create-feltdb 0.8.1 → 0.8.2

package/dist/server-source/crates/feltdb-server/src/tenancy.rs

@@ -41,6 +41,41 @@ pub struct Application {
     pub active_revision: Option<String>,
     #[serde(default)]
     pub environment_revisions: std::collections::BTreeMap<String, String>,
+    #[serde(default)]
+    pub qualification: Option<QualificationMarker>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct QualificationMarker {
+    pub purpose: String,
+    pub disposable: bool,
+    pub environment: String,
+    pub proof_run_id: String,
+    pub expires_at: u64,
+}
+impl QualificationMarker {
+    fn valid_for_creation(&self, timestamp: u64) -> bool {
+        self.purpose == "qualification"
+            && self.disposable
+            && self.environment == "qualification"
+            && !self.proof_run_id.trim().is_empty()
+            && self.expires_at > timestamp
+    }
+
+    fn authorize_destruction(&self, proof_run_id: &str, timestamp: u64) -> Result<(), String> {
+        if self.purpose != "qualification" || !self.disposable {
+            return Err("refusing destructive qualification: application is not marked disposable".into());
+        }
+        if self.environment != "qualification" {
+            return Err("refusing destructive qualification: environment is not qualification".into());
+        }
+        if self.proof_run_id.trim().is_empty() || proof_run_id.trim().is_empty() || self.proof_run_id != proof_run_id {
+            return Err("refusing destructive qualification: proof run does not match".into());
+        }
+        if self.expires_at <= timestamp {
+            return Err("refusing destructive qualification: disposable marker has expired".into());
+        }
+        Ok(())
+    }
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TenantMembership {
@@ -765,10 +800,25 @@ impl TenancyStore {
         actor: &str,
         tenant_id: &str,
         name: &str,
+    ) -> Result<Application, String> {
+        self.create_application_with_qualification(actor, tenant_id, name, None)
+    }
+
+    pub fn create_application_with_qualification(
+        &self,
+        actor: &str,
+        tenant_id: &str,
+        name: &str,
+        qualification: Option<QualificationMarker>,
     ) -> Result<Application, String> {
         if !self.authorize_tenant(actor, tenant_id, "applications:write") {
             return Err("forbidden".into());
         }
+        if let Some(marker) = qualification.as_ref() {
+            if !marker.valid_for_creation(now()) {
+                return Err("invalid disposable qualification marker".into());
+            }
+        }
         let mut records = self
             .records
             .write()
@@ -794,6 +844,7 @@ impl TenancyStore {
             status: application_status(),
             active_revision: None,
             environment_revisions: Default::default(),
+            qualification,
         };
         records.application_memberships.push(ApplicationMembership {
             application_id: application.id.clone(),
@@ -816,6 +867,22 @@ impl TenancyStore {
         Ok(application)
     }
 
+    pub fn delete_qualification_application(
+        &self,
+        actor: &str,
+        application_id: &str,
+        proof_run_id: &str,
+    ) -> Result<(), String> {
+        let application = self
+            .application_for(actor, application_id)
+            .ok_or_else(|| "application not found".to_string())?;
+        let marker = application.qualification.ok_or_else(|| {
+            "refusing destructive qualification: application is not marked disposable".to_string()
+        })?;
+        marker.authorize_destruction(proof_run_id, now())?;
+        self.delete_application(actor, application_id)
+    }
+
     pub fn delete_application(&self, actor: &str, application_id: &str) -> Result<(), String> {
         let tenant_id = self
             .application_tenant(application_id)
@@ -1238,6 +1305,73 @@ mod tests {
         assert!(!store.authorize_application("user_a", &tenant_a.id, &app_b.id, "state:read"));
     }
 
+    #[test]
+    fn destructive_qualification_requires_an_unexpired_matching_marker() {
+        let valid_marker = QualificationMarker {
+            purpose: "qualification".into(), disposable: true, environment: "qualification".into(), proof_run_id: "proof-1".into(), expires_at: now() + 300,
+        };
+        assert!(valid_marker.authorize_destruction("", now()).unwrap_err().contains("does not match"));
+        assert!(valid_marker.authorize_destruction("proof-other", now()).unwrap_err().contains("does not match"));
+        let mut wrong_environment = valid_marker.clone();
+        wrong_environment.environment = "production".into();
+        assert!(wrong_environment.authorize_destruction("proof-1", now()).unwrap_err().contains("environment"));
+        let mut not_disposable = valid_marker.clone();
+        not_disposable.disposable = false;
+        assert!(not_disposable.authorize_destruction("proof-1", now()).unwrap_err().contains("not marked disposable"));
+        let mut expired = valid_marker.clone();
+        expired.expires_at = now().saturating_sub(1);
+        assert!(expired.authorize_destruction("proof-1", now()).unwrap_err().contains("expired"));
+        assert!(valid_marker.authorize_destruction("proof-1", now()).is_ok());
+
+        let store = store("qualification-guard");
+        let tenant = store.create_tenant("owner", "Qualification").unwrap();
+        let normal = store
+            .create_application("owner", &tenant.id, "Normal")
+            .unwrap();
+        assert!(store
+            .delete_qualification_application("owner", &normal.id, "proof-1")
+            .unwrap_err()
+            .contains("not marked disposable"));
+        assert!(store
+            .create_application_with_qualification(
+                "owner",
+                &tenant.id,
+                "Expired",
+                Some(QualificationMarker {
+                    purpose: "qualification".into(),
+                    disposable: true,
+                    environment: "qualification".into(),
+                    proof_run_id: "proof-expired".into(),
+                    expires_at: now().saturating_sub(1),
+                }),
+            )
+            .unwrap_err()
+            .contains("invalid disposable"));
+
+        let proof = store
+            .create_application_with_qualification(
+                "owner",
+                &tenant.id,
+                "Proof",
+                Some(QualificationMarker {
+                    purpose: "qualification".into(),
+                    disposable: true,
+                    environment: "qualification".into(),
+                    proof_run_id: "proof-1".into(),
+                    expires_at: now() + 300,
+                }),
+            )
+            .unwrap();
+        assert!(store
+            .delete_qualification_application("owner", &proof.id, "proof-other")
+            .unwrap_err()
+            .contains("does not match"));
+        store
+            .delete_qualification_application("owner", &proof.id, "proof-1")
+            .unwrap();
+        assert!(store.application_for("owner", &proof.id).is_none());
+    }
+
     #[test]
     fn invitation_acceptance_and_revocation_change_authorization() {
         let store = store("invitation");

package/package.json

@@ -2,7 +2,7 @@
   "name": "create-feltdb",
   "private": false,
   "description": "Create a new FeltDB application with one command",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "license": "MIT",
   "bin": {
     "create-feltdb": "bin/create-feltdb.js"