Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

8.0 KB
Raw Blame
use super::delete_item::delete_item;
use super::get_item;
use super::mark_uploaded;
use super::model::DeleteError;
use super::model::MetadataObject;
use super::put_item;
use anyhow::{Context, Result, format_err};
use aws_sdk_dynamodb::Client;
use aws_sdk_dynamodb::types::AttributeValue;
use serde_dynamo::{Item, from_item, to_item};
use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct DynamodbClient {
    table: String,
    client: Client,
}

impl DynamodbClient {
    /// Create a new DynamodbClient with the given AWS config and table name.
    pub fn new(aws_config: &macro_aws_config::SdkConfig, table: String) -> Self {
        let client = Client::new(aws_config);
        DynamodbClient { client, table }
    }

    #[tracing::instrument(skip(self))]
    pub async fn put_metadata(&self, metadata: MetadataObject) -> Result<()> {
        let item: Item = to_item(metadata).context("failed to convert metadata object")?;
        put_item::put_item(&self.client, &self.table, item).await?;
        Ok(())
    }

    #[tracing::instrument(skip(self))]
    pub async fn get_metadata(&self, id: &str) -> Result<Option<MetadataObject>> {
        let record = get_item::get_metadata_by_id(&self.client, &self.table, id).await?;
        if let Some(data) = record {
            from_item(data)
                .map_err(|e| format_err!("failed to deserialize metadata: {}", e))
                .map(Some)
        } else {
            Ok(None)
        }
    }

    #[tracing::instrument(skip(self))]
    pub async fn delete_metadata(&self, id: &str) -> Result<(), DeleteError> {
        delete_item(&self.client, &self.table, id).await
    }

    #[tracing::instrument(skip(self))]
    pub async fn update_last_accessed(&self, id: &str) -> Result<Option<()>> {
        Ok(None)
    }

    #[tracing::instrument(skip(self))]
    pub async fn mark_uploaded(&self, id: &str) -> Result<()> {
        mark_uploaded::mark_uploaded(&self.client, &self.table, id).await
    }

    #[tracing::instrument(skip(self), fields(count = file_ids.len()), err)]
    pub async fn bulk_get_metadata(
        &self,
        file_ids: &[String],
    ) -> Result<HashMap<String, MetadataObject>> {
        if file_ids.is_empty() {
            return Ok(HashMap::new());
        }

        // DynamoDB batch_get_item has a limit of 100 items
        let chunk_size = 100;
        let mut all_results = HashMap::new();

        for chunk in file_ids.chunks(chunk_size) {
            let mut keys = Vec::new();
            for file_id in chunk {
                let mut key = HashMap::new();
                key.insert("file_id".to_string(), AttributeValue::S(file_id.clone()));
                keys.push(key);
            }

            let request_items = {
                let mut request_items = HashMap::new();
                request_items.insert(
                    self.table.clone(),
                    aws_sdk_dynamodb::types::KeysAndAttributes::builder()
                        .set_keys(Some(keys))
                        .build()?,
                );
                request_items
            };

            let response = self
                .client
                .batch_get_item()
                .set_request_items(Some(request_items))
                .send()
                .await?;

            if let Some(responses) = response.responses()
                && let Some(items) = responses.get(&self.table)
            {
                for item in items {
                    let metadata: MetadataObject =
                        from_item(item.clone()).context("failed to deserialize metadata")?;
                    all_results.insert(metadata.file_id.clone(), metadata);
                }
            }
        }

        Ok(all_results)
    }

    #[tracing::instrument(skip(self), fields(count = file_ids.len()))]
    pub async fn bulk_delete_metadata(&self, file_ids: &[&str]) -> Vec<Result<(), DeleteError>> {
        if file_ids.is_empty() {
            return Vec::new();
        }

        // DynamoDB batch_write_item has a limit of 25 items per request
        const BATCH_SIZE: usize = 25;
        let mut results = Vec::with_capacity(file_ids.len());

        // Initialize results as success, will mark failures later
        for _ in 0..file_ids.len() {
            results.push(Ok(()));
        }

        for (chunk_idx, chunk) in file_ids.chunks(BATCH_SIZE).enumerate() {
            let base_idx = chunk_idx * BATCH_SIZE;

            // Build delete requests
            let mut write_requests = Vec::new();
            for file_id in chunk {
                let mut key = HashMap::new();
                key.insert(
                    "file_id".to_string(),
                    AttributeValue::S(file_id.to_string()),
                );

                let delete_request = aws_sdk_dynamodb::types::DeleteRequest::builder()
                    .set_key(Some(key))
                    .build()
                    .context("failed to build DeleteRequest");

                match delete_request {
                    Ok(del_req) => {
                        write_requests.push(
                            aws_sdk_dynamodb::types::WriteRequest::builder()
                                .delete_request(del_req)
                                .build(),
                        );
                    }
                    Err(e) => {
                        tracing::error!(file_id = file_id, error = ?e, "failed to build delete request");
                        results[base_idx + write_requests.len()] =
                            Err(DeleteError::Other(e.to_string()));
                    }
                }
            }

            if write_requests.is_empty() {
                continue;
            }

            let mut request_items = HashMap::new();
            request_items.insert(self.table.clone(), write_requests);

            // Execute batch write
            match self
                .client
                .batch_write_item()
                .set_request_items(Some(request_items.clone()))
                .send()
                .await
            {
                Ok(response) => {
                    // Handle unprocessed items
                    if let Some(unprocessed) = response.unprocessed_items()
                        && let Some(unprocessed_writes) = unprocessed.get(&self.table)
                        && !unprocessed_writes.is_empty()
                    {
                        tracing::warn!(
                            count = unprocessed_writes.len(),
                            "batch delete had unprocessed items, marking as errors"
                        );

                        // Mark unprocessed items as failures
                        for write_req in unprocessed_writes {
                            if let Some(del_req) = write_req.delete_request() {
                                let key = del_req.key();
                                if let Some(AttributeValue::S(file_id)) = key.get("file_id") {
                                    // Find the index of this file_id in the chunk
                                    if let Some(local_idx) =
                                        chunk.iter().position(|id| *id == file_id.as_str())
                                    {
                                        results[base_idx + local_idx] = Err(DeleteError::Other(
                                            "unprocessed by DynamoDB".to_string(),
                                        ));
                                    }
                                }
                            }
                        }
                    }
                }
                Err(e) => {
                    tracing::error!(error = ?e, "batch delete request failed");
                    // Mark all items in this chunk as failed
                    for (i, _) in chunk.iter().enumerate() {
                        results[base_idx + i] =
                            Err(DeleteError::Other(format!("batch delete failed: {}", e)));
                    }
                }
            }
        }

        results
    }
}