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.

5.0 KB
Raw Blame
//! What a form is called. A form that created its own database goes by that
//! database's name: every read asks the databases domain for it, and a
//! rename renames the database. A form over an existing table keeps a name
//! of its own.

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

use std::collections::{HashMap, HashSet};

use databases::domain::models::DatabaseError;
use databases::domain::ports::{DatabaseMetadataReads, DatabaseRowReads, DatabasesService};
use entity_access::domain::models::{
    AccessLevel, EditAccessLevel, Entity, EntityAccessReceipt, EntityPermission, EntityType,
    ViewAccessLevel,
};
use macro_event_broker::MacroEventBroker;

use super::{FormsServiceImpl, database_error, internal_receipt, repository_error};
use crate::domain::models::{DatabaseId, Form, FormError, FormId};
use crate::domain::ports::{
    Clock, FormAccessDirectory, FormEventPublisher, FormImageFiles, FormsRepo,
};

/// The receipt a form's editor renames its database with: Edit on a live
/// form grants Edit on its database, so the caller's own auth acts there
/// and the databases domain attributes the rename to them.
fn database_edit_receipt(
    receipt: &EntityAccessReceipt<EditAccessLevel>,
    database_id: DatabaseId,
) -> Result<EntityAccessReceipt<EditAccessLevel>, FormError> {
    EntityAccessReceipt::try_new(
        receipt.auth().clone(),
        Entity {
            entity_id: database_id.to_string(),
            entity_type: EntityType::Database,
        },
        EntityPermission::AccessLevel {
            access_level: AccessLevel::Edit,
        },
    )
    .map_err(|_| FormError::NotFound)
}

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,
{
    /// The name of the database a form goes by, in the trash or not. A
    /// database's forms are removed with it, so a missing one breaks the
    /// databases contract.
    async fn database_name(&self, database_id: DatabaseId) -> Result<String, FormError> {
        match self
            .databases
            .database_metadata(internal_receipt::<ViewAccessLevel>(database_id))
            .await
        {
            Ok(database) => Ok(database.name),
            Err(DatabaseError::NotFound) => Err(FormError::DatabaseContract(
                "a form outlived the database it is named by",
            )),
            Err(error) => Err(database_error(error)),
        }
    }

    /// `form` under the name it goes by.
    pub(super) async fn named(
        &self,
        form: Form,
        name_follows_database: bool,
    ) -> Result<Form, FormError> {
        if !name_follows_database {
            return Ok(form);
        }
        let name = self.database_name(form.database_id).await?;
        Ok(Form { name, ..form })
    }

    /// `forms` under the names they go by, reading each database's name
    /// once however many of them follow it.
    pub(super) async fn named_forms(&self, forms: Vec<Form>) -> Result<Vec<Form>, FormError> {
        let ids: Vec<FormId> = forms.iter().map(|form| form.id).collect();
        let following: HashSet<FormId> = self
            .repository
            .forms_with_database_names(&ids)
            .await
            .map_err(repository_error)?
            .into_iter()
            .collect();
        let mut database_names: HashMap<DatabaseId, String> = HashMap::new();
        let mut named = Vec::with_capacity(forms.len());
        for form in forms {
            if !following.contains(&form.id) {
                named.push(form);
                continue;
            }
            let name = match database_names.get(&form.database_id) {
                Some(name) => name.clone(),
                None => {
                    let name = self.database_name(form.database_id).await?;
                    database_names.insert(form.database_id, name.clone());
                    name
                }
            };
            named.push(Form { name, ..form });
        }
        Ok(named)
    }

    /// Rename the database `form` goes by as the caller, answering the name
    /// it took. A database in the trash is not renamed: restore it first.
    pub(super) async fn rename_database_of(
        &self,
        receipt: &EntityAccessReceipt<EditAccessLevel>,
        form: &Form,
        name: String,
    ) -> Result<String, FormError> {
        let database = self
            .databases
            .rename_database(database_edit_receipt(receipt, form.database_id)?, name)
            .await
            .map_err(|error| match error {
                DatabaseError::NotFound => FormError::TableGone,
                other => database_error(other),
            })?;
        Ok(database.name)
    }
}