@feltdb/core 0.4.12 → 0.4.13

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

@@ -0,0 +1,449 @@
+use crate::{content::ContentStore, tenancy::TenancyStore};
+use rand::{distributions::Alphanumeric, Rng};
+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 = "SCREAMING_SNAKE_CASE")]
+pub enum ArtifactKind {
+    Source,
+    Document,
+    Image,
+    Dataset,
+    Form,
+    Build,
+    Package,
+    ModelOutput,
+    ExecutionOutput,
+    Log,
+    Report,
+    Backup,
+    Export,
+    Import,
+    Application,
+    Configuration,
+    Other(String),
+}
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum ArtifactLifecycle {
+    Created,
+    Active,
+    Superseded,
+    Archived,
+    Deleted,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ProducerRef {
+    pub kind: String,
+    pub id: String,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct RetentionPolicy {
+    pub retain_until: Option<u64>,
+    pub retention_class: Option<String>,
+    pub legal_hold: bool,
+    pub delete_after: Option<u64>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ArtifactMetadata {
+    pub name: String,
+    pub environment: Option<String>,
+    #[serde(default)]
+    pub tags: BTreeSet<String>,
+    #[serde(default)]
+    pub labels: BTreeMap<String, String>,
+    pub sensitivity: Option<String>,
+    pub classification: Option<String>,
+    #[serde(default)]
+    pub retention: RetentionPolicy,
+    #[serde(default)]
+    pub application: Value,
+    #[serde(default)]
+    pub provider: Value,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Artifact {
+    pub id: String,
+    pub tenant_id: String,
+    pub application_id: String,
+    pub content_hash: String,
+    pub content_type: String,
+    pub size: u64,
+    pub kind: ArtifactKind,
+    pub lifecycle: ArtifactLifecycle,
+    pub created_by: String,
+    pub producer: ProducerRef,
+    pub source: Option<String>,
+    #[serde(default)]
+    pub parents: Vec<String>,
+    pub supersedes: Option<String>,
+    pub revision: Option<String>,
+    pub workload: Option<String>,
+    pub execution: Option<String>,
+    pub metadata: ArtifactMetadata,
+    pub created_at: u64,
+}
+impl Artifact {
+    pub fn reference(&self) -> String {
+        format!(
+            "artifact://{}/{}/{}",
+            self.tenant_id, self.application_id, self.id
+        )
+    }
+}
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Records {
+    artifacts: Vec<Artifact>,
+}
+#[derive(Clone)]
+pub struct ArtifactStore {
+    path: PathBuf,
+    content: ContentStore,
+    records: Arc<RwLock<Records>>,
+}
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs()
+}
+fn id() -> String {
+    format!(
+        "artifact_{}",
+        rand::thread_rng()
+            .sample_iter(&Alphanumeric)
+            .take(20)
+            .map(char::from)
+            .collect::<String>()
+    )
+}
+impl ArtifactStore {
+    pub fn load(path: impl Into<PathBuf>, content: ContentStore) -> 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,
+            content,
+            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())
+    }
+    fn allowed(actor: &str, tenancy: &TenancyStore, app: &str, capability: &str) -> bool {
+        tenancy
+            .application_tenant(app)
+            .map(|tenant| {
+                tenancy.authorize_application(actor, &tenant, app, capability)
+                    || tenancy.authorize_application(actor, &tenant, app, "applications:write")
+                    || tenancy.authorize_application(actor, &tenant, app, "applications:read")
+            })
+            .unwrap_or(false)
+    }
+    pub fn create(
+        &self,
+        actor: &str,
+        tenancy: &TenancyStore,
+        application_id: &str,
+        kind: ArtifactKind,
+        content_type: String,
+        bytes: &[u8],
+        producer: ProducerRef,
+        parents: Vec<String>,
+        supersedes: Option<String>,
+        metadata: ArtifactMetadata,
+        revision: Option<String>,
+        workload: Option<String>,
+        execution: Option<String>,
+    ) -> Result<Artifact, String> {
+        if !Self::allowed(actor, tenancy, application_id, "artifact:create") {
+            return Err("forbidden".into());
+        }
+        let tenant_id = tenancy
+            .application_tenant(application_id)
+            .ok_or("application not found")?;
+        let records = self
+            .records
+            .read()
+            .map_err(|_| "artifact store lock poisoned")?;
+        for reference in parents.iter().chain(supersedes.iter()) {
+            if !records.artifacts.iter().any(|a| {
+                &a.id == reference
+                    && a.tenant_id == tenant_id
+                    && a.application_id == application_id
+                    && a.lifecycle != ArtifactLifecycle::Deleted
+            }) {
+                return Err("parent artifact unavailable or outside application boundary".into());
+            }
+        }
+        drop(records);
+        let hash = self.content.store(bytes).map_err(|e| e.to_string())?;
+        let artifact = Artifact {
+            id: id(),
+            tenant_id,
+            application_id: application_id.into(),
+            content_hash: hash,
+            content_type,
+            size: bytes.len() as u64,
+            kind,
+            lifecycle: ArtifactLifecycle::Active,
+            created_by: actor.into(),
+            producer,
+            source: None,
+            parents,
+            supersedes,
+            revision,
+            workload,
+            execution,
+            metadata,
+            created_at: now(),
+        };
+        let mut r = self
+            .records
+            .write()
+            .map_err(|_| "artifact store lock poisoned")?;
+        if let Some(old) = artifact
+            .supersedes
+            .as_ref()
+            .and_then(|id| r.artifacts.iter_mut().find(|a| &a.id == id))
+        {
+            old.lifecycle = ArtifactLifecycle::Superseded
+        }
+        r.artifacts.push(artifact.clone());
+        self.persist(&r)?;
+        Ok(artifact)
+    }
+    pub fn list(
+        &self,
+        actor: &str,
+        tenancy: &TenancyStore,
+        app: &str,
+    ) -> Result<Vec<Artifact>, String> {
+        if !Self::allowed(actor, tenancy, app, "artifact:read") {
+            return Err("forbidden".into());
+        }
+        Ok(self
+            .records
+            .read()
+            .map_err(|_| "artifact store lock poisoned")?
+            .artifacts
+            .iter()
+            .filter(|a| a.application_id == app && a.lifecycle != ArtifactLifecycle::Deleted)
+            .cloned()
+            .collect())
+    }
+    pub fn get(&self, actor: &str, tenancy: &TenancyStore, id: &str) -> Result<Artifact, String> {
+        let r = self
+            .records
+            .read()
+            .map_err(|_| "artifact store lock poisoned")?;
+        let a = r
+            .artifacts
+            .iter()
+            .find(|a| a.id == id && a.lifecycle != ArtifactLifecycle::Deleted)
+            .ok_or("artifact not found")?;
+        if !Self::allowed(actor, tenancy, &a.application_id, "artifact:read") {
+            return Err("forbidden".into());
+        }
+        Ok(a.clone())
+    }
+    pub fn content(
+        &self,
+        actor: &str,
+        tenancy: &TenancyStore,
+        id: &str,
+    ) -> Result<Vec<u8>, String> {
+        let a = self.get(actor, tenancy, id)?;
+        self.content
+            .get(&a.content_hash)
+            .map_err(|_| "artifact integrity failure".to_string())?
+            .ok_or("artifact content missing".into())
+    }
+    pub fn lifecycle(
+        &self,
+        actor: &str,
+        tenancy: &TenancyStore,
+        id: &str,
+        next: ArtifactLifecycle,
+    ) -> Result<Artifact, String> {
+        let mut r = self
+            .records
+            .write()
+            .map_err(|_| "artifact store lock poisoned")?;
+        let a = r
+            .artifacts
+            .iter_mut()
+            .find(|a| a.id == id)
+            .ok_or("artifact not found")?;
+        if !Self::allowed(actor, tenancy, &a.application_id, "artifact:write") {
+            return Err("forbidden".into());
+        }
+        let valid = matches!(
+            (a.lifecycle, next),
+            (ArtifactLifecycle::Active, ArtifactLifecycle::Archived)
+                | (ArtifactLifecycle::Archived, ArtifactLifecycle::Active)
+                | (_, ArtifactLifecycle::Deleted)
+        );
+        if !valid {
+            return Err("invalid artifact lifecycle transition".into());
+        }
+        if next == ArtifactLifecycle::Deleted
+            && (a.metadata.retention.legal_hold
+                || a.metadata
+                    .retention
+                    .retain_until
+                    .is_some_and(|at| at > now()))
+        {
+            return Err("artifact retention policy prevents deletion".into());
+        }
+        a.lifecycle = next;
+        let out = a.clone();
+        self.persist(&r)?;
+        Ok(out)
+    }
+    pub fn parents(
+        &self,
+        actor: &str,
+        tenancy: &TenancyStore,
+        id: &str,
+    ) -> Result<Vec<Artifact>, String> {
+        let a = self.get(actor, tenancy, id)?;
+        let r = self
+            .records
+            .read()
+            .map_err(|_| "artifact store lock poisoned")?;
+        Ok(r.artifacts
+            .iter()
+            .filter(|candidate| {
+                a.parents.contains(&candidate.id) || a.supersedes.as_ref() == Some(&candidate.id)
+            })
+            .cloned()
+            .collect())
+    }
+    pub fn children(
+        &self,
+        actor: &str,
+        tenancy: &TenancyStore,
+        id: &str,
+    ) -> Result<Vec<Artifact>, String> {
+        let a = self.get(actor, tenancy, id)?;
+        let r = self
+            .records
+            .read()
+            .map_err(|_| "artifact store lock poisoned")?;
+        Ok(r.artifacts
+            .iter()
+            .filter(|candidate| {
+                candidate.application_id == a.application_id
+                    && (candidate.parents.contains(&a.id)
+                        || candidate.supersedes.as_ref() == Some(&a.id))
+            })
+            .cloned()
+            .collect())
+    }
+    pub fn verify(&self, actor: &str, tenancy: &TenancyStore, id: &str) -> Result<bool, String> {
+        self.content(actor, tenancy, id).map(|_| true)
+    }
+    pub fn content_references(&self, hash: &str) -> usize {
+        self.records
+            .read()
+            .map(|r| {
+                r.artifacts
+                    .iter()
+                    .filter(|a| a.content_hash == hash && a.lifecycle != ArtifactLifecycle::Deleted)
+                    .count()
+            })
+            .unwrap_or(0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn upload_dedup_immutability_lineage_and_gc_refs() {
+        let suffix = id();
+        let tenancy =
+            TenancyStore::load(std::env::temp_dir().join(format!("{suffix}-tenant"))).unwrap();
+        let tenant = tenancy.create_tenant("owner", "Artifacts").unwrap();
+        let app = tenancy
+            .create_application("owner", &tenant.id, "App")
+            .unwrap();
+        let root = std::env::temp_dir().join(format!("{suffix}-content"));
+        let content = ContentStore::new(root.clone()).unwrap();
+        let store = ArtifactStore::load(
+            std::env::temp_dir().join(format!("{suffix}-artifacts")),
+            content,
+        )
+        .unwrap();
+        let producer = ProducerRef {
+            kind: "human".into(),
+            id: "owner".into(),
+        };
+        let a = store
+            .create(
+                "owner",
+                &tenancy,
+                &app.id,
+                ArtifactKind::Document,
+                "text/plain".into(),
+                b"same",
+                producer.clone(),
+                vec![],
+                None,
+                ArtifactMetadata::default(),
+                None,
+                None,
+                None,
+            )
+            .unwrap();
+        let b = store
+            .create(
+                "owner",
+                &tenancy,
+                &app.id,
+                ArtifactKind::Report,
+                "text/plain".into(),
+                b"same",
+                producer,
+                vec![a.id.clone()],
+                Some(a.id.clone()),
+                ArtifactMetadata::default(),
+                None,
+                Some("workload-1".into()),
+                Some("execution-1".into()),
+            )
+            .unwrap();
+        assert_eq!(a.content_hash, b.content_hash);
+        assert_eq!(store.content_references(&a.content_hash), 2);
+        assert_eq!(store.parents("owner", &tenancy, &b.id).unwrap().len(), 1);
+        assert_eq!(store.content("owner", &tenancy, &b.id).unwrap(), b"same");
+        store
+            .lifecycle("owner", &tenancy, &b.id, ArtifactLifecycle::Deleted)
+            .unwrap();
+        assert_eq!(store.content_references(&a.content_hash), 1);
+        let _ = fs::remove_dir_all(root);
+    }
+}

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

@@ -0,0 +1,59 @@
+use std::{
+    fs::OpenOptions,
+    io::Write,
+    path::PathBuf,
+    sync::{Arc, Mutex},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use serde::Serialize;
+
+#[derive(Clone)]
+pub struct AuditLog {
+    path: Arc<PathBuf>,
+    lock: Arc<Mutex<()>>,
+}
+
+#[derive(Serialize)]
+pub struct AuditEvent<'a> {
+    pub timestamp_ms: u128,
+    pub namespace: &'a str,
+    pub principal: &'a str,
+    pub action: &'a str,
+    pub target: &'a str,
+    pub outcome: &'a str,
+    pub status: u16,
+}
+
+impl AuditLog {
+    pub fn new(path: PathBuf) -> Self {
+        Self {
+            path: Arc::new(path),
+            lock: Arc::new(Mutex::new(())),
+        }
+    }
+
+    pub fn record(&self, mut event: AuditEvent<'_>) -> Result<(), String> {
+        let _guard = self
+            .lock
+            .lock()
+            .map_err(|_| "audit log lock poisoned".to_string())?;
+        if let Some(parent) = self.path.parent() {
+            std::fs::create_dir_all(parent).map_err(|error| error.to_string())?;
+        }
+        event.timestamp_ms = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .map_err(|error| error.to_string())?
+            .as_millis();
+        let mut file = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&*self.path)
+            .map_err(|error| error.to_string())?;
+        serde_json::to_writer(&mut file, &event).map_err(|error| error.to_string())?;
+        file.write_all(b"\n").map_err(|error| error.to_string())?;
+        file.flush().map_err(|error| error.to_string())?;
+        file.sync_data().map_err(|error| error.to_string())?;
+        Ok(())
+    }
+}