@feltdb/core 0.4.12 → 0.4.14

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

@@ -0,0 +1,97 @@
+use serde::Serialize;
+use std::sync::{
+    atomic::{AtomicU64, Ordering},
+    Arc,
+};
+
+#[derive(Clone, Default)]
+pub struct Metrics {
+    inner: Arc<Inner>,
+}
+
+#[derive(Default)]
+struct Inner {
+    requests: AtomicU64,
+    authentication_failures: AtomicU64,
+    state_reads: AtomicU64,
+    state_mutations: AtomicU64,
+    event_connections: AtomicU64,
+    sync_operations_sent: AtomicU64,
+    sync_operations_received: AtomicU64,
+    peer_sync_successes: AtomicU64,
+    peer_sync_failures: AtomicU64,
+    operations_compacted: AtomicU64,
+}
+
+#[derive(Serialize)]
+pub struct MetricsSnapshot {
+    pub requests: u64,
+    pub authentication_failures: u64,
+    pub state_reads: u64,
+    pub state_mutations: u64,
+    pub event_connections: u64,
+    pub sync_operations_sent: u64,
+    pub sync_operations_received: u64,
+    pub peer_sync_successes: u64,
+    pub peer_sync_failures: u64,
+    pub operations_compacted: u64,
+}
+
+impl Metrics {
+    pub fn request(&self) {
+        self.inner.requests.fetch_add(1, Ordering::Relaxed);
+    }
+    pub fn authentication_failure(&self) {
+        self.inner
+            .authentication_failures
+            .fetch_add(1, Ordering::Relaxed);
+    }
+    pub fn state_read(&self) {
+        self.inner.state_reads.fetch_add(1, Ordering::Relaxed);
+    }
+    pub fn state_mutation(&self) {
+        self.inner.state_mutations.fetch_add(1, Ordering::Relaxed);
+    }
+    pub fn event_connection(&self) {
+        self.inner.event_connections.fetch_add(1, Ordering::Relaxed);
+    }
+    pub fn sync_sent(&self, count: u64) {
+        self.inner
+            .sync_operations_sent
+            .fetch_add(count, Ordering::Relaxed);
+    }
+    pub fn sync_received(&self, count: u64) {
+        self.inner
+            .sync_operations_received
+            .fetch_add(count, Ordering::Relaxed);
+    }
+    pub fn peer_sync_success(&self) {
+        self.inner
+            .peer_sync_successes
+            .fetch_add(1, Ordering::Relaxed);
+    }
+    pub fn peer_sync_failure(&self) {
+        self.inner
+            .peer_sync_failures
+            .fetch_add(1, Ordering::Relaxed);
+    }
+    pub fn operations_compacted(&self, count: u64) {
+        self.inner
+            .operations_compacted
+            .fetch_add(count, Ordering::Relaxed);
+    }
+    pub fn snapshot(&self) -> MetricsSnapshot {
+        MetricsSnapshot {
+            requests: self.inner.requests.load(Ordering::Relaxed),
+            authentication_failures: self.inner.authentication_failures.load(Ordering::Relaxed),
+            state_reads: self.inner.state_reads.load(Ordering::Relaxed),
+            state_mutations: self.inner.state_mutations.load(Ordering::Relaxed),
+            event_connections: self.inner.event_connections.load(Ordering::Relaxed),
+            sync_operations_sent: self.inner.sync_operations_sent.load(Ordering::Relaxed),
+            sync_operations_received: self.inner.sync_operations_received.load(Ordering::Relaxed),
+            peer_sync_successes: self.inner.peer_sync_successes.load(Ordering::Relaxed),
+            peer_sync_failures: self.inner.peer_sync_failures.load(Ordering::Relaxed),
+            operations_compacted: self.inner.operations_compacted.load(Ordering::Relaxed),
+        }
+    }
+}

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

@@ -0,0 +1,350 @@
+use base64::{engine::general_purpose::STANDARD, Engine};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use sha2::{Digest, Sha256};
+use std::{
+    collections::BTreeMap,
+    fs,
+    path::PathBuf,
+    sync::{Arc, RwLock},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+pub const BUNDLE_FORMAT_VERSION: u32 = 1;
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ExportOptions {
+    pub include_data: bool,
+    pub include_artifacts: bool,
+    pub include_history: bool,
+    pub include_audit: bool,
+    pub include_provenance: bool,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ImportMode {
+    New,
+    Clone,
+    Restore,
+    Replace,
+    Merge,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BundleManifest {
+    pub bundle_id: String,
+    pub format_version: u32,
+    pub feltdb_version: String,
+    pub tenant_id: String,
+    pub application_id: String,
+    pub application_revision: Option<String>,
+    pub schema_versions: Vec<u64>,
+    pub state_version: Option<String>,
+    pub artifact_roots: Vec<String>,
+    pub environment_descriptors: Vec<String>,
+    pub provenance_root: Option<String>,
+    pub audit_root: Option<String>,
+    pub integrity_root: String,
+    pub created_at: u64,
+    pub options: ExportOptions,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BundleArtifact {
+    pub manifest: Value,
+    pub content_base64: String,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PortableBundle {
+    pub format: String,
+    pub bundle: BundleManifest,
+    pub manifest: Value,
+    pub revisions: Vec<Value>,
+    pub state: Option<Value>,
+    pub artifacts: Vec<BundleArtifact>,
+    pub workflows: Vec<Value>,
+    pub connections: Vec<Value>,
+    pub environments: Vec<Value>,
+    pub policies: Vec<Value>,
+    pub provenance: Vec<Value>,
+    pub audit: Vec<Value>,
+    pub checksums: BTreeMap<String, String>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ImportPlan {
+    pub bundle_id: String,
+    pub mode: ImportMode,
+    pub destination_tenant: String,
+    pub destination_application: Option<String>,
+    pub creates: BTreeMap<String, u64>,
+    pub requires_secret_bindings: Vec<String>,
+    pub requires_provider_bindings: Vec<String>,
+    pub warnings: Vec<String>,
+    pub integrity_root: String,
+    pub mutates_destination: bool,
+}
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Records {
+    bundles: BTreeMap<String, PortableBundle>,
+}
+#[derive(Clone)]
+pub struct BundleStore {
+    path: PathBuf,
+    records: Arc<RwLock<Records>>,
+}
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+fn hash(bytes: &[u8]) -> String {
+    format!("sha256:{:x}", Sha256::digest(bytes))
+}
+pub fn canonical(value: &Value) -> Value {
+    match value {
+        Value::Object(map) => Value::Object(
+            map.iter()
+                .map(|(k, v)| (k.clone(), canonical(v)))
+                .collect::<BTreeMap<_, _>>()
+                .into_iter()
+                .collect(),
+        ),
+        Value::Array(values) => Value::Array(values.iter().map(canonical).collect()),
+        v => v.clone(),
+    }
+}
+fn bytes(value: &Value) -> Result<Vec<u8>, String> {
+    serde_json::to_vec(&canonical(value)).map_err(|e| e.to_string())
+}
+fn forbidden_secret(value: &Value) -> bool {
+    match value {
+        Value::Object(map) => map.iter().any(|(k, v)| {
+            matches!(
+                k.to_ascii_lowercase().as_str(),
+                "password"
+                    | "api_key"
+                    | "apikey"
+                    | "oauth_token"
+                    | "private_key"
+                    | "plaintext"
+                    | "secret_value"
+            ) || forbidden_secret(v)
+        }),
+        Value::Array(v) => v.iter().any(forbidden_secret),
+        _ => false,
+    }
+}
+impl PortableBundle {
+    pub fn build(
+        tenant: String,
+        application: String,
+        manifest: Value,
+        revisions: Vec<Value>,
+        state: Option<Value>,
+        artifacts: Vec<BundleArtifact>,
+        connections: Vec<Value>,
+        options: ExportOptions,
+    ) -> Result<Self, String> {
+        if forbidden_secret(&manifest) || connections.iter().any(forbidden_secret) {
+            return Err("bundle contains forbidden plaintext secret material".into());
+        }
+        let mut checksums = BTreeMap::new();
+        checksums.insert("manifest.json".into(), hash(&bytes(&manifest)?));
+        for (i, r) in revisions.iter().enumerate() {
+            checksums.insert(format!("revisions/{i}.json"), hash(&bytes(r)?));
+        }
+        if let Some(s) = &state {
+            checksums.insert("state/snapshot.json".into(), hash(&bytes(s)?));
+        }
+        for (i, a) in artifacts.iter().enumerate() {
+            let content = STANDARD
+                .decode(&a.content_base64)
+                .map_err(|_| "artifact payload invalid")?;
+            let expected = a
+                .manifest
+                .get("content_hash")
+                .and_then(Value::as_str)
+                .ok_or("artifact hash missing")?;
+            if hash(&content).trim_start_matches("sha256:") != expected {
+                return Err("artifact integrity mismatch".into());
+            }
+            checksums.insert(format!("artifacts/{i}.json"), hash(&bytes(&a.manifest)?));
+            checksums.insert(format!("artifacts/{i}.content"), hash(&content));
+        }
+        for (i, c) in connections.iter().enumerate() {
+            checksums.insert(format!("connections/{i}.json"), hash(&bytes(c)?));
+        }
+        let integrity_root = hash(&serde_json::to_vec(&checksums).map_err(|e| e.to_string())?);
+        let bundle_id = format!(
+            "bundle_{}",
+            integrity_root
+                .trim_start_matches("sha256:")
+                .chars()
+                .take(24)
+                .collect::<String>()
+        );
+        let application_revision = revisions
+            .first()
+            .and_then(|v| v.get("revision_id"))
+            .and_then(Value::as_str)
+            .map(Into::into);
+        let artifact_roots = artifacts
+            .iter()
+            .filter_map(|a| a.manifest.get("id").and_then(Value::as_str).map(Into::into))
+            .collect();
+        let environments = manifest
+            .get("environments")
+            .and_then(Value::as_array)
+            .cloned()
+            .unwrap_or_default();
+        Ok(Self {
+            format: "feltdb-bundle/v1".into(),
+            bundle: BundleManifest {
+                bundle_id,
+                format_version: BUNDLE_FORMAT_VERSION,
+                feltdb_version: env!("CARGO_PKG_VERSION").into(),
+                tenant_id: tenant,
+                application_id: application,
+                application_revision,
+                schema_versions: vec![1],
+                state_version: state
+                    .as_ref()
+                    .and_then(|v| v.get("content_hash"))
+                    .and_then(Value::as_str)
+                    .map(Into::into),
+                artifact_roots,
+                environment_descriptors: environments
+                    .iter()
+                    .filter_map(|v| v.get("name").and_then(Value::as_str).map(Into::into))
+                    .collect(),
+                provenance_root: None,
+                audit_root: None,
+                integrity_root,
+                created_at: now(),
+                options,
+            },
+            manifest,
+            revisions,
+            state,
+            artifacts,
+            workflows: vec![],
+            connections,
+            environments,
+            policies: vec![],
+            provenance: vec![],
+            audit: vec![],
+            checksums,
+        })
+    }
+    pub fn verify(&self) -> Result<(), String> {
+        if self.format != "feltdb-bundle/v1" || self.bundle.format_version != BUNDLE_FORMAT_VERSION
+        {
+            return Err("unsupported bundle format".into());
+        }
+        let rebuilt = Self::build(
+            self.bundle.tenant_id.clone(),
+            self.bundle.application_id.clone(),
+            self.manifest.clone(),
+            self.revisions.clone(),
+            self.state.clone(),
+            self.artifacts.clone(),
+            self.connections.clone(),
+            self.bundle.options.clone(),
+        )?;
+        if rebuilt.checksums != self.checksums
+            || rebuilt.bundle.integrity_root != self.bundle.integrity_root
+            || rebuilt.bundle.bundle_id != self.bundle.bundle_id
+        {
+            return Err("bundle integrity verification failed".into());
+        }
+        Ok(())
+    }
+    pub fn plan(
+        &self,
+        mode: ImportMode,
+        tenant: String,
+        application: Option<String>,
+    ) -> Result<ImportPlan, String> {
+        self.verify()?;
+        let secret_refs = self
+            .connections
+            .iter()
+            .flat_map(|c| {
+                c.get("secret_refs")
+                    .and_then(Value::as_array)
+                    .cloned()
+                    .unwrap_or_default()
+            })
+            .filter_map(|v| v.get("secret_id").and_then(Value::as_str).map(Into::into))
+            .collect();
+        let providers = self
+            .connections
+            .iter()
+            .filter_map(|c| c.get("provider").and_then(Value::as_str).map(Into::into))
+            .collect();
+        Ok(ImportPlan{bundle_id:self.bundle.bundle_id.clone(),mode,destination_tenant:tenant,destination_application:application,creates:[("revisions".into(),self.revisions.len()as u64),("records".into(),self.state.as_ref().and_then(|v|v.get("rows")).and_then(Value::as_array).map(|v|v.len()as u64).unwrap_or(0)),("artifacts".into(),self.artifacts.len()as u64),("connections".into(),self.connections.len()as u64)].into(),requires_secret_bindings:secret_refs,requires_provider_bindings:providers,warnings:vec!["Imported principals and grants are never trusted; destination authorization is re-evaluated.".into()],integrity_root:self.bundle.integrity_root.clone(),mutates_destination:false})
+    }
+}
+impl BundleStore {
+    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 tmp = self.path.with_extension("tmp");
+        fs::write(
+            &tmp,
+            serde_json::to_vec_pretty(r).map_err(|e| e.to_string())?,
+        )
+        .map_err(|e| e.to_string())?;
+        fs::rename(tmp, &self.path).map_err(|e| e.to_string())
+    }
+    pub fn put(&self, bundle: PortableBundle) -> Result<(), String> {
+        bundle.verify()?;
+        let mut r = self
+            .records
+            .write()
+            .map_err(|_| "bundle store lock poisoned")?;
+        r.bundles.insert(bundle.bundle.bundle_id.clone(), bundle);
+        self.persist(&r)
+    }
+    pub fn get(&self, id: &str) -> Option<PortableBundle> {
+        self.records.read().ok()?.bundles.get(id).cloned()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn deterministic_round_trip_tamper_and_secret_safety() {
+        let options = ExportOptions {
+            include_data: true,
+            include_artifacts: false,
+            include_history: true,
+            include_audit: false,
+            include_provenance: false,
+        };
+        let b=PortableBundle::build("t".into(),"a".into(),serde_json::json!({"application_id":"a","environments":[]}),vec![serde_json::json!({"revision_id":"r1"})],Some(serde_json::json!({"rows":[],"content_hash":"h"})),vec![],vec![serde_json::json!({"provider":"postgres","secret_refs":[{"secret_id":"secret://unbound"}]})],options).unwrap();
+        b.verify().unwrap();
+        assert!(!serde_json::to_string(&b)
+            .unwrap()
+            .contains("password-value"));
+        let plan = b.plan(ImportMode::Clone, "other".into(), None).unwrap();
+        assert!(!plan.mutates_destination);
+        assert_eq!(plan.requires_secret_bindings.len(), 1);
+        let mut changed = b;
+        changed.manifest["application_id"] = "changed".into();
+        assert!(changed.verify().is_err());
+    }
+}