server/
server.rs

1//! Example server: ensures _sys_* tables exist, then loads config from PACKAGE_PATH (package directory with manifest.json) or from DB (config APIs).
2//! If PACKAGE_PATH is set, config is loaded from that directory (must contain manifest.json + config JSONs) and migrations applied; otherwise config is loaded from _sys_* tables (empty until fed via config APIs or package install).
3
4use architect_sdk::{
5    apply_migrations, common_routes_with_ready, config_routes, create_pool, ensure_database_exists,
6    ensure_sys_tables, entity_routes, load_from_pool, load_registry_from_pool, resolve, AppState,
7    FullConfig, DEFAULT_PACKAGE_ID,
8};
9use axum::Router;
10use std::collections::HashMap;
11use std::path::{Path, PathBuf};
12use std::sync::{Arc, RwLock};
13use tokio::net::TcpListener;
14use tracing_subscriber::EnvFilter;
15
16#[tokio::main]
17async fn main() -> Result<(), Box<dyn std::error::Error>> {
18    dotenvy::dotenv().ok();
19    let filter =
20        EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("architect_sdk=info"));
21    tracing_subscriber::fmt().with_env_filter(filter).init();
22
23    let database_url =
24        std::env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite://architect.db".into());
25    ensure_database_exists(&database_url).await?;
26
27    // create_pool uses the compiled-in dialect automatically (sqlite by default).
28    let pool = create_pool(&database_url, 5).await?;
29
30    let dialect = architect_sdk::db::active_dialect();
31    ensure_sys_tables(&pool, dialect.as_ref()).await?;
32
33    let tenant_registry = load_registry_from_pool(&pool)
34        .await
35        .map_err(|e| -> Box<dyn std::error::Error> { Box::new(e) })?;
36    tracing::info!("loaded tenant registry (X-Tenant-ID required for config and entity APIs)");
37
38    let (config, package_id) = match std::env::var("PACKAGE_PATH") {
39        Ok(package_path) => {
40            tracing::info!("loading config from package path: {}", package_path);
41            let (cfg, id) = load_config_from_package_path(&package_path).await?;
42            (cfg, id)
43        }
44        Err(_) => {
45            tracing::info!("PACKAGE_PATH not set; loading config from _sys_* tables (use config APIs or POST /api/v1/config/package to insert)");
46            let cfg = load_from_pool(&pool, DEFAULT_PACKAGE_ID)
47                .await
48                .map_err(|e| -> Box<dyn std::error::Error> { Box::new(e) })?;
49            (cfg, DEFAULT_PACKAGE_ID.to_string())
50        }
51    };
52    apply_migrations(
53        &pool,
54        &config,
55        None,
56        None,
57        dialect.as_ref(),
58        &HashMap::new(),
59    )
60    .await?;
61    let model = resolve(&config)?.with_package_id(&package_id);
62    let mut package_models = HashMap::new();
63    package_models.insert(package_id.clone(), model.clone());
64    let storage = architect_sdk::init_storage_provider().await;
65    let event_client = architect_sdk::events::DecisionHubClient::from_env();
66    let authrs_client = architect_sdk::authrs::AuthrsClient::from_env();
67    let state = AppState {
68        pool: pool.clone(),
69        model: Arc::new(RwLock::new(model)),
70        package_models: Arc::new(RwLock::new(package_models)),
71        tenant_pools: Arc::new(RwLock::new(HashMap::new())),
72        tenant_registry: Arc::new(tenant_registry),
73        storage,
74        event_client,
75        authrs_client,
76        dialect,
77        extensible_cache: Default::default(),
78        cross_package_index: Arc::new(RwLock::new(None)),
79    };
80
81    let api = Router::new()
82        .merge(common_routes_with_ready(state.clone()))
83        .nest("/api/v1", config_routes(state.clone()))
84        .nest("/api/v1", entity_routes(state));
85
86    let app = Router::new().nest("/", api);
87
88    let listener = TcpListener::bind("0.0.0.0:3000").await?;
89    tracing::info!("listening on {}", listener.local_addr()?);
90    axum::serve(listener, app).await?;
91    Ok(())
92}
93
94/// Read all JSON records for a config kind from a package directory.
95/// Tries `{kind}.json` first (flat file), then scans `{kind}/*.json` (subdirectory),
96/// merging all arrays in alphabetical order. Returns an empty vec if neither exists.
97async fn read_kind_from_dir(
98    dir: &Path,
99    kind: &str,
100) -> Result<Vec<serde_json::Value>, Box<dyn std::error::Error>> {
101    let flat = dir.join(format!("{}.json", kind));
102    if flat.exists() {
103        let content = tokio::fs::read_to_string(&flat).await?;
104        return Ok(serde_json::from_str(&content)?);
105    }
106
107    let subdir = dir.join(kind);
108    if subdir.is_dir() {
109        let mut read_dir = tokio::fs::read_dir(&subdir).await?;
110        let mut files: Vec<PathBuf> = Vec::new();
111        while let Some(entry) = read_dir.next_entry().await? {
112            let path = entry.path();
113            if path.extension().and_then(|e| e.to_str()) == Some("json") {
114                files.push(path);
115            }
116        }
117        files.sort();
118        let mut merged: Vec<serde_json::Value> = Vec::new();
119        for path in files {
120            let content = tokio::fs::read_to_string(&path).await?;
121            let mut items: Vec<serde_json::Value> = serde_json::from_str(&content)?;
122            merged.append(&mut items);
123        }
124        return Ok(merged);
125    }
126
127    Ok(vec![])
128}
129
130async fn load_config_from_package_path(
131    dir: &str,
132) -> Result<(FullConfig, String), Box<dyn std::error::Error>> {
133    let dir = PathBuf::from(dir);
134    let manifest_path = dir.join("manifest.json");
135    let manifest_json = tokio::fs::read_to_string(&manifest_path)
136        .await
137        .map_err(|e| format!("package path must contain manifest.json: {}", e))?;
138    let manifest: serde_json::Value = serde_json::from_str(&manifest_json)?;
139    let manifest_obj = manifest.as_object().ok_or_else(|| {
140        std::io::Error::new(
141            std::io::ErrorKind::InvalidData,
142            "manifest.json must be an object",
143        )
144    })?;
145    let package_id = manifest_obj
146        .get("id")
147        .and_then(|v| v.as_str())
148        .ok_or_else(|| {
149            std::io::Error::new(
150                std::io::ErrorKind::InvalidData,
151                "manifest must have 'id' (string)",
152            )
153        })?
154        .to_string();
155    let _name = manifest_obj
156        .get("name")
157        .and_then(|v| v.as_str())
158        .ok_or_else(|| {
159            std::io::Error::new(
160                std::io::ErrorKind::InvalidData,
161                "manifest must have 'name' (string)",
162            )
163        })?;
164    let _version = manifest_obj
165        .get("version")
166        .and_then(|v| v.as_str())
167        .ok_or_else(|| {
168            std::io::Error::new(
169                std::io::ErrorKind::InvalidData,
170                "manifest must have 'version' (string)",
171            )
172        })?;
173    let schema_name = manifest_obj
174        .get("schema")
175        .and_then(|v| v.as_str())
176        .ok_or_else(|| {
177            std::io::Error::new(
178                std::io::ErrorKind::InvalidData,
179                "manifest must have 'schema' (string)",
180            )
181        })?;
182    tracing::info!(
183        "package manifest: id={:?} name={:?} version={:?} schema={:?}",
184        package_id,
185        _name,
186        _version,
187        schema_name
188    );
189
190    let schemas = vec![serde_json::json!({ "id": "default", "name": schema_name })];
191    let schemas: Vec<architect_sdk::config::SchemaConfig> =
192        serde_json::from_value(serde_json::Value::Array(schemas))?;
193
194    let mut enums = read_kind_from_dir(&dir, "enums").await?;
195    for o in enums.iter_mut() {
196        if let Some(obj) = o.as_object_mut() {
197            obj.entry("schema_id")
198                .or_insert_with(|| serde_json::Value::String("default".into()));
199        }
200    }
201    let enums: Vec<architect_sdk::config::EnumConfig> =
202        serde_json::from_value(serde_json::Value::Array(enums))?;
203
204    let mut tables = read_kind_from_dir(&dir, "tables").await?;
205    for o in tables.iter_mut() {
206        if let Some(obj) = o.as_object_mut() {
207            obj.entry("schema_id")
208                .or_insert_with(|| serde_json::Value::String("default".into()));
209        }
210    }
211    let tables: Vec<architect_sdk::config::TableConfig> =
212        serde_json::from_value(serde_json::Value::Array(tables))?;
213
214    let columns_raw = read_kind_from_dir(&dir, "columns").await?;
215    let columns: Vec<architect_sdk::config::ColumnConfig> =
216        serde_json::from_value(serde_json::Value::Array(columns_raw))?;
217
218    let mut indexes = read_kind_from_dir(&dir, "indexes").await?;
219    for o in indexes.iter_mut() {
220        if let Some(obj) = o.as_object_mut() {
221            obj.entry("schema_id")
222                .or_insert_with(|| serde_json::Value::String("default".into()));
223        }
224    }
225    let indexes: Vec<architect_sdk::config::IndexConfig> =
226        serde_json::from_value(serde_json::Value::Array(indexes))?;
227
228    let mut relationships = read_kind_from_dir(&dir, "relationships").await?;
229    for o in relationships.iter_mut() {
230        if let Some(obj) = o.as_object_mut() {
231            obj.entry("from_schema_id")
232                .or_insert_with(|| serde_json::Value::String("default".into()));
233            obj.entry("to_schema_id")
234                .or_insert_with(|| serde_json::Value::String("default".into()));
235        }
236    }
237    let relationships: Vec<architect_sdk::config::RelationshipConfig> =
238        serde_json::from_value(serde_json::Value::Array(relationships))?;
239
240    let api_entities_raw = read_kind_from_dir(&dir, "api_entities").await?;
241    let api_entities: Vec<architect_sdk::config::ApiEntityConfig> =
242        serde_json::from_value(serde_json::Value::Array(api_entities_raw))?;
243
244    let kv_stores_raw = read_kind_from_dir(&dir, "kv_stores").await?;
245    let kv_stores: Vec<architect_sdk::config::KvStoreConfig> =
246        serde_json::from_value(serde_json::Value::Array(kv_stores_raw))?;
247
248    Ok((
249        FullConfig {
250            schemas,
251            enums,
252            tables,
253            columns,
254            indexes,
255            relationships,
256            api_entities,
257            kv_stores,
258        },
259        package_id,
260    ))
261}
server/server.rs

server/
server.rs
