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.

37.4 KB
Raw Blame
//! Cells as entity properties through the properties crate's adapter; a batch
//! shares one transaction across the schema, row identities, cells and
//! options.

mod core;
mod derive;
mod duplicate;
mod provisioning;
mod required;
mod transfer;

use std::collections::HashMap;

use models_properties::service::property_value::PropertyValue;
use models_properties::{EntityReference, EntityType};
use properties::domain::database_cell_writer::DatabaseCellWriter;
use properties::domain::database_definition_writer::{
    DatabaseDefinitionWriter, NewDatabaseDefinition,
};
use properties::domain::database_option_writer::{
    ColorChange, DatabaseOptionWriter, DeleteUnusedOptionOutcome,
};
use properties::domain::model::UpdatePropertyOptionOutcome;
use properties::domain::ports::PropertiesRepo;
use sqlx::{PgPool, Postgres, Transaction};

use crate::domain::journal::{Before, JournalActor, RowImage, cell_value, row_cells};
use crate::domain::models::{
    ColumnProtection, NewDefinition, OptionId, PropertyDefinitionId, RowId, TableId, TakenId,
    Write, Writes, WritesOutcome,
};
use crate::domain::ports::CellStore;
use crate::outbound::pg_databases_repo::schema::{self, Inserted, Removed};
use crate::outbound::pg_databases_repo::{PgDatabasesRepoError, journal, rows, views};

/// [`CellStore`] over the properties repository, with the pool its batches
/// open their transaction on.
#[derive(Debug, Clone)]
pub struct PgCellStore<Properties> {
    pool: PgPool,
    properties: Properties,
}

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

/// The properties-side name of a row.
fn row_entity(row: RowId) -> EntityReference {
    EntityReference {
        entity_id: row.to_string(),
        entity_type: EntityType::DatabaseRow,
        specific_message_id: None,
    }
}

/// The store's error, keeping the failing side's cause.
#[derive(Debug, thiserror::Error)]
pub enum PgCellStoreError {
    /// The properties repository failed.
    #[error("properties: {0}")]
    Properties(#[from] anyhow::Error),
    /// A statement of a batch failed; nothing of it committed.
    #[error("row batch: {0}")]
    Sqlx(#[from] sqlx::Error),
    /// The properties writer failed inside a batch; nothing of it committed.
    #[error("row batch cells: {0}")]
    Cells(#[source] Box<dyn std::error::Error + Send + Sync>),
    /// A repository statement of a batch failed; nothing of it committed.
    #[error("row batch statement: {0}")]
    Repository(#[from] PgDatabasesRepoError),
    /// The properties side keyed a row's cells by something that is not a
    /// row id.
    #[error("row cells keyed by `{0}`, which is not a row id")]
    CorruptRowId(String),
    /// An imported table carries its request key without the fingerprint
    /// written with it.
    #[error("imported table {0} has no import fingerprint")]
    MissingImportFingerprint(TableId),
}

/// The unique index on a table's view names.
const VIEW_NAME_CONSTRAINT: &str = "database_views_table_name_key";
/// The primary key of `database_views`.
const VIEW_KEY: &str = "database_views_pkey";

/// Which constraint a view statement failed on, if it failed on one.
fn violated(error: &PgDatabasesRepoError) -> Option<&str> {
    match error {
        PgDatabasesRepoError::Sqlx(sqlx::Error::Database(database)) => database.constraint(),
        _ => None,
    }
}

/// Whether a view statement failed on the unique view name of its table.
fn name_taken(error: &PgDatabasesRepoError) -> bool {
    violated(error) == Some(VIEW_NAME_CONSTRAINT)
}

/// The row a properties-side entity id names.
fn row_of(entity_id: &str) -> Result<RowId, PgCellStoreError> {
    entity_id
        .parse()
        .map_err(|_| PgCellStoreError::CorruptRowId(entity_id.to_string()))
}

/// Preserve the batch API's missing-table outcome when its parent is absent.
fn missing_database(writes: &Writes) -> WritesOutcome {
    WritesOutcome::TableNotFound(
        writes
            .writes
            .iter()
            .flat_map(|write| write.versioned_tables().iter().copied())
            .next()
            .unwrap_or_default(),
    )
}

fn cells_error(error: impl std::error::Error + Send + Sync + 'static) -> PgCellStoreError {
    PgCellStoreError::Cells(Box::new(error))
}

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

    #[tracing::instrument(err, skip(self, rows), fields(rows = rows.len()))]
    async fn cells(
        &self,
        rows: &[RowId],
    ) -> Result<HashMap<RowId, HashMap<PropertyDefinitionId, PropertyValue>>, Self::Error> {
        if rows.is_empty() {
            return Ok(HashMap::new());
        }
        let fetched = self
            .properties
            .get_entity_properties_batch(rows.iter().map(|row| row_entity(*row)).collect())
            .await?;
        let mut cells: HashMap<RowId, HashMap<PropertyDefinitionId, PropertyValue>> =
            HashMap::new();
        for (key, properties) in fetched {
            let row_cells = cells.entry(row_of(&key.entity_id)?).or_default();
            for property in properties {
                if let Some(value) = property.value {
                    row_cells.insert(property.property.property_definition_id, value);
                }
            }
        }
        Ok(cells)
    }

    #[tracing::instrument(err, skip(self, rows), fields(rows = rows.len()))]
    async fn column_cells(
        &self,
        rows: &[RowId],
        definition: PropertyDefinitionId,
    ) -> Result<HashMap<RowId, PropertyValue>, Self::Error> {
        if rows.is_empty() {
            return Ok(HashMap::new());
        }
        let fetched = self
            .properties
            .get_entity_properties_batch_filtered(
                rows.iter().map(|row| row_entity(*row)).collect(),
                vec![definition],
                None,
            )
            .await?;
        let mut cells = HashMap::new();
        for (key, properties) in fetched {
            let row = row_of(&key.entity_id)?;
            let value = properties
                .into_iter()
                .find(|property| property.property.property_definition_id == definition)
                .and_then(|property| property.value);
            if let Some(value) = value {
                cells.insert(row, value);
            }
        }
        Ok(cells)
    }

    #[tracing::instrument(err, skip(self, writes), fields(writes = writes.writes.len()))]
    async fn apply_writes(&self, writes: &Writes) -> Result<WritesOutcome, Self::Error> {
        // Returning before the commit drops the transaction, which rolls
        // everything back.
        let mut transaction = self.pool.begin().await?;

        if !rows::lock_live_database(&mut transaction, writes.database_id).await? {
            return Ok(missing_database(writes));
        }
        self.apply_in(transaction, writes).await
    }
}

/// What one write did inside its batch: the rows it inserted, or the
/// outcome refusing the whole batch.
enum Applied {
    Rows(Vec<RowId>),
    Refused(WritesOutcome),
}

impl<Properties> PgCellStore<Properties>
where
    Properties: PropertiesRepo<Err = anyhow::Error>
        + DatabaseCellWriter<Transaction = Transaction<'static, Postgres>>
        + DatabaseOptionWriter
        + DatabaseDefinitionWriter<Transaction = Transaction<'static, Postgres>>
        + Send
        + Sync
        + 'static,
{
    /// Commit a core storage batch; the app wrapper takes its entity lock first.
    async fn apply_in(
        &self,
        mut transaction: Transaction<'static, Postgres>,
        writes: &Writes,
    ) -> Result<WritesOutcome, PgCellStoreError> {
        // Parent locks precede table locks, as every writer takes them.
        if !schema::lock_database(
            &mut transaction,
            writes.database_id,
            writes.changes_tables(),
        )
        .await?
        {
            return Ok(missing_database(writes));
        }
        let created: Vec<TableId> = writes
            .writes
            .iter()
            .filter_map(|write| match write {
                Write::CreateTable { table_id, .. } => Some(*table_id),
                _ => None,
            })
            .collect();
        let deleted: Vec<TableId> = writes
            .writes
            .iter()
            .filter_map(|write| match write {
                Write::DeleteTable { table_id, .. } => Some(*table_id),
                _ => None,
            })
            .collect();
        let mut required: Vec<TableId> = writes
            .writes
            .iter()
            .flat_map(|write| write.versioned_tables().iter().copied())
            .chain(deleted.iter().copied())
            .chain(writes.expected_versions.iter().map(|(table, _)| *table))
            .chain(
                writes
                    .derivations
                    .iter()
                    .map(|derivation| derivation.table_id()),
            )
            .filter(|table| !created.contains(table))
            .collect();
        required.sort();
        required.dedup();
        // A relation's target sees the relation go if it is still there; it
        // may be in another database, or gone.
        let related: Vec<TableId> = writes
            .writes
            .iter()
            .filter_map(|write| match write {
                Write::DeleteColumn {
                    related: Some((_, table)),
                    ..
                } => Some(*table),
                _ => None,
            })
            .filter(|table| !required.contains(table) && !created.contains(table))
            .collect();
        let locked: Vec<TableId> = required.iter().chain(&related).copied().collect();
        let live = schema::lock_table_versions(&mut transaction, &locked).await?;
        if let Some(gone) = required.iter().find(|table| !live.contains_key(table)) {
            return Ok(WritesOutcome::TableNotFound(*gone));
        }
        let read_versions = writes.writes.iter().filter_map(|write| match write {
            Write::ReplaceColumn {
                table_id,
                read_version: Some(version),
                ..
            } => Some((*table_id, *version)),
            _ => None,
        });
        for (table, version) in writes
            .expected_versions
            .iter()
            .copied()
            .chain(read_versions)
        {
            if live.get(&table) != Some(&version) {
                return Ok(WritesOutcome::VersionConflict(table));
            }
        }
        for (table, version) in writes.journal.read_versions() {
            if live.get(&table).is_some_and(|live| *live != version) {
                return Ok(WritesOutcome::SchemaMoved(table));
            }
        }
        let before = self.before_image(&mut transaction, writes).await?;

        let mut minted: Vec<(usize, OptionId)> = Vec::new();
        for (index, write) in writes.writes.iter().enumerate() {
            let options: &[(OptionId, _)] = match write {
                Write::AddOptions { options, .. } => options,
                Write::CreateColumn {
                    definition: Some(definition),
                    ..
                } => &definition.options,
                _ => &[],
            };
            minted.extend(options.iter().map(|(id, _)| (index, *id)));
        }
        let existing = self
            .properties
            .existing_option_ids_in(
                &mut transaction,
                &minted
                    .iter()
                    .map(|(_, id)| id.into_uuid())
                    .collect::<Vec<_>>(),
            )
            .await
            .map_err(cells_error)?;
        if let Some((write, id)) = minted
            .iter()
            .find(|(_, id)| existing.contains(id.as_uuid()))
        {
            return Ok(WritesOutcome::IdTaken {
                write: *write,
                id: TakenId::Option(*id),
            });
        }

        let mut inserted = Vec::with_capacity(writes.writes.len());
        for (index, write) in writes.writes.iter().enumerate() {
            let outcome = self
                .apply_write(&mut transaction, writes, index, write)
                .await?;
            match outcome {
                Applied::Rows(rows) => inserted.push(rows),
                Applied::Refused(outcome) => return Ok(outcome),
            }
        }

        // A table whose derived cells all held their values already keeps
        // its version, unless another write changed it.
        let mut rederived = Vec::new();
        for derivation in &writes.derivations {
            let rows = journal::table_rows(&mut *transaction, derivation.table_id()).await?;
            if self.derive(&mut transaction, derivation, &rows).await? {
                rederived.push(derivation.table_id());
            }
        }

        if let Some(missing) = self
            .check_required_cells(&mut transaction, writes, &inserted)
            .await?
        {
            return Ok(missing);
        }

        let mut grouped: Vec<(TableId, Vec<RowId>)> = Vec::new();
        for (table, row) in &writes.related_rows {
            match grouped.iter_mut().find(|(target, _)| target == table) {
                Some((_, rows)) => rows.push(*row),
                None => grouped.push((*table, vec![*row])),
            }
        }
        for (table, named) in &grouped {
            let held = rows::hold_rows(&mut *transaction, *table, named).await?;
            if let Some(row) = named.iter().find(|row| !held.contains(row)) {
                return Ok(WritesOutcome::MissingRelatedRow(*row));
            }
        }

        let mut changed: Vec<TableId> = writes
            .writes
            .iter()
            .filter(|write| write.changes())
            .flat_map(|write| write.versioned_tables().iter().copied())
            .chain(created.iter().copied())
            .chain(rederived)
            .chain(
                related
                    .iter()
                    .copied()
                    .filter(|table| live.contains_key(table)),
            )
            .filter(|table| !deleted.contains(table))
            .collect();
        changed.sort();
        changed.dedup();
        let mut table_versions = HashMap::new();
        for table in changed {
            let version = rows::bump_table_version(&mut *transaction, table).await?;
            table_versions.insert(table, version);
        }
        let mut stamped: Vec<RowId> = inserted.iter().flatten().copied().collect();
        stamped.extend(writes.writes.iter().flat_map(|write| match write {
            Write::UpdateRows { rows, .. } => rows.iter().map(|(row, _)| *row).collect(),
            Write::MoveCard { row, .. } => vec![*row],
            _ => Vec::new(),
        }));
        stamped.sort();
        stamped.dedup();
        journal::stamp_rows(&mut *transaction, &stamped, writes.created_by.as_ref()).await?;
        let entries = crate::domain::journal::entries(writes, &before, &inserted, &table_versions);
        let changes = journal::record(
            &mut transaction,
            &JournalActor {
                user: Some(writes.created_by.to_string()),
                acting_bot: writes.journal.acting_bot,
            },
            &entries,
        )
        .await?;
        transaction.commit().await?;
        Ok(WritesOutcome::Applied {
            inserted,
            table_versions,
            changes,
        })
    }

    /// Apply one write of a batch inside its transaction.
    async fn apply_write(
        &self,
        transaction: &mut Transaction<'static, Postgres>,
        writes: &Writes,
        index: usize,
        write: &Write,
    ) -> Result<Applied, PgCellStoreError> {
        let refused = |outcome| Ok(Applied::Refused(outcome));
        let database_id = writes.database_id;
        // Schema planning is optimistic. Recheck protections under the same table
        // locks that serialize protection registration before changing stored schema.
        let protected_operation = match write {
            Write::DeleteColumn { column_id, .. } => Some((*column_id, ColumnProtection::Delete)),
            Write::ReplaceColumn { replacement, .. } => {
                Some((replacement.column.id, ColumnProtection::ChangeType))
            }
            _ => None,
        };
        if let Some((column_id, capability)) = protected_operation {
            let blocked = sqlx::query_scalar!(
                "SELECT EXISTS(SELECT 1 FROM database_column_protections WHERE column_id = $1 AND capability = $2) AS \"blocked!\"",
                column_id.into_uuid(), capability.to_string()
            ).fetch_one(&mut **transaction).await?;
            if blocked {
                return refused(WritesOutcome::ColumnProtected {
                    write: index,
                    capability,
                });
            }
        }
        match write {
            Write::Unchanged { .. } => {}
            Write::CreateTable { table_id, name } => {
                match schema::insert_table(transaction, database_id, *table_id, name).await? {
                    Inserted::Applied => {}
                    Inserted::IdTaken => {
                        return refused(WritesOutcome::IdTaken {
                            write: index,
                            id: TakenId::Table(*table_id),
                        });
                    }
                    Inserted::Conflict => {
                        return refused(WritesOutcome::TableNameTaken { write: index });
                    }
                }
            }
            Write::RenameTable {
                table_id,
                from,
                name,
            } => {
                if !schema::rename_table(transaction, database_id, *table_id, from, name).await? {
                    return refused(WritesOutcome::TableRenamedElsewhere { write: index });
                }
            }
            Write::DeleteTable { table_id, .. } => {
                match schema::delete_table(transaction, database_id, *table_id).await? {
                    Removed::Applied => {}
                    Removed::Missing => return refused(WritesOutcome::TableNotFound(*table_id)),
                    Removed::LastTable => {
                        return refused(WritesOutcome::LastTable { write: index });
                    }
                }
            }
            Write::OrderTables { tables, positions } => {
                if !schema::order_tables(transaction, database_id, tables, positions).await? {
                    return refused(WritesOutcome::TablesChanged { write: index });
                }
            }
            Write::CreateColumn { column, definition } => {
                if let Some(definition) = definition {
                    self.create_definition(transaction, database_id, definition)
                        .await?;
                }
                match schema::insert_column(transaction, column).await? {
                    Inserted::Applied => {}
                    Inserted::IdTaken => {
                        return refused(WritesOutcome::IdTaken {
                            write: index,
                            id: TakenId::Column(column.id),
                        });
                    }
                    Inserted::Conflict => {
                        return refused(WritesOutcome::MissingColumn { write: index });
                    }
                }
            }
            Write::RenameColumn {
                table_id,
                column_id,
                from,
                name,
            } => {
                if !schema::rename_column(transaction, *table_id, *column_id, from.as_deref(), name)
                    .await?
                {
                    return refused(WritesOutcome::ColumnRenamedElsewhere { write: index });
                }
            }
            Write::DeleteColumn {
                table_id,
                column_id,
                definition_id,
                views,
                ..
            } => {
                if !schema::delete_column(transaction, *table_id, *column_id, *definition_id)
                    .await?
                {
                    return refused(WritesOutcome::MissingColumn { write: index });
                }
                if !schema::rewrite_views(transaction, views).await? {
                    return refused(WritesOutcome::MissingView { write: index });
                }
            }
            Write::OrderColumns {
                table_id,
                positions,
            } => {
                if !schema::order_columns(transaction, *table_id, positions).await? {
                    return refused(WritesOutcome::MissingColumn { write: index });
                }
            }
            Write::ReplaceColumn {
                table_id,
                definition,
                replacement,
                views,
                ..
            } => {
                if let Some(definition) = definition {
                    self.create_definition(transaction, database_id, definition)
                        .await?;
                }
                if !schema::rebind_column(transaction, *table_id, replacement).await? {
                    return refused(WritesOutcome::MissingColumn { write: index });
                }
                if !schema::rewrite_views(transaction, views).await? {
                    return refused(WritesOutcome::MissingView { write: index });
                }
                for (row, value) in &replacement.values {
                    self.properties
                        .upsert_entity_property_in(
                            transaction,
                            &row_entity(*row),
                            replacement.definition_id,
                            Some(value.clone()),
                        )
                        .await
                        .map_err(cells_error)?;
                }
            }
            Write::AddOptions {
                definition_id,
                options,
                ..
            } => {
                let values: Vec<_> = options
                    .iter()
                    .map(|(id, value)| (id.into_uuid(), value.clone()))
                    .collect();
                self.properties
                    .add_options_in(transaction, *definition_id, &values)
                    .await
                    .map_err(cells_error)?;
            }
            Write::InsertRows {
                table_id,
                rows,
                restored,
                derivation,
            } => {
                let minted = if restored.is_empty() {
                    rows::append_rows(
                        transaction,
                        *table_id,
                        writes.created_by.as_ref(),
                        rows.len(),
                    )
                    .await?
                } else {
                    match rows::restore_rows(
                        transaction,
                        *table_id,
                        writes.created_by.as_ref(),
                        restored,
                    )
                    .await?
                    {
                        rows::Restored::Applied(rows) => Some(rows),
                        rows::Restored::TableGone => None,
                        rows::Restored::Taken(row) => {
                            return refused(WritesOutcome::RowTaken { write: index, row });
                        }
                    }
                };
                let Some(minted) = minted else {
                    return refused(WritesOutcome::TableNotFound(*table_id));
                };
                let mut valued = Vec::new();
                for (row, cells) in minted.iter().zip(rows) {
                    for (definition, value) in cells {
                        self.properties
                            .upsert_entity_property_in(
                                transaction,
                                &row_entity(row.id),
                                *definition,
                                Some(value.clone()),
                            )
                            .await
                            .map_err(cells_error)?;
                        if !valued.contains(definition) {
                            valued.push(*definition);
                        }
                    }
                }
                rows::settle_inference(&mut **transaction, *table_id, &valued).await?;
                let minted: Vec<RowId> = minted.into_iter().map(|row| row.id).collect();
                if let Some(derivation) = derivation {
                    self.derive(transaction, derivation, &minted).await?;
                }
                return Ok(Applied::Rows(minted));
            }
            Write::UpdateRows {
                table_id,
                rows,
                derivation,
            } => {
                let named: Vec<RowId> = rows.iter().map(|(row, _)| *row).collect();
                let owned = rows::lock_rows(&mut **transaction, *table_id, &named).await?;
                if let Some(row) = named.iter().find(|row| !owned.contains(row)) {
                    return refused(WritesOutcome::MissingRow {
                        write: index,
                        row: *row,
                    });
                }
                let mut valued = Vec::new();
                for (row, cells) in rows {
                    for (definition, value) in cells {
                        self.properties
                            .upsert_entity_property_in(
                                transaction,
                                &row_entity(*row),
                                *definition,
                                value.clone(),
                            )
                            .await
                            .map_err(cells_error)?;
                        if value.is_some() && !valued.contains(definition) {
                            valued.push(*definition);
                        }
                    }
                }
                rows::settle_inference(&mut **transaction, *table_id, &valued).await?;
                if let Some(derivation) = derivation {
                    self.derive(transaction, derivation, &named).await?;
                }
            }
            Write::DeleteRows {
                table_id,
                rows,
                only_if_unreferenced,
            } => {
                if *only_if_unreferenced {
                    rows::lock_rows(&mut **transaction, *table_id, rows).await?;
                    if self
                        .properties
                        .database_rows_referenced_in(transaction, &journal::entity_ids(rows))
                        .await
                        .map_err(cells_error)?
                    {
                        return refused(WritesOutcome::RowInUse);
                    }
                }
                for row in rows {
                    // The row's cells go with it, by the schema's trigger.
                    if !rows::delete_row(&mut **transaction, *table_id, *row).await? {
                        return refused(WritesOutcome::MissingRow {
                            write: index,
                            row: *row,
                        });
                    }
                }
            }
            Write::UpdateOption {
                definition_id,
                option_id,
                value,
                color,
                ..
            } => {
                match self
                    .properties
                    .update_option_in(
                        transaction,
                        *definition_id,
                        option_id.into_uuid(),
                        value.clone(),
                        match color {
                            None => ColorChange::Keep,
                            Some(None) => ColorChange::Clear,
                            Some(Some(color)) => ColorChange::Set(color.clone()),
                        },
                    )
                    .await
                    .map_err(cells_error)?
                {
                    UpdatePropertyOptionOutcome::Updated(_) => {}
                    UpdatePropertyOptionOutcome::NotFound => {
                        return refused(WritesOutcome::MissingOption { write: index });
                    }
                    UpdatePropertyOptionOutcome::DuplicateValue => {
                        return refused(WritesOutcome::OptionLabelTaken { write: index });
                    }
                }
            }
            Write::DeleteOption {
                only_if_unused,
                tables,
                definition_id,
                option_id,
                views: rewritten,
                ..
            } => {
                let deleted = if *only_if_unused {
                    match self
                        .properties
                        .delete_unused_option_in(transaction, *definition_id, option_id.into_uuid())
                        .await
                        .map_err(cells_error)?
                    {
                        DeleteUnusedOptionOutcome::Deleted => true,
                        DeleteUnusedOptionOutcome::NotFound => false,
                        DeleteUnusedOptionOutcome::InUse => {
                            return refused(WritesOutcome::OptionInUse);
                        }
                    }
                } else {
                    self.properties
                        .delete_option_in(transaction, *definition_id, option_id.into_uuid())
                        .await
                        .map_err(cells_error)?
                };
                if !deleted {
                    return refused(WritesOutcome::MissingOption { write: index });
                }
                for view in rewritten {
                    if !views::update_view(&mut **transaction, view).await? {
                        return refused(WritesOutcome::MissingView { write: index });
                    }
                }
                views::clear_lane(&mut **transaction, tables, *option_id).await?;
            }
            Write::CreateView { view } => {
                match views::insert_view(&mut **transaction, view).await {
                    Ok(()) => {}
                    Err(error) if violated(&error) == Some(VIEW_KEY) => {
                        return refused(WritesOutcome::IdTaken {
                            write: index,
                            id: TakenId::View(view.id),
                        });
                    }
                    Err(error) if name_taken(&error) => {
                        return refused(WritesOutcome::ViewNameTaken { write: index });
                    }
                    Err(error) => return Err(error.into()),
                }
            }
            Write::UpdateView { view, regrouped } => {
                match views::update_view(&mut **transaction, view).await {
                    Ok(true) => {}
                    Ok(false) => return refused(WritesOutcome::MissingView { write: index }),
                    Err(error) if name_taken(&error) => {
                        return refused(WritesOutcome::ViewNameTaken { write: index });
                    }
                    Err(error) => return Err(error.into()),
                }
                if *regrouped {
                    views::clear_positions(&mut **transaction, view.id).await?;
                }
            }
            Write::DeleteView { table_id, view_id } => {
                if !views::delete_view(&mut **transaction, *table_id, *view_id).await? {
                    return refused(WritesOutcome::MissingView { write: index });
                }
            }
            Write::OrderViews {
                table_id,
                positions,
            } => {
                if !views::order_views(&mut **transaction, *table_id, positions).await? {
                    return refused(WritesOutcome::MissingView { write: index });
                }
            }
            Write::MoveCard {
                table_id,
                view_id,
                row,
                positions,
                cell: (definition, value),
            } => {
                if rows::lock_rows(&mut **transaction, *table_id, &[*row])
                    .await?
                    .is_empty()
                {
                    return refused(WritesOutcome::MissingRow {
                        write: index,
                        row: *row,
                    });
                }
                self.properties
                    .upsert_entity_property_in(
                        transaction,
                        &row_entity(*row),
                        *definition,
                        value.clone(),
                    )
                    .await
                    .map_err(cells_error)?;
                views::place_cards(&mut **transaction, *view_id, positions).await?;
            }
        }
        Ok(Applied::Rows(Vec::new()))
    }

    /// What the batch touches, read under its locks before it writes: the
    /// rows it updates, deletes or moves, every cell of the columns it
    /// removes or retypes or takes an option out of, and the cards of the
    /// boards it moves a card on.
    async fn before_image(
        &self,
        transaction: &mut Transaction<'static, Postgres>,
        writes: &Writes,
    ) -> Result<Before, PgCellStoreError> {
        let reads = crate::domain::journal::reads(writes);
        let schema = &writes.journal.schema;
        let mut before = Before {
            schema: schema.clone(),
            ..Before::default()
        };
        for write in &writes.writes {
            if let Write::DeleteOption {
                table_id,
                definition_id,
                option_id,
                ..
            } = write
            {
                let rows = journal::table_rows(&mut **transaction, *table_id).await?;
                if self
                    .properties
                    .option_used_outside_rows_in(
                        transaction,
                        *definition_id,
                        option_id.into_uuid(),
                        &journal::entity_ids(&rows),
                    )
                    .await
                    .map_err(cells_error)?
                {
                    before.incomplete_options.insert(*option_id);
                }
            }
        }
        let places = journal::row_places(&mut **transaction, &reads.rows).await?;
        if !places.is_empty() {
            let rows: Vec<RowId> = places.iter().map(|(row, _, _)| *row).collect();
            let values = self
                .properties
                .entity_values_in(
                    transaction,
                    EntityType::DatabaseRow,
                    &journal::entity_ids(&rows),
                    None,
                )
                .await
                .map_err(cells_error)?;
            let mut values = journal::by_row(values);
            for (row, table, position) in places {
                let cells = values.remove(&row).unwrap_or_default();
                before.rows.insert(
                    row,
                    RowImage {
                        table,
                        position,
                        cells: row_cells(schema, table, &cells),
                    },
                );
            }
        }
        for (table, column, definition) in &reads.columns {
            let rows = journal::table_rows(&mut **transaction, *table).await?;
            let values = self
                .properties
                .entity_values_in(
                    transaction,
                    EntityType::DatabaseRow,
                    &journal::entity_ids(&rows),
                    Some(&[*definition]),
                )
                .await
                .map_err(cells_error)?;
            let cells = journal::by_row(values)
                .into_iter()
                .filter_map(|(row, mut values)| {
                    let value = values.remove(definition)?;
                    Some((row, cell_value(&value)?))
                })
                .collect();
            before.column_cells.insert(*column, cells);
        }
        for board in &reads.boards {
            let cards = views::view_positions(&mut **transaction, *board).await?;
            before.cards.insert(*board, cards);
        }
        Ok(before)
    }

    /// Create a definition a write needs, under the ids the service minted.
    async fn create_definition(
        &self,
        transaction: &mut Transaction<'static, Postgres>,
        database_id: crate::domain::models::DatabaseId,
        definition: &NewDefinition,
    ) -> Result<(), PgCellStoreError> {
        let options: Vec<_> = definition
            .options
            .iter()
            .map(|(id, value)| (id.into_uuid(), value.clone()))
            .collect();
        self.properties
            .create_database_definition_in(
                transaction,
                NewDatabaseDefinition {
                    id: definition.id,
                    database_id: database_id.into_uuid(),
                    name: &definition.name,
                    data_type: definition.data_type,
                    is_multi_select: definition.is_multi_select,
                    specific_entity_type: definition.specific_entity_type,
                    options: &options,
                },
            )
            .await
            .map_err(cells_error)?;
        Ok(())
    }
}