Add BulkDeleteDatastoreItems to Datastore API spec (#944)

Co-authored-by: ci.datadog-api-spec <[email protected]>

Author: api-clients-generation-pipeline[bot]

.generator/schemas/v2/openapi.yaml

@@ -6553,6 +6553,46 @@ components:
           description: The type of the object, must be `budget`.
           type: string
       type: object
+    BulkDeleteAppsDatastoreItemsRequest:
+      description: Request to delete items from a datastore.
+      properties:
+        data:
+          $ref: '#/components/schemas/BulkDeleteAppsDatastoreItemsRequestData'
+      type: object
+    BulkDeleteAppsDatastoreItemsRequestData:
+      description: Data wrapper containing the data needed to delete items from a
+        datastore.
+      properties:
+        attributes:
+          $ref: '#/components/schemas/BulkDeleteAppsDatastoreItemsRequestDataAttributes'
+        id:
+          description: ID for the datastore of the items to delete.
+          type: string
+        type:
+          $ref: '#/components/schemas/BulkDeleteAppsDatastoreItemsRequestDataType'
+      required:
+      - type
+      type: object
+    BulkDeleteAppsDatastoreItemsRequestDataAttributes:
+      description: Attributes of request data to delete items from a datastore.
+      properties:
+        item_keys:
+          description: List of primary keys identifying items to delete from datastore.
+            Up to 100 items can be deleted in a single request.
+          items:
+            type: string
+          maxItems: 100
+          type: array
+      type: object
+    BulkDeleteAppsDatastoreItemsRequestDataType:
+      default: items
+      description: Items resource type.
+      enum:
+      - items
+      example: items
+      type: string
+      x-enum-varnames:
+      - ITEMS
     BulkMuteFindingsRequest:
       description: The new bulk mute finding request.
       properties:
@@ -14869,6 +14909,17 @@ components:
         data:
           $ref: '#/components/schemas/DeleteAppsDatastoreItemResponseData'
       type: object
+    DeleteAppsDatastoreItemResponseArray:
+      description: The definition of `DeleteAppsDatastoreItemResponseArray` object.
+      properties:
+        data:
+          description: The `DeleteAppsDatastoreItemResponseArray` `data`.
+          items:
+            $ref: '#/components/schemas/DeleteAppsDatastoreItemResponseData'
+          type: array
+      required:
+      - data
+      type: object
     DeleteAppsDatastoreItemResponseData:
       description: Data containing the identifier of the datastore item that was successfully
         deleted.
@@ -51257,6 +51308,57 @@ paths:
         permissions:
         - apps_datastore_write
   /api/v2/actions-datastores/{datastore_id}/items/bulk:
+    delete:
+      description: Deletes multiple items from a datastore by their keys in a single
+        operation.
+      operationId: BulkDeleteDatastoreItems
+      parameters:
+      - description: The ID of the datastore.
+        in: path
+        name: datastore_id
+        required: true
+        schema:
+          type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/BulkDeleteAppsDatastoreItemsRequest'
+        required: true
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/DeleteAppsDatastoreItemResponseArray'
+          description: OK
+        '400':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/JSONAPIErrorResponse'
+          description: Bad Request
+        '404':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/JSONAPIErrorResponse'
+          description: Not Found
+        '429':
+          $ref: '#/components/responses/TooManyRequestsResponse'
+        '500':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/JSONAPIErrorResponse'
+          description: Internal Server Error
+      summary: Bulk delete datastore items
+      tags:
+      - Actions Datastores
+      x-permission:
+        operator: OR
+        permissions:
+        - apps_datastore_write
     post:
       description: Creates or replaces multiple items in a datastore by their keys
         in a single operation.

examples/v2_actions-datastores_BulkDeleteDatastoreItems.rs

@@ -0,0 +1,32 @@
+// Bulk delete datastore items returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_actions_datastores::ActionsDatastoresAPI;
+use datadog_api_client::datadogV2::model::BulkDeleteAppsDatastoreItemsRequest;
+use datadog_api_client::datadogV2::model::BulkDeleteAppsDatastoreItemsRequestData;
+use datadog_api_client::datadogV2::model::BulkDeleteAppsDatastoreItemsRequestDataAttributes;
+use datadog_api_client::datadogV2::model::BulkDeleteAppsDatastoreItemsRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "datastore" in the system
+    let datastore_data_id = std::env::var("DATASTORE_DATA_ID").unwrap();
+    let body = BulkDeleteAppsDatastoreItemsRequest::new().data(
+        BulkDeleteAppsDatastoreItemsRequestData::new(
+            BulkDeleteAppsDatastoreItemsRequestDataType::ITEMS,
+        )
+        .attributes(
+            BulkDeleteAppsDatastoreItemsRequestDataAttributes::new()
+                .item_keys(vec!["test-key".to_string()]),
+        ),
+    );
+    let configuration = datadog::Configuration::new();
+    let api = ActionsDatastoresAPI::with_config(configuration);
+    let resp = api
+        .bulk_delete_datastore_items(datastore_data_id.clone(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadogV2/api/api_actions_datastores.rs

@@ -54,6 +54,15 @@ impl ListDatastoreItemsOptionalParams {
     }
 }
 
+/// BulkDeleteDatastoreItemsError is a struct for typed errors of method [`ActionsDatastoresAPI::bulk_delete_datastore_items`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum BulkDeleteDatastoreItemsError {
+    JSONAPIErrorResponse(crate::datadogV2::model::JSONAPIErrorResponse),
+    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
 /// BulkWriteDatastoreItemsError is a struct for typed errors of method [`ActionsDatastoresAPI::bulk_write_datastore_items`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -200,6 +209,167 @@ impl ActionsDatastoresAPI {
         Self { config, client }
     }
 
+    /// Deletes multiple items from a datastore by their keys in a single operation.
+    pub async fn bulk_delete_datastore_items(
+        &self,
+        datastore_id: String,
+        body: crate::datadogV2::model::BulkDeleteAppsDatastoreItemsRequest,
+    ) -> Result<
+        crate::datadogV2::model::DeleteAppsDatastoreItemResponseArray,
+        datadog::Error<BulkDeleteDatastoreItemsError>,
+    > {
+        match self
+            .bulk_delete_datastore_items_with_http_info(datastore_id, body)
+            .await
+        {
+            Ok(response_content) => {
+                if let Some(e) = response_content.entity {
+                    Ok(e)
+                } else {
+                    Err(datadog::Error::Serde(serde::de::Error::custom(
+                        "response content was None",
+                    )))
+                }
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    /// Deletes multiple items from a datastore by their keys in a single operation.
+    pub async fn bulk_delete_datastore_items_with_http_info(
+        &self,
+        datastore_id: String,
+        body: crate::datadogV2::model::BulkDeleteAppsDatastoreItemsRequest,
+    ) -> Result<
+        datadog::ResponseContent<crate::datadogV2::model::DeleteAppsDatastoreItemResponseArray>,
+        datadog::Error<BulkDeleteDatastoreItemsError>,
+    > {
+        let local_configuration = &self.config;
+        let operation_id = "v2.bulk_delete_datastore_items";
+
+        let local_client = &self.client;
+
+        let local_uri_str = format!(
+            "{}/api/v2/actions-datastores/{datastore_id}/items/bulk",
+            local_configuration.get_operation_host(operation_id),
+            datastore_id = datadog::urlencode(datastore_id)
+        );
+        let mut local_req_builder =
+            local_client.request(reqwest::Method::DELETE, local_uri_str.as_str());
+
+        // build headers
+        let mut headers = HeaderMap::new();
+        headers.insert("Content-Type", HeaderValue::from_static("application/json"));
+        headers.insert("Accept", HeaderValue::from_static("application/json"));
+
+        // build user agent
+        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
+            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
+            Err(e) => {
+                log::warn!("Failed to parse user agent header: {e}, falling back to default");
+                headers.insert(
+                    reqwest::header::USER_AGENT,
+                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
+                )
+            }
+        };
+
+        // build auth
+        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
+            headers.insert(
+                "DD-API-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-API-KEY header"),
+            );
+        };
+        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
+            headers.insert(
+                "DD-APPLICATION-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-APPLICATION-KEY header"),
+            );
+        };
+
+        // build body parameters
+        let output = Vec::new();
+        let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter);
+        if body.serialize(&mut ser).is_ok() {
+            if let Some(content_encoding) = headers.get("Content-Encoding") {
+                match content_encoding.to_str().unwrap_or_default() {
+                    "gzip" => {
+                        let mut enc = GzEncoder::new(Vec::new(), Compression::default());
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    "deflate" => {
+                        let mut enc = ZlibEncoder::new(Vec::new(), Compression::default());
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    "zstd1" => {
+                        let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap();
+                        let _ = enc.write_all(ser.into_inner().as_slice());
+                        match enc.finish() {
+                            Ok(buf) => {
+                                local_req_builder = local_req_builder.body(buf);
+                            }
+                            Err(e) => return Err(datadog::Error::Io(e)),
+                        }
+                    }
+                    _ => {
+                        local_req_builder = local_req_builder.body(ser.into_inner());
+                    }
+                }
+            } else {
+                local_req_builder = local_req_builder.body(ser.into_inner());
+            }
+        }
+
+        local_req_builder = local_req_builder.headers(headers);
+        let local_req = local_req_builder.build()?;
+        log::debug!("request content: {:?}", local_req.body());
+        let local_resp = local_client.execute(local_req).await?;
+
+        let local_status = local_resp.status();
+        let local_content = local_resp.text().await?;
+        log::debug!("response content: {}", local_content);
+
+        if !local_status.is_client_error() && !local_status.is_server_error() {
+            match serde_json::from_str::<
+                crate::datadogV2::model::DeleteAppsDatastoreItemResponseArray,
+            >(&local_content)
+            {
+                Ok(e) => {
+                    return Ok(datadog::ResponseContent {
+                        status: local_status,
+                        content: local_content,
+                        entity: Some(e),
+                    })
+                }
+                Err(e) => return Err(datadog::Error::Serde(e)),
+            };
+        } else {
+            let local_entity: Option<BulkDeleteDatastoreItemsError> =
+                serde_json::from_str(&local_content).ok();
+            let local_error = datadog::ResponseContent {
+                status: local_status,
+                content: local_content,
+                entity: local_entity,
+            };
+            Err(datadog::Error::ResponseError(local_error))
+        }
+    }
+
     /// Creates or replaces multiple items in a datastore by their keys in a single operation.
     pub async fn bulk_write_datastore_items(
         &self,

src/datadogV2/model/mod.rs

@@ -78,6 +78,16 @@ pub mod model_update_apps_datastore_item_request_data_type;
 pub use self::model_update_apps_datastore_item_request_data_type::UpdateAppsDatastoreItemRequestDataType;
 pub mod model_item_api_payload;
 pub use self::model_item_api_payload::ItemApiPayload;
+pub mod model_bulk_delete_apps_datastore_items_request;
+pub use self::model_bulk_delete_apps_datastore_items_request::BulkDeleteAppsDatastoreItemsRequest;
+pub mod model_bulk_delete_apps_datastore_items_request_data;
+pub use self::model_bulk_delete_apps_datastore_items_request_data::BulkDeleteAppsDatastoreItemsRequestData;
+pub mod model_bulk_delete_apps_datastore_items_request_data_attributes;
+pub use self::model_bulk_delete_apps_datastore_items_request_data_attributes::BulkDeleteAppsDatastoreItemsRequestDataAttributes;
+pub mod model_bulk_delete_apps_datastore_items_request_data_type;
+pub use self::model_bulk_delete_apps_datastore_items_request_data_type::BulkDeleteAppsDatastoreItemsRequestDataType;
+pub mod model_delete_apps_datastore_item_response_array;
+pub use self::model_delete_apps_datastore_item_response_array::DeleteAppsDatastoreItemResponseArray;
 pub mod model_bulk_put_apps_datastore_items_request;
 pub use self::model_bulk_put_apps_datastore_items_request::BulkPutAppsDatastoreItemsRequest;
 pub mod model_bulk_put_apps_datastore_items_request_data;