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.

6.5 KB
Raw Blame
//! HTTP adapter for the document snapshot/update service.
use base64::{Engine, engine::general_purpose::STANDARD};
use futures::StreamExt;
use serde::{Deserialize, Serialize};

use super::document_effects::WorkerDocumentEffects;
use super::*;
use crate::{
    constants::SYSTEM_AUTHOR_ID,
    d1::insert_missing_user_mappings,
    domain::document::{self, DocumentError, MAX_BINARY_BYTES, MAX_REVISION_BYTES},
    storage::DocumentUpdateStorage,
};

const MAX_BODY_BYTES: usize = (MAX_BINARY_BYTES + MAX_REVISION_BYTES).div_ceil(3) * 4 + 1024;

#[derive(Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub(crate) struct UpdateRequest {
    expected_revision: String,
    update: String,
}

#[derive(Serialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub(crate) struct SnapshotResponse {
    snapshot: String,
    revision: String,
}

#[derive(Serialize)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
pub(crate) struct UpdateResponse {
    revision: String,
    applied: bool,
}

fn error_response(error: DocumentError) -> Result<Response> {
    let status = match error {
        DocumentError::Unauthorized => 401,
        DocumentError::Forbidden => 403,
        DocumentError::Conflict => 409,
        DocumentError::TooLarge => 413,
        DocumentError::Invalid(_) => 400,
        DocumentError::Persistence => 503,
        DocumentError::Notification => 500,
    };
    Ok(
        Response::from_json(&serde_json::json!({ "error": error.to_string() }))?
            .with_status(status),
    )
}

impl SyncSession {
    pub(in crate::inbound) async fn document_handler(
        &self,
        mut req: Request,
        document_id: &str,
        is_update: bool,
        access: crate::domain::document::DocumentAccess,
        claims: crate::auth::AuthToken,
    ) -> Result<Response> {
        if req.method() != if is_update { Method::Post } else { Method::Get } {
            return Ok(response(405));
        }
        if is_update && let Err(error) = access.require_edit() {
            return error_response(error);
        }
        if !self.exists(document_id).await? {
            return Ok(response(404));
        }
        if !is_update {
            let state = self.document_state().await?;
            let compact = req
                .url()?
                .query_pairs()
                .any(|(key, value)| key == "shallow" && value == "true");
            let snapshot = if compact {
                document::shallow_snapshot(&access, &state.loro_doc)
            } else {
                document::snapshot(&access, &state.loro_doc)
            };
            return match snapshot {
                Ok((snapshot, revision)) => Response::from_json(&SnapshotResponse {
                    snapshot: STANDARD.encode(snapshot),
                    revision: STANDARD.encode(revision),
                }),
                Err(error) => error_response(error),
            };
        }
        if req
            .headers()
            .get("content-length")?
            .and_then(|length| length.parse::<usize>().ok())
            .is_some_and(|length| length > MAX_BODY_BYTES)
        {
            return error_response(DocumentError::TooLarge);
        }
        let mut bytes = Vec::new();
        let mut stream = req.stream()?;
        while let Some(chunk) = stream.next().await {
            let chunk = chunk?;
            if bytes.len().saturating_add(chunk.len()) > MAX_BODY_BYTES {
                return error_response(DocumentError::TooLarge);
            }
            bytes.extend_from_slice(&chunk);
        }
        let body: UpdateRequest = match serde_json::from_slice(&bytes) {
            Ok(body) => body,
            Err(_) => return error_response(DocumentError::Invalid("Invalid update request.")),
        };
        if body.update.len() > MAX_BINARY_BYTES.div_ceil(3) * 4
            || body.expected_revision.len() > MAX_REVISION_BYTES.div_ceil(3) * 4
        {
            return error_response(DocumentError::TooLarge);
        }
        let (Ok(update), Ok(revision)) = (
            STANDARD.decode(body.update),
            STANDARD.decode(body.expected_revision),
        ) else {
            return error_response(DocumentError::Invalid("Invalid base64 update or revision."));
        };
        let state = self.document_state().await?;
        let storage = self.session_storage().await?;
        // Only agent actors are stored with the operation; humans are still editors.
        let is_agent = claims.actor.is_some();
        // Agents write for the user they act on behalf of; tokens without a user
        // are service writes.
        let author = claims
            .user_id
            .clone()
            .unwrap_or_else(|| SYSTEM_AUTHOR_ID.to_owned());
        let editor = match document::DocumentAttribution::from_session_claims(
            claims.actor,
            claims.user_id,
            claims.agent_correlation_id,
        ) {
            Ok(editor) => editor,
            Err(error) => return error_response(error),
        };
        let stored_attribution = if is_agent { editor.as_ref() } else { None };
        let port = DocumentUpdateStorage {
            document_state: &state,
            storage: &storage,
            attribution: stored_attribution,
        };
        let effects = WorkerDocumentEffects {
            session: self,
            document_state: &state,
            document_id,
            attribution: editor.as_ref(),
        };
        // The service synchronously compares + validates + imports before its
        // first storage await, just like a websocket update in this isolate.
        let prepared = match document::update(&access, &port, &effects, &revision, &update).await {
            Ok(prepared) => prepared,
            Err(error) => return error_response(error),
        };
        // Taken from the request, so a retry of an applied update still maps them.
        let writers = match document::writing_peers(&update) {
            Ok(writers) => writers,
            Err(error) => return error_response(error),
        };
        let db = self.env.d1(USER_PEER_D1_BINDING)?;
        insert_missing_user_mappings(
            &db,
            document_id,
            &author,
            stored_attribution.map(|attribution| attribution.actor.as_str()),
            &writers,
        )
        .await?;
        Response::from_json(&UpdateResponse {
            revision: STANDARD.encode(prepared.revision),
            applied: prepared.applied,
        })
    }
}