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.

3.7 KB
Raw Blame
use std::sync::Arc;

use anyhow::Context;
use aws_lambda_events::event::eventbridge::EventBridgeEvent;
use dynamodb_client::DynamodbClient;
use lambda_runtime::{
    Error, LambdaEvent, run, service_fn,
    tracing::{self},
};
use macro_entrypoint::MacroEntrypoint;
use macro_env_var::env_vars;
use models_bulk_upload::UploadFolderStatus;
use serde::{Deserialize, Serialize};

// see: https://docs.aws.amazon.com/AmazonS3/latest/userguide/ev-events.html
#[derive(Debug, Serialize, Deserialize)]
struct S3CreateObjectDetail {
    bucket: Bucket,
    object: Object,
}

#[derive(Debug, Serialize, Deserialize)]
struct Bucket {
    name: String,
}

#[derive(Debug, Serialize, Deserialize)]
struct Object {
    key: String,
}

#[tracing::instrument(skip_all)]
async fn handler(
    dynamodb_client: Arc<DynamodbClient>,
    sqs_client: Arc<sqs_client::SQS>,
    event: LambdaEvent<EventBridgeEvent<S3CreateObjectDetail>>,
) -> Result<(), Error> {
    let key = event.payload.detail.object.key;

    let staging_key = s3_key::BulkUploadStagingKey::from_s3_key(&key).map_err(|e| {
        tracing::warn!(error=?e, key=%key, "skipping non-extract key");
        Error::from("key is not a bulk upload staging key")
    })?;

    let upload_request_id = staging_key.request_id.as_str();

    tracing::info!("Processing request: {}", upload_request_id);

    let bulk_upload_request = dynamodb_client
        .bulk_upload
        .get_bulk_upload_request(upload_request_id)
        .await
        .inspect_err(|e| tracing::error!("Failed to get request info: {:?}", e))?;

    tracing::info!(
        "Received request info from dynamodb {:?}",
        bulk_upload_request
    );

    dynamodb_client
        .bulk_upload
        .update_bulk_upload_request_status(
            &bulk_upload_request.request_id,
            UploadFolderStatus::Uploaded,
            None,
            None,
        )
        .await
        .inspect_err(|e| tracing::error!("Failed to update status: {:?}", e))?;

    tracing::info!("Updated upload status for request {}", upload_request_id);

    sqs_client
        .enqueue_upload_extractor_unzip(
            upload_request_id,
            &staging_key.to_key(),
            bulk_upload_request.user_id.as_str(),
            &bulk_upload_request.name,
            &bulk_upload_request.parent_id,
        )
        .await
        .inspect_err(|e| tracing::error!("Failed to enqueue job: {:?}", e))?;

    tracing::info!("Finished processing request {}", upload_request_id);

    Ok(())
}

env_vars! {
    pub struct DynamodbTable;
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    MacroEntrypoint::default().init();
    tracing::info!("initiating lambda");

    let dynamo_table_name = DynamodbTable::new().context("DYNAMODB_TABLE must be set")?;
    let upload_extract_queue = macro_queues::UploadExtractorQueue::new();

    tracing::trace!("initialized env vars");

    let config = macro_aws_config::get_macro_aws_config().await;
    let dynamodb_client = DynamodbClient::new(&config, Some(dynamo_table_name.to_string()));

    tracing::trace!("initialized dynamodb client");

    let sqs_client = sqs_client::SQS::new(aws_sdk_sqs::Client::new(&config))
        .upload_extractor_queue(&upload_extract_queue);

    tracing::trace!("initialized sqs client");

    // Shared references
    let shared_sqs_client = Arc::new(sqs_client);
    let shared_dynamodb_client = Arc::new(dynamodb_client);

    let func = service_fn(
        move |event: LambdaEvent<EventBridgeEvent<S3CreateObjectDetail>>| {
            let sqs_client = shared_sqs_client.clone();
            let dynamodb_client = shared_dynamodb_client.clone();
            async move { handler(dynamodb_client, sqs_client, event).await }
        },
    );

    run(func).await
}