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.

10.2 KB
Raw Blame
//! Starter provisioning: the database, its schema, rows, cells and views
//! commit together, so a retry never finds half an example.

#[cfg(test)]
mod test;
use models_databases::position::{PositionError, keys_between};
use models_databases::{ColumnId, DatabaseId, OptionId, RowId};
use models_properties::DataType;
use models_properties::EntityReference;
use models_properties::service::property_option::PropertyOptionValue;
use models_properties::service::property_value::PropertyValue;
use properties::domain::database_cell_writer::DatabaseCellWriter;
use properties::domain::database_definition_writer::{
    DatabaseDefinitionWriter, NewDatabaseDefinition,
};
use sqlx::{PgPool, Postgres, Transaction};

use crate::domain::journal::{CellImage, JournalActor, cell_value, created_table};
use crate::domain::models::Viewer;
use crate::domain::starter::{DatabaseStarterRepo, StarterBlueprint, StarterDatabase};
use crate::outbound::pg_databases_repo::{
    PgDatabasesRepoError, insert_column, insert_owned_database, journal, rows, views,
};

/// Starter seeding errors; any of them rolls the whole seed back.
#[derive(Debug, thiserror::Error)]
pub enum PgStarterError {
    /// A statement of the seed failed.
    #[error(transparent)]
    Sqlx(#[from] sqlx::Error),
    /// The properties writer failed.
    #[error("starter dependency failed: {0}")]
    Dependency(#[source] Box<dyn std::error::Error + Send + Sync>),
    /// A repository statement of the seed failed.
    #[error("starter statement failed: {0}")]
    Repository(#[from] PgDatabasesRepoError),
    /// The seed's positions could not be minted.
    #[error("starter positions failed: {0}")]
    Position(#[from] PositionError),
    /// A seed row names a stage the blueprint does not have.
    #[error("starter row names stage {0}, which the blueprint does not have")]
    MissingStage(usize),
}

/// [`DatabaseStarterRepo`] over Postgres and the properties writers.
pub struct PgDatabaseStarterRepo<Properties> {
    pool: PgPool,
    properties: Properties,
}

impl<Properties> PgDatabaseStarterRepo<Properties> {
    /// Wrap the pool and the properties writers.
    pub fn new(pool: PgPool, properties: Properties) -> Self {
        Self { pool, properties }
    }
}

fn dependency(error: impl std::error::Error + Send + Sync + 'static) -> PgStarterError {
    PgStarterError::Dependency(Box::new(error))
}

impl<Properties> DatabaseStarterRepo for PgDatabaseStarterRepo<Properties>
where
    Properties: DatabaseDefinitionWriter<Transaction = Transaction<'static, Postgres>>
        + DatabaseCellWriter<Transaction = Transaction<'static, Postgres>>
        + Send
        + Sync
        + 'static,
{
    type Error = PgStarterError;

    #[tracing::instrument(err, skip(self, viewer, blueprint))]
    async fn ensure_starter(
        &self,
        viewer: &Viewer,
        blueprint: &StarterBlueprint,
    ) -> Result<StarterDatabase, Self::Error> {
        let mut transaction = self.pool.begin().await?;
        let user_id = viewer.user_id.as_ref();
        let claimed = sqlx::query_scalar!(
            "INSERT INTO database_starter_seeds (user_id) VALUES ($1) ON CONFLICT (user_id) DO NOTHING RETURNING user_id",
            user_id,
        )
        .fetch_optional(&mut *transaction)
        .await?
        .is_some();
        if !claimed {
            let database_id = sqlx::query_scalar!(
                r#"SELECT d.database_id FROM database_starter_seeds s JOIN database_entities d ON d.database_id = s.database_id
                   WHERE s.user_id = $1 AND d.trashed_at IS NULL"#,
                user_id,
            )
            .fetch_optional(&mut *transaction)
            .await?;
            return Ok(StarterDatabase {
                database_id: database_id.map(DatabaseId::from_uuid),
                table_id: None,
                view_id: None,
                created: false,
            });
        }
        // Existing and trashed databases both mean the user already started.
        if sqlx::query_scalar!(
            "SELECT EXISTS(SELECT 1 FROM database_entities WHERE user_id = $1) AS \"exists!\"",
            user_id
        )
        .fetch_one(&mut *transaction)
        .await?
        {
            transaction.commit().await?;
            return Ok(StarterDatabase {
                database_id: None,
                table_id: None,
                view_id: None,
                created: false,
            });
        }
        let database_id = blueprint.database_id;
        let table_id = blueprint.table_id;
        insert_owned_database(
            &mut transaction,
            database_id,
            blueprint.name,
            user_id,
            table_id,
            blueprint.table_name,
        )
        .await?;
        let title = self
            .properties
            .create_database_definition_in(
                &mut transaction,
                NewDatabaseDefinition {
                    id: macro_uuid::generate_uuid_v7(),
                    database_id: database_id.into_uuid(),
                    name: blueprint.title_name,
                    data_type: DataType::String,
                    is_multi_select: false,
                    specific_entity_type: None,
                    options: &[],
                },
            )
            .await
            .map_err(dependency)?;
        let stage_options: Vec<(uuid::Uuid, PropertyOptionValue)> = blueprint
            .stages
            .iter()
            .map(|stage| {
                (
                    OptionId::new().into_uuid(),
                    PropertyOptionValue::String((*stage).to_string()),
                )
            })
            .collect();
        let stage = self
            .properties
            .create_database_definition_in(
                &mut transaction,
                NewDatabaseDefinition {
                    id: macro_uuid::generate_uuid_v7(),
                    database_id: database_id.into_uuid(),
                    name: blueprint.stage_name,
                    data_type: DataType::SelectString,
                    is_multi_select: false,
                    specific_entity_type: None,
                    options: &stage_options,
                },
            )
            .await
            .map_err(dependency)?;
        let title_column_id = ColumnId::new();
        let stage_column_id = ColumnId::new();
        let column_positions = keys_between(None, None, 2)?;
        for ((column_id, definition_id), position) in [
            (title_column_id, title.definition.id),
            (stage_column_id, stage.definition.id),
        ]
        .into_iter()
        .zip(column_positions)
        {
            insert_column(
                &mut transaction,
                column_id,
                table_id,
                definition_id,
                &position,
                false,
            )
            .await?;
        }
        let version = rows::bump_table_version(&mut *transaction, table_id)
            .await
            .map_err(PgDatabasesRepoError::from)?;
        let mut seeded = Vec::with_capacity(blueprint.rows.len());
        let mut after = CellImage::default();
        let positions = keys_between(None, None, blueprint.rows.len())?;
        for ((name, stage_index), position) in blueprint.rows.iter().zip(positions) {
            let stage_option = stage
                .property_options
                .get(*stage_index)
                .ok_or(PgStarterError::MissingStage(*stage_index))?;
            let row_id = RowId::new();
            seeded.push(row_id);
            sqlx::query!(
                "INSERT INTO database_rows (id, table_id, position, created_by) VALUES ($1, $2, $3, $4)",
                row_id.into_uuid(),
                table_id.into_uuid(),
                position.as_str(),
                user_id,
            )
            .execute(&mut *transaction)
            .await?;
            let row = EntityReference {
                entity_id: row_id.to_string(),
                entity_type: models_properties::EntityType::DatabaseRow,
                specific_message_id: None,
            };
            for (column_id, definition_id, value) in [
                (
                    title_column_id,
                    title.definition.id,
                    PropertyValue::Str((*name).into()),
                ),
                (
                    stage_column_id,
                    stage.definition.id,
                    PropertyValue::SelectOption(vec![stage_option.id]),
                ),
            ] {
                if let Some(written) = cell_value(&value) {
                    after
                        .cells
                        .entry(row_id)
                        .or_default()
                        .insert(column_id, written);
                }
                self.properties
                    .upsert_entity_property_in(&mut transaction, &row, definition_id, Some(value))
                    .await
                    .map_err(dependency)?;
            }
        }
        let stage_options: Vec<_> = stage
            .property_options
            .iter()
            .map(|option| OptionId::from_uuid(option.id))
            .collect();
        let [table_view, board] = blueprint.views(
            title_column_id,
            stage_column_id,
            &stage_options,
            models_databases::views::written_at(),
        )?;
        views::insert_view(&mut *transaction, &table_view).await?;
        views::insert_view(&mut *transaction, &board).await?;
        journal::record(
            &mut transaction,
            &JournalActor {
                user: Some(user_id.to_string()),
                acting_bot: None,
            },
            &[created_table(
                database_id,
                table_id,
                version,
                &[title_column_id, stage_column_id],
                &seeded,
                after,
            )],
        )
        .await?;
        sqlx::query!(
            "UPDATE database_starter_seeds SET database_id = $2 WHERE user_id = $1",
            user_id,
            database_id.into_uuid()
        )
        .execute(&mut *transaction)
        .await?;
        transaction.commit().await?;
        Ok(StarterDatabase {
            database_id: Some(database_id),
            table_id: Some(table_id),
            view_id: Some(board.id),
            created: true,
        })
    }
}