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.2 KB
Raw Blame
//! Imports: the table, its placements, its rows and their cells, committed
//! together so a retry never finds half an import.

use models_databases::position::{key_between, keys_between};
use models_databases::{ColumnId, RowId};
use uuid::Uuid;

use super::*;
use crate::domain::journal::{CellImage, cell_value, created_table};
use crate::domain::models::{DatabaseId, Table, Viewer};
use crate::domain::transfer::{
    DatabaseTransferRepo, ImportFingerprint, ImportOutcome, ImportTable,
};
use crate::outbound::pg_databases_repo::{TableRecord, last_position, stored_positions, uuids};
use models_databases::position::Position;

/// Rows minted per `INSERT … UNNEST` statement.
const ROWS_PER_INSERT: usize = 500;

/// A `database_tables` row with the import key's fingerprint.
struct ImportedTableRecord {
    id: Uuid,
    database_id: Uuid,
    name: String,
    position: String,
    version: i64,
    import_fingerprint: Option<String>,
}

impl ImportedTableRecord {
    fn into_table(self) -> Result<(Table, Option<String>), PgDatabasesRepoError> {
        let fingerprint = self.import_fingerprint;
        let table = TableRecord {
            id: self.id,
            database_id: self.database_id,
            name: self.name,
            position: self.position,
            version: self.version,
        };
        Ok((table.try_into()?, fingerprint))
    }
}

impl<Properties> DatabaseTransferRepo for PgCellStore<Properties>
where
    Properties: PropertiesRepo<Err = anyhow::Error>
        + DatabaseCellWriter<Transaction = Transaction<'static, Postgres>>
        + Send
        + Sync
        + 'static,
{
    type Error = PgCellStoreError;

    #[tracing::instrument(err, skip(self))]
    async fn imported_table(
        &self,
        database_id: DatabaseId,
        request_id: Uuid,
    ) -> Result<Option<(Table, ImportFingerprint)>, Self::Error> {
        let imported = sqlx::query_as!(
            ImportedTableRecord,
            "SELECT id, database_id, name, position, version, import_fingerprint FROM database_tables WHERE database_id = $1 AND import_key = $2",
            database_id.into_uuid(),
            request_id,
        )
        .fetch_optional(&self.pool)
        .await?;
        imported
            .map(|record| {
                let (table, fingerprint) = record.into_table()?;
                let fingerprint =
                    fingerprint.ok_or(PgCellStoreError::MissingImportFingerprint(table.id))?;
                Ok((table, ImportFingerprint(fingerprint)))
            })
            .transpose()
    }

    #[tracing::instrument(err, skip(self, viewer, request, fingerprint, definitions, cells))]
    async fn import_table(
        &self,
        database_id: DatabaseId,
        viewer: &Viewer,
        request: &ImportTable,
        fingerprint: &ImportFingerprint,
        definitions: &[PropertyDefinitionId],
        cells: &[Vec<(PropertyDefinitionId, PropertyValue)>],
    ) -> Result<ImportOutcome, Self::Error> {
        let fingerprint = fingerprint.0.as_str();
        let mut transaction = self.pool.begin().await?;
        if !rows::lock_live_database(&mut transaction, database_id).await?
            || !schema::lock_database(&mut transaction, database_id, true).await?
        {
            return Ok(ImportOutcome::NotFound);
        }
        let replayed = sqlx::query_as!(
            ImportedTableRecord,
            "SELECT id, database_id, name, position, version, import_fingerprint FROM database_tables WHERE database_id = $1 AND import_key = $2",
            database_id.into_uuid(),
            request.request_id,
        )
        .fetch_optional(&mut *transaction)
        .await?;
        if let Some(record) = replayed {
            let (table, stored) = record.into_table()?;
            return Ok(if stored.as_deref() == Some(fingerprint) {
                ImportOutcome::Replayed(table)
            } else {
                ImportOutcome::KeyConflict
            });
        }
        let max_position = sqlx::query_scalar!(
            "SELECT MAX(position) FROM database_tables WHERE database_id = $1",
            database_id.into_uuid()
        )
        .fetch_one(&mut *transaction)
        .await?;
        let id = TableId::new();
        let position = last_position(max_position)
            .and_then(|last| key_between(last.as_ref(), None))
            .map_err(PgDatabasesRepoError::from)?;
        let table = sqlx::query_as!(
            TableRecord,
            r#"INSERT INTO database_tables (id, database_id, name, position, version, import_key, import_fingerprint)
               SELECT $1, $2, $3, $4, 1, $5, $6 WHERE NOT EXISTS (
                   SELECT 1 FROM database_tables WHERE database_id = $2 AND lower(name) = lower($3))
               RETURNING id, database_id, name, position, version"#,
            id.into_uuid(),
            database_id.into_uuid(),
            request.name,
            position.as_str(),
            request.request_id,
            fingerprint,
        )
        .fetch_optional(&mut *transaction)
        .await?;
        let Some(table) = table else {
            return Ok(ImportOutcome::NameConflict);
        };
        let column_positions =
            keys_between(None, None, definitions.len()).map_err(PgDatabasesRepoError::from)?;
        let mut columns = Vec::with_capacity(definitions.len());
        for (definition, position) in definitions.iter().zip(column_positions) {
            let column = ColumnId::new();
            columns.push(column);
            sqlx::query!(
                "INSERT INTO database_columns (id, table_id, property_definition_id, position, infer_type) VALUES ($1, $2, $3, $4, false)",
                column.into_uuid(),
                id.into_uuid(),
                definition,
                position.as_str(),
            )
            .execute(&mut *transaction)
            .await?;
        }
        let mut rows = Vec::with_capacity(request.rows.len());
        let mut row_positions = keys_between(None, None, request.rows.len())
            .map_err(PgDatabasesRepoError::from)?
            .into_iter();
        for batch in request.rows.chunks(ROWS_PER_INSERT) {
            let row_ids: Vec<RowId> = batch.iter().map(|_| RowId::new()).collect();
            let positions: Vec<Position> = row_positions.by_ref().take(batch.len()).collect();
            sqlx::query!(
                r#"INSERT INTO database_rows (id, table_id, position, created_by)
                   SELECT row_id, $1, position, $2 FROM UNNEST($3::uuid[], $4::text[]) AS data(row_id, position)"#,
                id.into_uuid(),
                viewer.user_id.as_ref(),
                &uuids(&row_ids),
                &stored_positions(&positions),
            )
            .execute(&mut *transaction)
            .await?;
            rows.extend(row_ids);
        }
        let column_ids: HashMap<_, _> = definitions
            .iter()
            .copied()
            .zip(columns.iter().copied())
            .collect();
        let mut after = CellImage::default();
        for (row, row_cells) in rows.iter().zip(cells) {
            for (definition, value) in row_cells {
                self.properties
                    .upsert_entity_property_in(
                        &mut transaction,
                        &row_entity(*row),
                        *definition,
                        Some(value.clone()),
                    )
                    .await
                    .map_err(cells_error)?;
                if let Some(column) = column_ids.get(definition)
                    && let Some(value) = cell_value(value)
                {
                    after.cells.entry(*row).or_default().insert(*column, value);
                }
            }
        }
        let table: Table = table.try_into().map_err(PgDatabasesRepoError::from)?;
        journal::record(
            &mut transaction,
            &JournalActor {
                user: Some(viewer.user_id.to_string()),
                acting_bot: viewer.acting_bot,
            },
            &[created_table(
                database_id,
                table.id,
                table.version,
                &columns,
                &rows,
                after,
            )],
        )
        .await?;
        transaction.commit().await?;
        Ok(ImportOutcome::Created(table))
    }
}