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.

18.0 KB
Raw Blame
//! Creating a form: over a new database whose one table holds only the
//! form's own columns, or over an existing table with a question per column.

use crate::domain::drafts::{FormDraftRepository, FormDraftStore};

use databases::domain::models::{CreateDatabase, DatabaseError, OpBatch, TableDetail, Viewer};
use databases::domain::ports::{DatabaseMetadataReads, DatabaseRowReads, DatabasesService};
use entity_access::domain::models::{
    EditAccessLevel, EntityAccessReceipt, OwnerAccessLevel, ViewAccessLevel,
};
use macro_event_broker::MacroEventBroker;
use models_databases::{ColumnChange, ColumnKind, DatabaseOp, NewColumn, TableChange};

use super::layout::{form_detail, question_columns};
use super::managed::{respondent_kind, submitted_kind};
use super::{
    FormsServiceImpl, database_error, internal_receipt, receipt_database_id, repository_error,
    validated_name,
};
use crate::domain::events::{Attribution, FormCreatedMetadata, FormTopicEvent};
use crate::domain::models::{
    Audience, ColumnId, DatabaseId, Form, FormAccess, FormBranding, FormCreation, FormDetail,
    FormError, FormId, FormLayout, FormQuestionId, FormSection, FormSectionId, FormStatus,
    QuestionLayout, TableId,
};
use crate::domain::ports::{
    Clock, CreateFormCommand, CreateSource, FormAccessDirectory, FormEventPublisher,
    FormImageFiles, FormsRepo,
};

/// The name a new database's table takes.
const RESPONSES_TABLE: &str = "Responses";
/// The date column each submission stamps.
pub(super) const SUBMITTED_COLUMN: &str = "Submitted";
/// The person column each signed-in submission names its respondent in.
pub(super) const RESPONDENT_COLUMN: &str = "Respondent";

/// Where a new form's table came from.
#[derive(Clone, Copy)]
enum Provenance {
    /// A database made for the form, which goes by its name, may stay out
    /// of Drive with it, and has no Respondent column when the form starts
    /// anonymous.
    OwnDatabase {
        is_hidden_in_drive: bool,
        anonymous: bool,
    },
    /// A table of a database the creator already had.
    ExistingTable,
}

/// A column the form writes itself: one the table already has, reused, or
/// one to create.
pub(super) enum ManagedColumn {
    Existing(ColumnId),
    New { id: ColumnId, name: String },
}

impl ManagedColumn {
    fn id(&self) -> ColumnId {
        match self {
            ManagedColumn::Existing(id) | ManagedColumn::New { id, .. } => *id,
        }
    }
}

/// Find the table's column named `base` (or `base 2`, `base 3`, … when an
/// earlier name is taken by a column of another type) of `kind`; otherwise use
/// the first free name for a new column.
pub(super) fn managed_column(table: &TableDetail, base: &str, kind: ColumnKind) -> ManagedColumn {
    let columns = question_columns(table);
    let named = |name: &str| {
        table
            .columns
            .iter()
            .find(|column| column.name().trim().to_lowercase() == name.to_lowercase())
    };
    let mut ordinal = 1;
    loop {
        let name = if ordinal == 1 {
            base.to_string()
        } else {
            format!("{base} {ordinal}")
        };
        match named(&name) {
            None => {
                return ManagedColumn::New {
                    id: ColumnId::new(),
                    name,
                };
            }
            Some(column)
                if columns
                    .get(&column.column.id)
                    .is_some_and(|facts| facts.kind == kind) =>
            {
                return ManagedColumn::Existing(column.column.id);
            }
            Some(_) => ordinal += 1,
        }
    }
}

/// The op creating a managed column, when it is new.
fn create_op(table: &TableDetail, column: &ManagedColumn, kind: ColumnKind) -> Option<DatabaseOp> {
    let ManagedColumn::New { id, name } = column else {
        return None;
    };
    Some(DatabaseOp::Column {
        table: table.table.id,
        column: *id,
        change: ColumnChange::Create {
            definition: NewColumn::New {
                name: name.clone(),
                kind,
                options: vec![],
                infer_type: false,
            },
            after: None,
        },
    })
}

/// Interactive creation retains its existing rollback policy; AI workflows keep
/// allocated identities for inspection after an interrupted multi-service write.
#[derive(Clone, Copy, PartialEq, Eq)]
pub(super) enum CreationPolicy {
    Interactive,
    Authoring,
}

impl<Repository, Databases, Access, Events, Now, Broker, Drafts, Images>
    FormsServiceImpl<Repository, Databases, Access, Events, Now, Broker, Drafts, Images>
where
    Repository: FormsRepo + FormDraftRepository,
    Databases: DatabasesService + DatabaseRowReads + DatabaseMetadataReads,
    Access: FormAccessDirectory,
    Events: FormEventPublisher,
    Now: Clock,
    Broker: MacroEventBroker,
    Drafts: FormDraftStore,
    Images: FormImageFiles,
{
    pub(super) async fn create(
        &self,
        creator: Viewer,
        command: CreateFormCommand,
    ) -> Result<FormDetail, FormError> {
        self.create_with_identity(creator, command, FormId::new(), CreationPolicy::Interactive)
            .await
    }

    pub(super) async fn create_with_identity(
        &self,
        creator: Viewer,
        command: CreateFormCommand,
        id: FormId,
        policy: CreationPolicy,
    ) -> Result<FormDetail, FormError> {
        let status = match policy {
            CreationPolicy::Interactive => FormStatus::Open,
            CreationPolicy::Authoring => FormStatus::Closed,
        };
        let name = validated_name(&command.name)?;
        match command.source {
            CreateSource::NewDatabase {
                is_hidden_in_drive,
                anonymous,
            } => {
                let provenance = Provenance::OwnDatabase {
                    is_hidden_in_drive,
                    anonymous,
                };
                self.create_over_new_database(creator, name, provenance, id, status, policy)
                    .await
            }
            CreateSource::Table { receipt, table_id } => {
                self.create_over_table(creator, name, receipt, table_id, id, status)
                    .await
            }
        }
    }

    /// A new database for the creator, its first table renamed "Responses"
    /// and holding only the managed columns, and a form with one empty
    /// section over it. A failed attachment attempts to remove the new database.
    async fn create_over_new_database(
        &self,
        creator: Viewer,
        name: String,
        provenance: Provenance,
        id: FormId,
        status: FormStatus,
        policy: CreationPolicy,
    ) -> Result<FormDetail, FormError> {
        let database = self
            .databases
            .create_database(CreateDatabase {
                name: name.clone(),
                owner_id: creator.user_id.clone(),
                acting_bot: creator.acting_bot,
            })
            .await
            .map_err(database_error)?;
        match self
            .attach_to_new_database(
                &creator,
                database.name,
                database.id,
                provenance,
                id,
                status,
                policy,
            )
            .await
        {
            Ok(detail) => Ok(detail),
            Err(error) => {
                if policy == CreationPolicy::Authoring {
                    return Err(FormError::DatabaseRetained {
                        database_id: database.id,
                        source: Box::new(error),
                    });
                }
                self.remove_new_database(database.id).await;
                Err(error)
            }
        }
    }

    #[expect(
        clippy::too_many_arguments,
        reason = "Attaching carries the new form's identity, status and provenance"
    )]
    async fn attach_to_new_database(
        &self,
        creator: &Viewer,
        name: String,
        database_id: DatabaseId,
        provenance: Provenance,
        id: FormId,
        status: FormStatus,
        policy: CreationPolicy,
    ) -> Result<FormDetail, FormError> {
        let detail = self
            .databases
            .get_database(internal_receipt::<ViewAccessLevel>(database_id))
            .await
            .map_err(database_error)?;
        let table = detail
            .tables
            .into_iter()
            .next()
            .ok_or_else(|| FormError::DatabaseContract("a new database has no table"))?;
        if policy == CreationPolicy::Authoring
            && (self
                .repository
                .table_has_form(table.table.id)
                .await
                .map_err(repository_error)?
                || self
                    .databases
                    .row_count(
                        internal_receipt::<ViewAccessLevel>(database_id),
                        table.table.id,
                    )
                    .await
                    .map_err(database_error)?
                    != 0)
        {
            return Err(FormError::Conflict);
        }
        let submitted = ManagedColumn::New {
            id: ColumnId::new(),
            name: SUBMITTED_COLUMN.to_string(),
        };
        let respondent = match provenance {
            Provenance::OwnDatabase {
                anonymous: true, ..
            } => None,
            Provenance::OwnDatabase { .. } | Provenance::ExistingTable => {
                Some(ManagedColumn::New {
                    id: ColumnId::new(),
                    name: RESPONDENT_COLUMN.to_string(),
                })
            }
        };
        let mut ops = vec![DatabaseOp::Table {
            table: table.table.id,
            change: TableChange::Rename {
                name: RESPONSES_TABLE.to_string(),
                previous_name: Some(table.table.name.clone()),
            },
        }];
        ops.extend(
            [
                create_op(&table, &submitted, submitted_kind()),
                respondent
                    .as_ref()
                    .and_then(|respondent| create_op(&table, respondent, respondent_kind())),
            ]
            .into_iter()
            .flatten(),
        );
        // The starter title column has no place on a form: the managed
        // columns go in first, so the table is never left without one.
        ops.extend(table.columns.iter().map(|column| DatabaseOp::Column {
            table: table.table.id,
            column: column.column.id,
            change: ColumnChange::Delete,
        }));
        self.databases
            .apply_ops(
                internal_receipt::<EditAccessLevel>(database_id),
                creator.clone(),
                OpBatch {
                    ops,
                    base_versions: if policy == CreationPolicy::Authoring {
                        [(table.table.id, table.table.version)].into()
                    } else {
                        Default::default()
                    },
                },
            )
            .await
            .map_err(database_error)?;
        let layout = FormLayout {
            sections: vec![FormSection::Questions {
                id: FormSectionId::new(),
                title: String::new(),
                description: String::new(),
                questions: vec![],
                show_when: None,
            }],
        };
        self.store_new_form(
            creator,
            name,
            (submitted.id(), respondent.as_ref().map(ManagedColumn::id)),
            layout,
            &table,
            provenance,
            id,
            status,
        )
        .await
    }

    /// Undo a database this request created, logging a failure: the form
    /// was not created, so nothing points at it.
    async fn remove_new_database(&self, database_id: DatabaseId) {
        if let Err(error) = self
            .databases
            .delete_database_permanently(internal_receipt::<OwnerAccessLevel>(database_id))
            .await
        {
            tracing::error!(error = ?error, %database_id, "failed to remove the database of a form that was not created");
        }
    }

    /// A form over a table of a database the creator owns: the managed
    /// columns found or created, then one section asking every other column.
    async fn create_over_table(
        &self,
        creator: Viewer,
        name: String,
        receipt: EntityAccessReceipt<OwnerAccessLevel>,
        table_id: TableId,
        id: FormId,
        status: FormStatus,
    ) -> Result<FormDetail, FormError> {
        // The receipt must be for a database; the table is looked up in it.
        receipt_database_id(&receipt)?;
        let view = receipt
            .clone()
            .try_into_requirement::<ViewAccessLevel>()
            .map_err(|_| FormError::NotFound)?;
        let detail = self
            .databases
            .get_database(view)
            .await
            .map_err(|error| match error {
                DatabaseError::NotFound => FormError::NotFound,
                other => database_error(other),
            })?;
        let table = detail
            .tables
            .into_iter()
            .find(|table| table.table.id == table_id)
            .ok_or(FormError::NotFound)?;
        if self
            .repository
            .table_has_form(table_id)
            .await
            .map_err(repository_error)?
        {
            return Err(FormError::TableAlreadyHasForm);
        }
        let submitted = managed_column(&table, SUBMITTED_COLUMN, submitted_kind());
        let respondent = managed_column(&table, RESPONDENT_COLUMN, respondent_kind());
        let ops: Vec<DatabaseOp> = [
            create_op(&table, &submitted, submitted_kind()),
            create_op(&table, &respondent, respondent_kind()),
        ]
        .into_iter()
        .flatten()
        .collect();
        if !ops.is_empty() {
            // Owner holds Edit, so the creator's own receipt writes the
            // managed columns and the journal names them.
            let edit = receipt
                .try_into_requirement::<EditAccessLevel>()
                .map_err(|_| FormError::NotFound)?;
            self.databases
                .apply_ops(edit, creator.clone(), OpBatch::from(ops))
                .await
                .map_err(database_error)?;
        }
        let managed = [submitted.id(), respondent.id()];
        let askable = question_columns(&table);
        let questions = table
            .columns
            .iter()
            .filter(|column| !managed.contains(&column.column.id))
            .filter(|column| askable.contains_key(&column.column.id))
            .map(|column| QuestionLayout {
                id: FormQuestionId::new(),
                column: column.column.id,
                help_text: String::new(),
                required: false,
                widget: None,
            })
            .collect();
        let layout = FormLayout {
            sections: vec![FormSection::Questions {
                id: FormSectionId::new(),
                title: String::new(),
                description: String::new(),
                questions,
                show_when: None,
            }],
        };
        self.store_new_form(
            &creator,
            name,
            (submitted.id(), Some(respondent.id())),
            layout,
            &table,
            Provenance::ExistingTable,
            id,
            status,
        )
        .await
    }

    /// Store a new form over `table`, owned by its creator, writing its two
    /// managed columns. A form over a database it created goes by that
    /// database's name, which `name` is at creation.
    #[expect(
        clippy::too_many_arguments,
        reason = "Creation binds the saved identity, initial access and managed columns in one write"
    )]
    async fn store_new_form(
        &self,
        creator: &Viewer,
        name: String,
        (submitted, respondent): (ColumnId, Option<ColumnId>),
        layout: FormLayout,
        table: &TableDetail,
        provenance: Provenance,
        id: FormId,
        status: FormStatus,
    ) -> Result<FormDetail, FormError> {
        let now = self.now();
        let database_id = table.table.database_id;
        let form = Form {
            id,
            name,
            description: String::new(),
            owner_id: creator.user_id.to_string(),
            database_id,
            table_id: table.table.id,
            submitted_column_id: Some(submitted),
            respondent_column_id: respondent,
            audience: Audience::Members,
            tally_visible: false,
            status,
            closes_at: None,
            confirmation_message: String::new(),
            branding: FormBranding::default(),
            created_at: now,
            updated_at: now,
            project_id: None,
            is_hidden_in_drive: matches!(
                provenance,
                Provenance::OwnDatabase {
                    is_hidden_in_drive: true,
                    ..
                }
            ),
            responses_visible: false,
            anonymous: matches!(
                provenance,
                Provenance::OwnDatabase {
                    anonymous: true,
                    ..
                }
            ),
        };
        match self
            .repository
            .create_form(
                &form,
                &layout,
                matches!(provenance, Provenance::OwnDatabase { .. }),
            )
            .await
            .map_err(repository_error)?
        {
            FormCreation::Created => {}
            FormCreation::TableOccupied => {
                return Err(FormError::TableAlreadyHasForm);
            }
            FormCreation::SchemaChanged => return Err(FormError::Conflict),
        }
        self.emit(FormTopicEvent::Created(FormCreatedMetadata {
            form_id: form.id,
            database_id,
            owner: creator.user_id.clone(),
            name: form.name.clone(),
            created_at: now,
            attribution: Attribution::acting(creator.user_id.clone(), creator.acting_bot),
        }));
        Ok(form_detail(form, FormAccess::Owner, layout, Some(table)))
    }
}