vtc-service 0.12.0

//! Default **Issues** registrations seeded at community boot (task 2.x
//! follow-up). The VTC always mints its built-in catalog types; seeding them
//! into the schema store means the registry accurately reflects what the
//! community issues, so issue-time validation ([`super::validate_issued`]) and
//! the admin UI have entries to work with out of the box.
//!
//! Seeding is **idempotent** and additive: it registers a default
//! [`SchemaEntry`] (kind [`Issues`](super::SchemaKind::Issues), no
//! `credentialSchema`) for any catalog type not already present, and never
//! overwrites an operator's edits.

use chrono::Utc;
use vti_common::error::AppError;
use vti_common::store::KeyspaceHandle;

use super::{SchemaEntry, SchemaKind, delete_schema, get_schema, schema_exists, store_schema};

/// The built-in credential types the VTC issues, keyed by the short type name
/// stamped in a credential's `type` array (what [`super::validate_issued`]
/// matches against). `(type_uri, dtg_type)`; `dtg_type` is `None` for a type
/// outside the DTG catalog.
///
/// The DTG types are the four the community mints: grants (VMC), role
/// credentials (VAC), statements (VSC — which statement is its predicate, the
/// set `crate::endorsement_types` accepts, never a subtype) and invitations
/// (VIC). The community's own identity check is a statement under `vetted/1`,
/// so it needs no entry of its own.
pub const DEFAULT_ISSUES_TYPES: &[(&str, Option<&str>)] = &[
    ("MembershipCredential", Some("MembershipCredential")),
    ("AuthorityCredential", Some("AuthorityCredential")),
    ("StatementCredential", Some("StatementCredential")),
    ("InvitationCredential", Some("InvitationCredential")),
];

/// Defaults an earlier release seeded for a type the VTC no longer mints.
/// Historical: the plain `IdentityVerificationCredential` the community issued
/// for its own identity check until that check became a `vetted/1` statement.
/// Removed at boot only where the seed wrote it, so an operator's own
/// registration of the name is kept.
const RETIRED_ISSUES_TYPES: &[&str] = &["IdentityVerificationCredential"];

/// The DID recorded as the registrant of a seeded default.
const SEED_AUTHOR: &str = "did:vtc:system";

/// Seed the default Issues registrations for the catalog types the VTC mints,
/// for any not already registered. Idempotent — safe to call on every boot.
pub async fn seed_default_issues(schemas_ks: &KeyspaceHandle) -> Result<(), AppError> {
    for type_uri in RETIRED_ISSUES_TYPES {
        if let Some(entry) = get_schema(schemas_ks, type_uri).await?
            && entry.created_by_did == SEED_AUTHOR
            && entry.kind == SchemaKind::Issues
        {
            delete_schema(schemas_ks, type_uri).await?;
        }
    }
    let now = Utc::now();
    for (type_uri, dtg_type) in DEFAULT_ISSUES_TYPES {
        if schema_exists(schemas_ks, type_uri).await? {
            continue;
        }
        store_schema(
            schemas_ks,
            &SchemaEntry {
                type_uri: (*type_uri).to_string(),
                dtg_type: dtg_type.map(str::to_string),
                credential_schema: None,
                kind: SchemaKind::Issues,
                description: Some("Built-in catalog type (seeded default)".to_string()),
                created_at: now,
                created_by_did: SEED_AUTHOR.to_string(),
            },
        )
        .await?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::super::{SchemaEntry, SchemaKind, get_schema, is_issues_registered, store_schema};
    use super::*;
    use vti_common::config::StoreConfig;
    use vti_common::store::Store;

    async fn ks() -> (tempfile::TempDir, Store, KeyspaceHandle) {
        let dir = tempfile::tempdir().unwrap();
        let store = Store::open(&StoreConfig {
            data_dir: dir.path().to_path_buf(),
        })
        .unwrap();
        let ks = store.keyspace("schemas").unwrap();
        (dir, store, ks)
    }

    #[tokio::test]
    async fn seeds_the_catalog_issues_types() {
        let (_d, _s, ks) = ks().await;
        seed_default_issues(&ks).await.unwrap();

        for (type_uri, _) in DEFAULT_ISSUES_TYPES {
            assert!(
                is_issues_registered(&ks, type_uri).await.unwrap(),
                "{type_uri} must be seeded as an Issues type"
            );
        }
    }

    /// A type an earlier release seeded and the VTC no longer mints is
    /// withdrawn where the seed wrote it, and kept where an operator did.
    #[tokio::test]
    async fn a_retired_seeded_default_is_withdrawn_but_an_operator_row_is_kept() {
        let (_d, _s, ks) = ks().await;
        let row = |by: &str| SchemaEntry {
            type_uri: RETIRED_ISSUES_TYPES[0].into(),
            dtg_type: None,
            credential_schema: None,
            kind: SchemaKind::Issues,
            description: None,
            created_at: Utc::now(),
            created_by_did: by.into(),
        };
        store_schema(&ks, &row(SEED_AUTHOR)).await.unwrap();
        seed_default_issues(&ks).await.unwrap();
        assert!(
            get_schema(&ks, RETIRED_ISSUES_TYPES[0])
                .await
                .unwrap()
                .is_none()
        );

        store_schema(&ks, &row("did:key:zAdmin")).await.unwrap();
        seed_default_issues(&ks).await.unwrap();
        assert!(
            get_schema(&ks, RETIRED_ISSUES_TYPES[0])
                .await
                .unwrap()
                .is_some()
        );
    }

    #[tokio::test]
    async fn is_idempotent_and_preserves_operator_edits() {
        let (_d, _s, ks) = ks().await;

        // An operator pre-registers Membership with a custom schema.
        let custom = SchemaEntry {
            type_uri: "MembershipCredential".into(),
            dtg_type: Some("MembershipCredential".into()),
            credential_schema: Some(serde_json::json!({ "type": "object" })),
            kind: SchemaKind::Issues,
            description: Some("operator-tuned".into()),
            created_at: Utc::now(),
            created_by_did: "did:key:zAdmin".into(),
        };
        store_schema(&ks, &custom).await.unwrap();

        // Seeding twice must not clobber the operator's entry.
        seed_default_issues(&ks).await.unwrap();
        seed_default_issues(&ks).await.unwrap();

        let got = get_schema(&ks, "MembershipCredential")
            .await
            .unwrap()
            .unwrap();
        assert_eq!(got, custom, "seeding must not overwrite an existing entry");
        // The other defaults are still seeded.
        assert!(
            is_issues_registered(&ks, "InvitationCredential")
                .await
                .unwrap()
        );
    }
}