Struct ResolvedModel 

pub struct ResolvedModel {
    pub entities: Vec<ResolvedEntity>,
    pub entity_by_path: HashMap<String, ResolvedEntity>,
}

Fields

entities: Vec<ResolvedEntity>

entity_by_path: HashMap<String, ResolvedEntity>

Implementations

impl ResolvedModel

pub fn entity_by_path(&self, path: &str) -> Option<&ResolvedEntity>

pub fn with_package_id(self, package_id: &str) -> Self

Backfill package_id on all contained entities. Call this after resolve() when the package id is known (e.g. from manifest.id or the route parameter).

Examples found in repository

examples/server.rs (line 61)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    let filter =
        EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("architect_sdk=info"));
    tracing_subscriber::fmt().with_env_filter(filter).init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite://architect.db".into());
    ensure_database_exists(&database_url).await?;

    // create_pool uses the compiled-in dialect automatically (sqlite by default).
    let pool = create_pool(&database_url, 5).await?;

    let dialect = architect_sdk::db::active_dialect();
    ensure_sys_tables(&pool, dialect.as_ref()).await?;

    let tenant_registry = load_registry_from_pool(&pool)
        .await
        .map_err(|e| -> Box<dyn std::error::Error> { Box::new(e) })?;
    tracing::info!("loaded tenant registry (X-Tenant-ID required for config and entity APIs)");

    let (config, package_id) = match std::env::var("PACKAGE_PATH") {
        Ok(package_path) => {
            tracing::info!("loading config from package path: {}", package_path);
            let (cfg, id) = load_config_from_package_path(&package_path).await?;
            (cfg, id)
        }
        Err(_) => {
            tracing::info!("PACKAGE_PATH not set; loading config from _sys_* tables (use config APIs or POST /api/v1/config/package to insert)");
            let cfg = load_from_pool(&pool, DEFAULT_PACKAGE_ID)
                .await
                .map_err(|e| -> Box<dyn std::error::Error> { Box::new(e) })?;
            (cfg, DEFAULT_PACKAGE_ID.to_string())
        }
    };
    apply_migrations(
        &pool,
        &config,
        None,
        None,
        dialect.as_ref(),
        &HashMap::new(),
    )
    .await?;
    let model = resolve(&config)?.with_package_id(&package_id);
    let mut package_models = HashMap::new();
    package_models.insert(package_id.clone(), model.clone());
    let storage = architect_sdk::init_storage_provider().await;
    let event_client = architect_sdk::events::DecisionHubClient::from_env();
    let authrs_client = architect_sdk::authrs::AuthrsClient::from_env();
    let state = AppState {
        pool: pool.clone(),
        model: Arc::new(RwLock::new(model)),
        package_models: Arc::new(RwLock::new(package_models)),
        tenant_pools: Arc::new(RwLock::new(HashMap::new())),
        tenant_registry: Arc::new(tenant_registry),
        storage,
        event_client,
        authrs_client,
        dialect,
        extensible_cache: Default::default(),
    };

    let api = Router::new()
        .merge(common_routes_with_ready(state.clone()))
        .nest("/api/v1", config_routes(state.clone()))
        .nest("/api/v1", entity_routes(state));

    let app = Router::new().nest("/", api);

    let listener = TcpListener::bind("0.0.0.0:3000").await?;
    tracing::info!("listening on {}", listener.local_addr()?);
    axum::serve(listener, app).await?;
    Ok(())
}

Trait Implementations

impl Clone for ResolvedModel

fn clone(&self) -> ResolvedModel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ResolvedModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.