fmp-rs 0.1.1

Production-grade Rust client for Financial Modeling Prep API with intelligent caching, rate limiting, and comprehensive endpoint coverage
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

//! Company search endpoints

use crate::client::FmpClient;
use crate::error::Result;
use crate::models::company::CompanySearchResult;
use serde::Serialize;

/// Company search API endpoints
pub struct CompanySearch {
    client: FmpClient,
}

impl CompanySearch {
    pub(crate) fn new(client: FmpClient) -> Self {
        Self { client }
    }

    /// Search for companies by name or symbol
    ///
    /// # Example
    /// ```no_run
    /// # use fmp_rs::FmpClient;
    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
    /// let client = FmpClient::new()?;
    /// let results = client.company_search().search("Apple", None, None).await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn search(
        &self,
        query: &str,
        limit: Option<u32>,
        exchange: Option<&str>,
    ) -> Result<Vec<CompanySearchResult>> {
        #[derive(Serialize)]
        struct Query<'a> {
            query: &'a str,
            #[serde(skip_serializing_if = "Option::is_none")]
            limit: Option<u32>,
            #[serde(skip_serializing_if = "Option::is_none")]
            exchange: Option<&'a str>,
            apikey: &'a str,
        }

        let url = self.client.build_url("/search");
        self.client
            .get_with_query(
                &url,
                &Query {
                    query,
                    limit,
                    exchange,
                    apikey: self.client.api_key(),
                },
            )
            .await
    }

    /// Search for companies by ticker symbol
    pub async fn search_symbol(
        &self,
        query: &str,
        limit: Option<u32>,
        exchange: Option<&str>,
    ) -> Result<Vec<CompanySearchResult>> {
        #[derive(Serialize)]
        struct Query<'a> {
            query: &'a str,
            #[serde(skip_serializing_if = "Option::is_none")]
            limit: Option<u32>,
            #[serde(skip_serializing_if = "Option::is_none")]
            exchange: Option<&'a str>,
            apikey: &'a str,
        }

        let url = self.client.build_url("/search-symbol");
        self.client
            .get_with_query(
                &url,
                &Query {
                    query,
                    limit,
                    exchange,
                    apikey: self.client.api_key(),
                },
            )
            .await
    }

    /// Search for companies by CIK number
    pub async fn search_cik(
        &self,
        cik: &str,
        limit: Option<u32>,
    ) -> Result<Vec<CompanySearchResult>> {
        #[derive(Serialize)]
        struct Query<'a> {
            cik: &'a str,
            #[serde(skip_serializing_if = "Option::is_none")]
            limit: Option<u32>,
            apikey: &'a str,
        }

        let url = self.client.build_url("/search-cik");
        self.client
            .get_with_query(
                &url,
                &Query {
                    cik,
                    limit,
                    apikey: self.client.api_key(),
                },
            )
            .await
    }

    /// Search for companies by CUSIP
    pub async fn search_cusip(&self, cusip: &str) -> Result<Vec<CompanySearchResult>> {
        #[derive(Serialize)]
        struct Query<'a> {
            cusip: &'a str,
            apikey: &'a str,
        }

        let url = self.client.build_url("/search-cusip");
        self.client
            .get_with_query(
                &url,
                &Query {
                    cusip,
                    apikey: self.client.api_key(),
                },
            )
            .await
    }

    /// Search for companies by ISIN
    pub async fn search_isin(&self, isin: &str) -> Result<Vec<CompanySearchResult>> {
        #[derive(Serialize)]
        struct Query<'a> {
            isin: &'a str,
            apikey: &'a str,
        }

        let url = self.client.build_url("/search-isin");
        self.client
            .get_with_query(
                &url,
                &Query {
                    isin,
                    apikey: self.client.api_key(),
                },
            )
            .await
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    #[ignore = "requires FMP API key"]
    async fn test_search() {
        let client = FmpClient::new().unwrap();
        let results = client
            .company_search()
            .search("Apple", Some(10), None)
            .await;
        assert!(results.is_ok());
    }

    #[test]
    fn test_search_builds_correct_url() {
        let client = FmpClient::builder().api_key("test_key").build().unwrap();
        let search = CompanySearch::new(client);
        // Just verify we can create the search instance
        assert_eq!(search.client.api_key(), "test_key");
    }
}