Create serverless index functionality

pinecone_sdk/src/control/create_index.rs

@@ -0,0 +1,172 @@
+use crate::pinecone::PineconeClient;
+use crate::utils::errors::PineconeError;
+use openapi::models::serverless_spec::Cloud;
+use openapi::models::create_index_request::Metric;
+use openapi::models::{CreateIndexRequest, CreateIndexRequestSpec, IndexModel, ServerlessSpec};
+
+impl PineconeClient {
+    /// Creates serverless index
+    pub async fn create_serverless_index(
+        &self,
+        name: &str,
+        dimension: u32, 
+        metric: Option<Metric>, 
+        cloud: Option<Cloud>,
+        region: &str
+    ) -> Result<IndexModel, PineconeError> {
+        // use defaults
+        let metric = metric.unwrap_or(Default::default());
+        let cloud = cloud.unwrap_or(Default::default());
+
+        // create request specs
+        let create_index_request_spec = CreateIndexRequestSpec {
+            serverless: Some(Box::new(ServerlessSpec {
+                cloud,
+                region: region.to_string(),
+            })),
+            pod: None,
+        };
+
+        let create_index_request = CreateIndexRequest {
+            name: name.to_string(),
+            dimension: dimension.try_into().unwrap(),
+            metric: Some(metric),
+            spec: Some(Box::new(create_index_request_spec)),
+        };
+
+        match openapi::apis::manage_indexes_api::create_index(
+            &self.openapi_config(),
+            create_index_request,
+        )
+        .await
+        {
+            Ok(index) => Ok(index),
+            Err(e) => Err(PineconeError::CreateIndexError { openapi_error: e }),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use core::panic;
+    use mockito::mock;
+    use tokio;
+
+    #[tokio::test]
+    async fn test_create_serverless_index() {
+        let _m = mock("POST", "/indexes")
+            .with_status(201)
+            .with_header("content-type", "application/json")
+            .with_body(
+                r#"
+                {
+                    "name": "index_name",
+                    "dimension": 10,
+                    "metric": "cosine",
+                    "host": "host1",
+                    "spec": {
+                        "serverless": {
+                            "cloud": "aws",
+                            "region": "us-east-1"
+                        }
+                    },
+                    "status": {
+                        "ready": true,
+                        "state": "Initializing"
+                    }
+                  }
+            "#,
+            )
+            .create();
+
+        let pinecone = PineconeClient::new(
+            Some("api_key".to_string()),
+            Some(mockito::server_url()),
+            None,
+            None,
+        );
+
+        let create_index_request = pinecone.unwrap().create_serverless_index(
+            "index_name",
+            10,
+            Some(Metric::Cosine),
+            Some(Cloud::Aws),
+            "us-east-1"
+        ).await;
+        assert!(create_index_request.is_ok());
+
+        let create_index_req = create_index_request.unwrap();
+        assert_eq!(create_index_req.name, "index_name");
+        assert_eq!(create_index_req.dimension, 10);
+        assert_eq!(create_index_req.metric, openapi::models::index_model::Metric::Cosine);
+
+        let spec = create_index_req.spec.serverless.unwrap();
+        assert_eq!(spec.cloud, openapi::models::serverless_spec::Cloud::Aws);
+        assert_eq!(spec.region, "us-east-1");
+    }
+
+    #[tokio::test]
+    async fn test_create_index_serverless() {
+        // Create a mock server
+        let _m = mock("POST", "/indexes")
+            .with_status(201)
+            .with_header("content-type", "application/json")
+            .with_body(
+                r#"
+                {
+                    "name": "index_name",
+                    "dimension": 10,
+                    "metric": "euclidean",
+                    "host": "host1",
+                    "spec": {
+                        "serverless": {
+                            "cloud": "aws",
+                            "region": "us-east-1"
+                        }
+                    },
+                    "status": {
+                        "ready": true,
+                        "state": "Initializing"
+                    }
+                  }
+            "#,
+            )
+            .create();
+
+        let pinecone = PineconeClient::new(
+            Some("api_key".to_string()),
+            Some(mockito::server_url()),
+            None,
+            None,
+        );
+
+        let name = "index_name";
+        let metric = Metric::Euclidean;
+        let cloud = Cloud::Aws;
+        let region = "us-east-1";
+
+        let result = pinecone.unwrap().create_serverless_index(
+            name,
+            10,
+            Some(metric), 
+            Some(cloud),
+            region).await;
+
+        match result {
+            Ok(index) => {
+                assert_eq!(index.name, name.to_string());
+                assert_eq!(index.dimension, 10);
+                assert_eq!(index.metric, openapi::models::index_model::Metric::Euclidean);
+                let spec = *index.spec;
+                let serverless_spec = spec.serverless.unwrap();
+                assert_eq!(
+                    serverless_spec.cloud,
+                    Cloud::Aws
+                );
+                assert_eq!(serverless_spec.region, region.to_string());
+            }
+            Err(e) => panic!("{}", e),
+        }
+    }
+}

pinecone_sdk/src/control/list_indexes.rs

@@ -1,10 +1,10 @@
-use crate::pinecone::Pinecone;
+use crate::pinecone::PineconeClient;
 use openapi::apis::manage_indexes_api;
 use openapi::apis::manage_indexes_api::ListIndexesError;
 use openapi::apis::Error;
 use openapi::models;
 
-impl Pinecone {
+impl PineconeClient {
     /// Lists all indexes.
     ///
     /// The results include a description of all indexes in your project, including the
@@ -17,12 +17,12 @@ impl Pinecone {
     /// ### Example
     ///
     /// ```
-    /// # use pinecone_sdk::pinecone::Pinecone;
+    /// # use pinecone_sdk::pinecone::PineconeClient;
     /// # use pinecone_sdk::utils::errors::PineconeError;
     /// # #[tokio::main]
     /// # async fn main() -> Result<(), PineconeError>{
     /// # // Create a Pinecone client with the API key and controller host.
-    /// # let pinecone = Pinecone::new(None, None, None, None).unwrap();
+    /// # let pinecone = PineconeClient::new(None, None, None, None).unwrap();
     /// #
     /// // List all indexes in the project.
     /// let index_list = pinecone.list_indexes();
@@ -31,7 +31,7 @@ impl Pinecone {
     /// ```
 
     pub async fn list_indexes(&self) -> Result<models::IndexList, Error<ListIndexesError>> {
-        let response = manage_indexes_api::list_indexes(self.openapi_config()).await?;
+        let response = manage_indexes_api::list_indexes(&self.openapi_config()).await?;
         println!("{:?}", response);
         Ok(response)
     }
@@ -87,7 +87,7 @@ mod tests {
 
         // Construct Pinecone instance with the mock server URL
         let api_key = "test_api_key".to_string();
-        let pinecone = Pinecone::new(Some(api_key), Some(mockito::server_url()), None, None)
+        let pinecone = PineconeClient::new(Some(api_key), Some(mockito::server_url()), None, None)
             .expect("Failed to create Pinecone instance");
 
         // Call list_indexes and verify the result

pinecone_sdk/src/control/mod.rs

@@ -1 +1,8 @@
-mod list_indexes;
+/// Module for creating an index.
+pub mod create_index;
+
+/// Module for listing all indexes.
+pub mod list_indexes;
+
+pub use openapi::models::create_index_request::Metric;
+pub use openapi::models::serverless_spec::Cloud;