pharos_native/runtime/

architect_preview_accounts.rs

//! Credentials belong exclusively to Architect's isolated preview database.
use super::{database, dynamic};
use pharos_runtime_database::operations::{
    AppSchema, DatabaseError, Field, FieldConstraint, Mutation, Predicate, Query, SortKey,
    Transaction, WriteValue,
};
use serde_json::{Value, json};
use std::{
    collections::{BTreeMap, BTreeSet},
    path::Path,
};

fn append_memberships(
    schema: &AppSchema,
    owner: bool,
    user_id: WriteValue,
    existing_id: Option<i64>,
    memberships: &BTreeSet<(&str, i64)>,
    steps: &mut Vec<Mutation>,
) -> Result<(), DatabaseError> {
    for name in ["store_membership", "user_profile"] {
        if existing_id.is_some_and(|id| memberships.contains(&(name, id))) {
            continue;
        }
        let Some(entity) = schema.entities.iter().find(|entity| entity.name == name) else {
            continue;
        };
        let mut values = BTreeMap::new();
        for field in &entity.fields {
            let value = match field.name.as_str() {
                "id" => continue,
                "user_id" => {
                    values.insert(field.name.clone(), user_id.clone());
                    continue;
                }
                "role" => role_value(field, owner, if owner { "store_owner" } else { "customer" })?,
                "account_type" => role_value(
                    field,
                    owner,
                    if owner {
                        "business_owner"
                    } else {
                        "business_customer"
                    },
                )?,
                "full_name" => json!(if owner {
                    "Preview Owner"
                } else {
                    "Preview Customer"
                }),
                "payment_preference" => json!("credit_card"),
                "email_verified" => json!(true),
                _ if field.default.is_some() || field.nullable => continue,
                _ => return Err(DatabaseError::InvalidContract),
            };
            values.insert(field.name.clone(), WriteValue::Literal(value));
        }
        steps.push(Mutation::Insert {
            entity: name.into(),
            values,
        });
    }
    Ok(())
}

fn role_value(field: &Field, owner: bool, fallback: &str) -> Result<Value, DatabaseError> {
    let names: &[&str] = if owner {
        &[
            "architect_admin",
            "store_owner",
            "business_owner",
            "admin",
            "owner",
        ]
    } else {
        &["build_user", "business_customer", "customer", "user"]
    };
    if let Some(allowed) = field
        .constraints
        .iter()
        .find_map(|constraint| match constraint {
            FieldConstraint::Allowed(values) => Some(values),
            _ => None,
        })
    {
        return names
            .iter()
            .find_map(|name| {
                allowed
                    .iter()
                    .find(|value| value.as_str() == Some(name))
                    .cloned()
            })
            .ok_or(DatabaseError::InvalidContract);
    }
    Ok(json!(fallback))
}

fn owner_role(value: &str) -> Option<bool> {
    match value {
        "architect_admin" | "store_owner" | "business_owner" | "admin" | "owner" => Some(true),
        "build_user" | "business_customer" | "customer" | "user" => Some(false),
        _ => None,
    }
}

/// Initializes the declared payment owner in isolated preview storage without exporting accounts or credentials.
fn append_preview_payment_owner(
    root: &Path,
    store: &database::LogicalAppStore,
    owner_id: WriteValue,
    steps: &mut Vec<Mutation>,
) -> Result<(), DatabaseError> {
    let Some(checkout) = pharos_runtime_payment::checkout_manifest_config(root) else {
        return Ok(());
    };
    if pharos_runtime_payment::checkout_manifest_string(&checkout, "kind", "commerce_cart")
        != "commerce_cart"
    {
        return Ok(());
    }
    let management = pharos_runtime_payment::payment_provider_manifest_config(root)
        .ok_or(DatabaseError::InvalidContract)?;
    let field = |key: &str| {
        management
            .get(key)
            .and_then(Value::as_str)
            .ok_or(DatabaseError::InvalidContract)
    };
    let entity_name = field("owner_entity")?;
    let route_field = field("owner_route_field")?;
    let user_field = field("owner_user_id_field")?;
    let route = pharos_runtime_payment::checkout_owner_route_value(root, &checkout)
        .map_err(|_| DatabaseError::InvalidContract)?;
    let entity = store
        .schema
        .entities
        .iter()
        .find(|entity| entity.name == entity_name)
        .ok_or(DatabaseError::InvalidContract)?;
    if !store
        .adapter
        .query(
            &store.config,
            &store.schema,
            &Query {
                entity: entity_name.into(),
                fields: vec![route_field.into()],
                filter: Some(Predicate::Equal(route_field.into(), json!(route))),
                order: vec![],
                limit: 1,
                offset: 0,
            },
        )?
        .is_empty()
    {
        return Ok(());
    }
    let mut values = BTreeMap::new();
    for field in &entity.fields {
        let value = match field.name.as_str() {
            "id" => continue,
            name if name == route_field => WriteValue::Literal(json!(route)),
            name if name == user_field => owner_id.clone(),
            "name" => WriteValue::Literal(json!(route)),
            _ if field.default.is_some() || field.nullable => continue,
            _ => return Err(DatabaseError::InvalidContract),
        };
        values.insert(field.name.clone(), value);
    }
    steps.push(Mutation::Insert {
        entity: entity_name.into(),
        values,
    });
    Ok(())
}

pub(super) fn state_root(workspace: &Path) -> std::path::PathBuf {
    // Only Architect's generated runtime configuration owns mutable preview paths.
    // An uploaded app.conf must never redirect account initialization outside it.
    crate::config::dynamic_config_lookup_raw(&workspace.join("runtime.conf"), "state_dir")
        .map(std::path::PathBuf::from)
        .map(|path| {
            if path.is_absolute() {
                path
            } else {
                workspace.join(path)
            }
        })
        .unwrap_or_else(|| workspace.join("state"))
}

/// Reports whether the isolated namespace has received the named preview defaults.
fn named_defaults_ready(marker: &Path) -> bool {
    std::fs::metadata(marker)
        .ok()
        .filter(|metadata| metadata.len() <= 4096)
        .and_then(|_| std::fs::read(marker).ok())
        .and_then(|bytes| serde_json::from_slice::<Value>(&bytes).ok())
        .and_then(|value| value.get("defaults_version").and_then(Value::as_u64))
        == Some(2)
}

/// Initializes isolated preview roles and adds named defaults without resetting established accounts.
pub(super) fn prepare(root: &Path, workspace: &Path, app_id: &str) -> Result<(), DatabaseError> {
    let marker = state_root(workspace)
        .join(app_id)
        .join("preview-accounts.json");
    if named_defaults_ready(&marker) {
        return Ok(());
    }
    static INITIALIZE: std::sync::Mutex<()> = std::sync::Mutex::new(());
    let _guard = INITIALIZE.lock().map_err(|_| DatabaseError::Unavailable)?;
    if named_defaults_ready(&marker) {
        return Ok(());
    }
    let previously_initialized = marker.is_file();
    let store =
        database::app_operations_store(root, Some(&workspace.join("runtime.conf")), app_id)?;
    let Some(account) = store
        .schema
        .entities
        .iter()
        .find(|entity| entity.name == "user_account")
    else {
        return Ok(());
    };
    if !["id", "username", "password_hash"]
        .iter()
        .all(|name| account.fields.iter().any(|field| field.name == *name))
    {
        return Err(DatabaseError::InvalidContract);
    }
    let users = store.adapter.query(
        &store.config,
        &store.schema,
        &Query {
            entity: account.name.clone(),
            fields: account
                .fields
                .iter()
                .filter(|field| {
                    matches!(
                        field.name.as_str(),
                        "id" | "username" | "role" | "account_type"
                    )
                })
                .map(|field| field.name.clone())
                .collect(),
            filter: None,
            order: vec![SortKey {
                field: "id".into(),
                descending: false,
            }],
            limit: 64,
            offset: 0,
        },
    )?;
    let mut roles = BTreeMap::new();
    let mut memberships = BTreeSet::new();
    for (entity_name, role_field) in [
        ("store_membership", "role"),
        ("user_profile", "account_type"),
    ] {
        let Some(entity) = store
            .schema
            .entities
            .iter()
            .find(|entity| entity.name == entity_name)
        else {
            continue;
        };
        if !["user_id", role_field]
            .iter()
            .all(|name| entity.fields.iter().any(|field| field.name == *name))
        {
            continue;
        }
        for row in store.adapter.query(
            &store.config,
            &store.schema,
            &Query {
                entity: entity_name.into(),
                fields: vec!["user_id".into(), role_field.into()],
                filter: None,
                order: vec![],
                limit: 128,
                offset: 0,
            },
        )? {
            if let Some(id) = row.get("user_id").and_then(Value::as_i64) {
                memberships.insert((entity_name, id));
            }
            if let (Some(id), Some(owner)) = (
                row.get("user_id").and_then(Value::as_i64),
                row.get(role_field)
                    .and_then(Value::as_str)
                    .and_then(owner_role),
            ) {
                roles
                    .entry(id)
                    .and_modify(|existing| *existing |= owner)
                    .or_insert(owner);
            }
        }
    }
    for user in &users {
        if let (Some(id), Some(owner)) = (
            user.get("id").and_then(Value::as_i64),
            user.get("role")
                .or_else(|| user.get("account_type"))
                .and_then(Value::as_str)
                .and_then(owner_role),
        ) {
            roles.insert(id, owner);
        }
    }
    let selected = if roles.is_empty() {
        [users.first(), users.get(1)]
    } else {
        [true, false].map(|owner| {
            users.iter().find(|user| {
                user.get("id")
                    .and_then(Value::as_i64)
                    .and_then(|id| roles.get(&id))
                    .copied()
                    == Some(owner)
            })
        })
    };
    let named = [("admin", true), ("user", false)].map(|(name, owner)| {
        let user = users
            .iter()
            .find(|user| user.get("username").and_then(Value::as_str) == Some(name));
        if let Some(user) = user {
            let id = user
                .get("id")
                .and_then(Value::as_i64)
                .ok_or(DatabaseError::InvalidContract)?;
            let matches_role = roles.get(&id).copied().or_else(|| {
                selected[usize::from(!owner)].and_then(|selected| {
                    (selected.get("id").and_then(Value::as_i64) == Some(id)).then_some(owner)
                })
            });
            if matches_role != Some(owner) {
                return Err(DatabaseError::InvalidContract);
            }
        }
        Ok(user)
    });
    let [admin, user] = named;
    let selected = [selected[0], selected[1], admin?, user?];
    let mut steps = Vec::new();
    let mut usernames = Vec::new();
    for (index, user) in selected.into_iter().enumerate() {
        let owner = index % 2 == 0;
        let password = dynamic::hash_password("pass").map_err(|_| DatabaseError::Unavailable)?;
        if let Some(user) = user {
            let id = user
                .get("id")
                .cloned()
                .ok_or(DatabaseError::InvalidContract)?;
            usernames.push(
                user.get("username")
                    .and_then(Value::as_str)
                    .ok_or(DatabaseError::InvalidContract)?
                    .to_owned(),
            );
            if previously_initialized {
                continue;
            }
            let mut values =
                BTreeMap::from([("password_hash".into(), WriteValue::Literal(json!(password)))]);
            if account.fields.iter().any(|field| field.name == "is_active") {
                values.insert("is_active".into(), WriteValue::Literal(json!(true)));
            }
            for field in account
                .fields
                .iter()
                .filter(|field| matches!(field.name.as_str(), "role" | "account_type"))
            {
                if user
                    .get(&field.name)
                    .and_then(Value::as_str)
                    .and_then(owner_role)
                    .is_none()
                {
                    let fallback = if field.name == "account_type" {
                        if owner {
                            "business_owner"
                        } else {
                            "business_customer"
                        }
                    } else if owner {
                        "owner"
                    } else {
                        "customer"
                    };
                    values.insert(
                        field.name.clone(),
                        WriteValue::Literal(role_value(field, owner, fallback)?),
                    );
                }
            }
            steps.push(Mutation::Update {
                entity: account.name.clone(),
                filter: Predicate::Equal("id".into(), id.clone()),
                values,
                expected_rows: Some(1),
            });
            append_memberships(
                &store.schema,
                owner,
                WriteValue::Literal(id.clone()),
                id.as_i64(),
                &memberships,
                &mut steps,
            )?;
            if index == 0 {
                append_preview_payment_owner(root, &store, WriteValue::Literal(id), &mut steps)?;
            }
            continue;
        }
        let default_username = ["owner1", "customer1", "admin", "user"][index];
        let username = if users
            .iter()
            .any(|user| user.get("username").and_then(Value::as_str) == Some(default_username))
        {
            let nonce = pharos_runtime_security::csrf_generate_random_hex(6);
            if nonce.is_empty() {
                return Err(DatabaseError::Unavailable);
            }
            format!(
                "preview_{}_{nonce}",
                if owner { "owner" } else { "customer" }
            )
        } else {
            default_username.to_owned()
        };
        let mut values = BTreeMap::new();
        for field in &account.fields {
            let value = match field.name.as_str() {
                "id" => continue,
                "username" => json!(username),
                "password_hash" => json!(password),
                "email" | "normalized_email" => json!(format!("{username}@preview.example.test")),
                "display_name" => json!(if owner {
                    "Preview Owner"
                } else {
                    "Preview Customer"
                }),
                "is_active" | "email_verified" => json!(true),
                "account_status" => json!("active"),
                "role" => role_value(field, owner, if owner { "owner" } else { "customer" })?,
                "account_type" => role_value(
                    field,
                    owner,
                    if owner {
                        "business_owner"
                    } else {
                        "business_customer"
                    },
                )?,
                "created_at" | "updated_at" => json!(super::timestamp_after_seconds_utc(0)),
                _ if field.default.is_some() || field.nullable => continue,
                _ => return Err(DatabaseError::InvalidContract),
            };
            values.insert(field.name.clone(), WriteValue::Literal(value));
        }
        let account_step = steps.len();
        steps.push(Mutation::Insert {
            entity: account.name.clone(),
            values,
        });
        append_memberships(
            &store.schema,
            owner,
            WriteValue::GeneratedId(account_step),
            None,
            &memberships,
            &mut steps,
        )?;
        if index == 0 {
            append_preview_payment_owner(
                root,
                &store,
                WriteValue::GeneratedId(account_step),
                &mut steps,
            )?;
        }
        usernames.push(username);
    }
    if !steps.is_empty() {
        store.adapter.transact(
            &store.config,
            &store.schema,
            &Transaction {
                steps,
                idempotency_key: None,
            },
        )?;
    }
    std::fs::create_dir_all(marker.parent().ok_or(DatabaseError::InvalidInput)?)
        .map_err(|_| DatabaseError::Unavailable)?;
    std::fs::write(
        marker,
        serde_json::to_vec(&json!({"defaults_version":2,"usernames": usernames}))
            .map_err(|_| DatabaseError::InvalidInput)?,
    )
    .map_err(|_| DatabaseError::Unavailable)
}

#[cfg(test)]
mod tests {
    use super::*;
    use pharos_runtime_database::{
        contract::AppDataContract,
        operations::{AppSchema, Entity, Field, FieldType, Identity, Migration, SchemaChange},
    };

    #[test]
    fn preview_accounts_have_pass_and_survive_repeated_preparation() {
        let workspace = Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("tmp/0.8.4-testing")
            .join(format!("preview-account-unit-{}", std::process::id()));
        let root = workspace.join("app");
        std::fs::create_dir_all(root.join("data/contracts")).unwrap();
        std::fs::write(root.join("pharos.app.json"), r#"{"app_id":"preview_accounts_test","database":{"migration_contract":"data/contracts/database.json"}}"#).unwrap();
        std::fs::write(root.join("pharos.app.yml"), "app_id: preview_accounts_test\ndatabase:\n  migration_contract: data/contracts/database.json\n").unwrap();
        std::fs::write(
            root.join("app.conf"),
            format!("state_dir={}\n", root.join("untrusted-state").display()),
        )
        .unwrap();
        assert_eq!(state_root(&workspace), workspace.join("state"));
        std::fs::write(
            workspace.join("runtime.conf"),
            format!(
                "db_backend=sqlite\ndb_path={}\n",
                workspace.join("preview.sqlite3").display()
            ),
        )
        .unwrap();
        let manifest = json!({"app_id":"preview_accounts_test","database":{"migration_contract":"data/contracts/database.json"},
            "payments":{"provider_management":{"owner_entity":"store","owner_route_field":"slug","owner_user_id_field":"owner_user_id","supported_providers":[],"provider_checkout":{"kind":"commerce_cart","owner_route_value":"preview-shop"}}}});
        std::fs::write(
            root.join("pharos.app.json"),
            serde_json::to_vec(&manifest).unwrap(),
        )
        .unwrap();
        std::fs::write(
            root.join("pharos.app.yml"),
            pharos_runtime_core::yaml::serialize_yaml_value(&manifest).unwrap(),
        )
        .unwrap();
        let entity = Entity {
            name: "user_account".into(),
            identity: Identity::AutoInteger("id".into()),
            fields: [
                "id",
                "username",
                "email",
                "password_hash",
                "display_name",
                "is_active",
                "role",
            ]
            .into_iter()
            .map(|name| Field {
                name: name.into(),
                kind: match name {
                    "id" => FieldType::Integer,
                    "is_active" => FieldType::Boolean,
                    _ => FieldType::Text,
                },
                nullable: false,
                max_length: (name == "username").then_some(128),
                default: None,
                references: None,
                on_delete: None,
                constraints: if name == "role" {
                    vec![FieldConstraint::Allowed(vec![
                        json!("owner"),
                        json!("customer"),
                    ])]
                } else {
                    vec![]
                },
            })
            .collect(),
            unique: vec![vec!["username".into()]],
            indexes: vec![],
            conditional_indexes: vec![],
        };
        let payment_owner: Entity = serde_json::from_value(json!({"name":"store","identity":{"auto_integer":"id"},
            "fields":[{"name":"id","kind":"integer","nullable":false,"constraints":[]},
                      {"name":"slug","kind":"text","nullable":false,"max_length":128,"constraints":[]},
                      {"name":"owner_user_id","kind":"integer","nullable":false,"references":["user_account","id"],"on_delete":"restrict","constraints":[]},
                      {"name":"name","kind":"text","nullable":false,"max_length":256,"constraints":[]}],
            "unique":[["slug"]],"indexes":[],"conditional_indexes":[]})).unwrap();
        let changes = vec![
            SchemaChange::CreateEntity(entity.clone()),
            SchemaChange::CreateEntity(payment_owner.clone()),
        ];
        let contract = AppDataContract {
            schema: AppSchema {
                app_id: "preview_accounts_test".into(),
                entities: vec![entity, payment_owner],
            },
            migrations: vec![Migration {
                app_id: "preview_accounts_test".into(),
                id: "create_users".into(),
                checksum: pharos_runtime_database::contract::migration_checksum(
                    "preview_accounts_test",
                    "create_users",
                    &changes,
                )
                .unwrap(),
                changes,
            }],
            legacy_adoption: None,
        };
        std::fs::write(
            root.join("data/contracts/database.json"),
            serde_json::to_vec(&contract).unwrap(),
        )
        .unwrap();
        database::source_selected_logical_contract(
            &root,
            Some(&workspace.join("runtime.conf")),
            "preview_accounts_test",
            None,
        )
        .expect("valid preview test contract")
        .expect("selected preview test contract");
        database::checked_backend_config(
            &root,
            Some(&workspace.join("runtime.conf")),
            Some("preview_accounts_test"),
        )
        .expect("valid preview test backend");
        assert_eq!(
            database::dynamic_runtime_prepare(
                &root,
                Some(&workspace.join("runtime.conf")),
                Some("preview_accounts_test")
            ),
            0
        );
        prepare(&root, &workspace, "preview_accounts_test").unwrap();
        let store = database::app_operations_store(
            &root,
            Some(&workspace.join("runtime.conf")),
            "preview_accounts_test",
        )
        .unwrap();
        let rows = store
            .adapter
            .query(
                &store.config,
                &store.schema,
                &Query {
                    entity: "user_account".into(),
                    fields: vec!["role".into(), "password_hash".into()],
                    filter: None,
                    order: vec![SortKey {
                        field: "id".into(),
                        descending: false,
                    }],
                    limit: 2,
                    offset: 0,
                },
            )
            .unwrap();
        assert_eq!(rows[0]["role"], "owner");
        assert_eq!(rows[1]["role"], "customer");
        let payment_owners = store
            .adapter
            .query(
                &store.config,
                &store.schema,
                &Query {
                    entity: "store".into(),
                    fields: vec!["slug".into(), "owner_user_id".into()],
                    filter: None,
                    order: vec![],
                    limit: 2,
                    offset: 0,
                },
            )
            .unwrap();
        assert_eq!(payment_owners.len(), 1);
        assert_eq!(payment_owners[0]["slug"], "preview-shop");
        assert_eq!(payment_owners[0]["owner_user_id"], 1);
        assert_ne!(rows[0]["password_hash"], rows[1]["password_hash"]);
        for username in ["owner1", "customer1", "admin", "user"] {
            assert!(
                database::dynamic_relational_authenticate_user(
                    &root,
                    Some(&workspace.join("runtime.conf")),
                    Some("preview_accounts_test"),
                    username,
                    "pass"
                )
                .unwrap()
                .is_some()
            );
        }
        let changed = dynamic::hash_password("changed-preview-password").unwrap();
        let store = database::app_operations_store(
            &root,
            Some(&workspace.join("runtime.conf")),
            "preview_accounts_test",
        )
        .unwrap();
        store
            .adapter
            .transact(
                &store.config,
                &store.schema,
                &Transaction {
                    steps: vec![Mutation::Update {
                        entity: "user_account".into(),
                        filter: Predicate::Equal("id".into(), json!(1)),
                        values: BTreeMap::from([(
                            "password_hash".into(),
                            WriteValue::Literal(json!(changed)),
                        )]),
                        expected_rows: Some(1),
                    }],
                    idempotency_key: None,
                },
            )
            .unwrap();
        // Upgrade an established namespace without replacing its existing passwords.
        store
            .adapter
            .transact(
                &store.config,
                &store.schema,
                &Transaction {
                    steps: vec![
                        Mutation::Delete {
                            entity: "user_account".into(),
                            filter: Predicate::Equal("username".into(), json!("admin")),
                            expected_rows: Some(1),
                        },
                        Mutation::Delete {
                            entity: "user_account".into(),
                            filter: Predicate::Equal("username".into(), json!("user")),
                            expected_rows: Some(1),
                        },
                    ],
                    idempotency_key: None,
                },
            )
            .unwrap();
        std::fs::write(
            state_root(&workspace).join("preview_accounts_test/preview-accounts.json"),
            br#"{"usernames":["owner1","customer1"]}"#,
        )
        .unwrap();
        prepare(&root, &workspace, "preview_accounts_test").unwrap();
        for (username, role) in [("admin", "owner"), ("user", "customer")] {
            let rows = store
                .adapter
                .query(
                    &store.config,
                    &store.schema,
                    &Query {
                        entity: "user_account".into(),
                        fields: vec!["role".into()],
                        filter: Some(Predicate::Equal("username".into(), json!(username))),
                        order: vec![],
                        limit: 1,
                        offset: 0,
                    },
                )
                .unwrap();
            assert_eq!(rows[0]["role"], role);
            assert!(
                database::dynamic_relational_authenticate_user(
                    &root,
                    Some(&workspace.join("runtime.conf")),
                    Some("preview_accounts_test"),
                    username,
                    "pass"
                )
                .unwrap()
                .is_some()
            );
        }
        assert!(
            database::dynamic_relational_authenticate_user(
                &root,
                Some(&workspace.join("runtime.conf")),
                Some("preview_accounts_test"),
                "owner1",
                "changed-preview-password"
            )
            .unwrap()
            .is_some()
        );
        store
            .adapter
            .transact(
                &store.config,
                &store.schema,
                &Transaction {
                    steps: vec![Mutation::Update {
                        entity: "user_account".into(),
                        filter: Predicate::Equal("id".into(), json!(2)),
                        values: BTreeMap::from([(
                            "role".into(),
                            WriteValue::Literal(json!("owner")),
                        )]),
                        expected_rows: Some(1),
                    }],
                    idempotency_key: None,
                },
            )
            .unwrap();
        std::fs::remove_file(
            state_root(&workspace).join("preview_accounts_test/preview-accounts.json"),
        )
        .unwrap();
        prepare(&root, &workspace, "preview_accounts_test").unwrap();
        let rows = store
            .adapter
            .query(
                &store.config,
                &store.schema,
                &Query {
                    entity: "user_account".into(),
                    fields: vec!["username".into(), "role".into()],
                    filter: None,
                    order: vec![],
                    limit: 4,
                    offset: 0,
                },
            )
            .unwrap();
        assert_eq!(rows.len(), 4);
        assert!(rows.iter().any(|row| {
            row["role"] == "customer" && row["username"].as_str().is_some_and(|name| name == "user")
        }));
        assert!(!root.join("untrusted-state").exists());
        store
            .adapter
            .transact(
                &store.config,
                &store.schema,
                &Transaction {
                    steps: vec![Mutation::Update {
                        entity: "user_account".into(),
                        filter: Predicate::Equal("username".into(), json!("admin")),
                        values: BTreeMap::from([(
                            "role".into(),
                            WriteValue::Literal(json!("customer")),
                        )]),
                        expected_rows: Some(1),
                    }],
                    idempotency_key: None,
                },
            )
            .unwrap();
        std::fs::remove_file(
            state_root(&workspace).join("preview_accounts_test/preview-accounts.json"),
        )
        .unwrap();
        assert_eq!(
            prepare(&root, &workspace, "preview_accounts_test"),
            Err(DatabaseError::InvalidContract)
        );
        std::fs::remove_dir_all(workspace).unwrap();
    }
}