@feltdb/core 0.4.12 → 0.4.14

package/dist/create/server-source/crates/feltdb-server/src/providers.rs

@@ -0,0 +1,269 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    fs,
+    path::PathBuf,
+    sync::{Arc, RwLock},
+    time::{SystemTime, UNIX_EPOCH},
+};
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ProviderType {
+    Connection,
+    Storage,
+    Search,
+    Vector,
+    Llm,
+    Embedding,
+    Identity,
+    Delivery,
+    Worker,
+    Execution,
+    Scheduler,
+    Deployment,
+    Observability,
+    Ui,
+    Workflow,
+    Capability,
+    Agent,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum ProviderStatus {
+    Installed,
+    Available,
+    Enabled,
+    Disabled,
+    Revoked,
+    UpgradePending,
+    Failed,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProviderManifest {
+    pub provider_id: String,
+    pub namespace: String,
+    pub provider_type: ProviderType,
+    pub version: String,
+    pub feltdb_contract: String,
+    pub capabilities: BTreeSet<String>,
+    pub permissions: BTreeSet<String>,
+    pub environments: BTreeSet<String>,
+    pub runtimes: BTreeSet<String>,
+    pub dependencies: BTreeMap<String, String>,
+    pub configuration_schema: Value,
+    pub secret_requirements: Vec<String>,
+    pub migration_required: bool,
+    pub publisher: String,
+    pub package_ref: String,
+    pub package_hash: String,
+    pub signature: Option<String>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProviderHealth {
+    pub status: String,
+    pub ready: bool,
+    pub version: String,
+    pub last_invocation: Option<u64>,
+    pub last_failure: Option<String>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InstalledProvider {
+    pub manifest: ProviderManifest,
+    pub status: ProviderStatus,
+    pub installed_at: u64,
+    pub tenant_bindings: BTreeSet<String>,
+    pub application_bindings: BTreeSet<String>,
+    pub granted_capabilities: BTreeSet<String>,
+    pub configuration_revision: Option<String>,
+    pub health: ProviderHealth,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProviderExecutionContext {
+    pub tenant_id: String,
+    pub application_id: String,
+    pub provider_id: String,
+    pub capabilities: BTreeSet<String>,
+    pub resource_scope: String,
+    pub workload_id: Option<String>,
+    pub deadline: u64,
+    pub causal_id: Option<String>,
+}
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Records {
+    providers: BTreeMap<String, InstalledProvider>,
+}
+#[derive(Clone)]
+pub struct ProviderStore {
+    path: PathBuf,
+    records: Arc<RwLock<Records>>,
+}
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+impl ProviderStore {
+    pub fn load(path: impl Into<PathBuf>) -> Result<Self, String> {
+        let path = path.into();
+        let records = if path.exists() {
+            serde_json::from_slice(&fs::read(&path).map_err(|e| e.to_string())?)
+                .map_err(|e| e.to_string())?
+        } else {
+            Records::default()
+        };
+        Ok(Self {
+            path,
+            records: Arc::new(RwLock::new(records)),
+        })
+    }
+    fn persist(&self, r: &Records) -> Result<(), String> {
+        if let Some(p) = self.path.parent() {
+            fs::create_dir_all(p).map_err(|e| e.to_string())?
+        }
+        let t = self.path.with_extension("tmp");
+        fs::write(&t, serde_json::to_vec_pretty(r).map_err(|e| e.to_string())?)
+            .map_err(|e| e.to_string())?;
+        fs::rename(t, &self.path).map_err(|e| e.to_string())
+    }
+    pub fn verify(&self, m: &ProviderManifest) -> Result<(), String> {
+        if m.provider_id.trim().is_empty() || m.namespace.trim().is_empty() {
+            return Err("provider identity is required".into());
+        }
+        if m.package_hash.is_empty() {
+            return Err("provider package hash is required".into());
+        }
+        if m.signature.is_none() {
+            return Err("unsigned provider packages cannot be activated".into());
+        }
+        if m.feltdb_contract != "1" {
+            return Err("incompatible FeltDB provider contract".into());
+        }
+        Ok(())
+    }
+    pub fn install(
+        &self,
+        m: ProviderManifest,
+        tenant: Option<String>,
+        application: Option<String>,
+    ) -> Result<InstalledProvider, String> {
+        self.verify(&m)?;
+        let mut r = self
+            .records
+            .write()
+            .map_err(|_| "provider store lock poisoned")?;
+        if r.providers.contains_key(&m.provider_id) {
+            return Err("provider already installed".into());
+        }
+        let id = m.provider_id.clone();
+        let p = InstalledProvider {
+            health: ProviderHealth {
+                status: "unknown".into(),
+                ready: false,
+                version: m.version.clone(),
+                last_invocation: None,
+                last_failure: None,
+            },
+            manifest: m,
+            status: ProviderStatus::Installed,
+            installed_at: now(),
+            tenant_bindings: tenant.into_iter().collect(),
+            application_bindings: application.into_iter().collect(),
+            granted_capabilities: BTreeSet::new(),
+            configuration_revision: None,
+        };
+        r.providers.insert(id, p.clone());
+        self.persist(&r)?;
+        Ok(p)
+    }
+    pub fn list(&self) -> Vec<InstalledProvider> {
+        self.records
+            .read()
+            .map(|r| r.providers.values().cloned().collect())
+            .unwrap_or_default()
+    }
+    pub fn get(&self, id: &str) -> Option<InstalledProvider> {
+        self.records.read().ok()?.providers.get(id).cloned()
+    }
+    pub fn set_status(
+        &self,
+        id: &str,
+        status: ProviderStatus,
+    ) -> Result<InstalledProvider, String> {
+        let mut r = self
+            .records
+            .write()
+            .map_err(|_| "provider store lock poisoned")?;
+        let p = r.providers.get_mut(id).ok_or("provider not found")?;
+        if status == ProviderStatus::Enabled && p.manifest.signature.is_none() {
+            return Err("unsigned provider cannot be enabled".into());
+        }
+        p.status = status;
+        p.health.ready = p.status == ProviderStatus::Enabled;
+        p.health.status = if p.health.ready {
+            "healthy".into()
+        } else {
+            "unknown".into()
+        };
+        let out = p.clone();
+        self.persist(&r)?;
+        Ok(out)
+    }
+    pub fn health(&self, id: &str) -> Result<ProviderHealth, String> {
+        Ok(self.get(id).ok_or("provider not found")?.health)
+    }
+    pub fn dependencies(&self, id: &str) -> Result<BTreeMap<String, String>, String> {
+        Ok(self
+            .get(id)
+            .ok_or("provider not found")?
+            .manifest
+            .dependencies)
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn manifest() -> ProviderManifest {
+        ProviderManifest {
+            provider_id: "local.test".into(),
+            namespace: "test".into(),
+            provider_type: ProviderType::Storage,
+            version: "1.0.0".into(),
+            feltdb_contract: "1".into(),
+            capabilities: ["storage:read".into()].into(),
+            permissions: ["artifact:read".into()].into(),
+            environments: ["development".into()].into(),
+            runtimes: ["wasm".into()].into(),
+            dependencies: BTreeMap::new(),
+            configuration_schema: serde_json::json!({"type":"object"}),
+            secret_requirements: vec![],
+            migration_required: false,
+            publisher: "test".into(),
+            package_ref: "artifact://pkg".into(),
+            package_hash: "sha256:pkg".into(),
+            signature: Some("sig".into()),
+        }
+    }
+    #[test]
+    fn lifecycle_persists_and_unsigned_is_rejected() {
+        let path = std::env::temp_dir().join(format!("providers-{}", now()));
+        let s = ProviderStore::load(&path).unwrap();
+        let p = s
+            .install(manifest(), Some("t".into()), Some("a".into()))
+            .unwrap();
+        assert_eq!(
+            s.set_status(&p.manifest.provider_id, ProviderStatus::Enabled)
+                .unwrap()
+                .status,
+            ProviderStatus::Enabled
+        );
+        assert!(s.set_status("missing", ProviderStatus::Enabled).is_err());
+        let mut bad = manifest();
+        bad.signature = None;
+        assert!(s.install(bad, None, None).is_err());
+        let s2 = ProviderStore::load(&path).unwrap();
+        assert_eq!(s2.list().len(), 1);
+        let _ = fs::remove_file(path);
+    }
+}