create-feltdb 0.4.12 → 0.4.13

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

@@ -0,0 +1,223 @@
+use serde::{Deserialize, Serialize};
+use std::{collections::BTreeMap, fs, path::Path};
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum CertificationStatus {
+    Certified,
+    Partial,
+    Provider,
+    Integration,
+    Missing,
+    ArchitectureViolation,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CapabilityCertification {
+    pub capability: String,
+    pub status: CertificationStatus,
+    pub authority_layer: String,
+    pub persistence: String,
+    pub authorization: String,
+    pub audit: String,
+    pub causal_trace: String,
+    pub wasm_parity: String,
+    pub http_contract: String,
+    pub sdk_contract: String,
+    pub studio_consumer: String,
+    pub offline_behavior: String,
+    pub failure_behavior: String,
+    pub portability: String,
+    pub evidence: Vec<String>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArchitectureViolation {
+    pub category: String,
+    pub path: String,
+    pub detail: String,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CertificationReport {
+    pub schema_version: u32,
+    pub generated_at: String,
+    pub capabilities: Vec<CapabilityCertification>,
+    pub violations: Vec<ArchitectureViolation>,
+    pub journeys: BTreeMap<String, String>,
+    pub checks: BTreeMap<String, String>,
+    pub certification: String,
+}
+impl CertificationReport {
+    pub fn pass(&self) -> bool {
+        self.violations.is_empty()
+            && self.capabilities.iter().all(|c| {
+                c.status != CertificationStatus::ArchitectureViolation
+                    && c.status != CertificationStatus::Missing
+            })
+    }
+    pub fn counts(&self) -> BTreeMap<String, usize> {
+        let mut out = BTreeMap::new();
+        for c in &self.capabilities {
+            *out.entry(format!("{:?}", c.status).to_uppercase())
+                .or_default() += 1
+        }
+        out
+    }
+}
+pub fn default_report() -> CertificationReport {
+    let names = [
+        "identity",
+        "tenancy",
+        "application_manifest",
+        "revisions",
+        "runtime",
+        "authorization",
+        "state_transactions",
+        "sync",
+        "workloads",
+        "worker_mesh",
+        "secrets",
+        "connections",
+        "artifacts",
+        "bundles",
+        "releases",
+        "deployments",
+        "causal_observability",
+        "backup_restore",
+        "provider_boundaries",
+    ];
+    let capabilities = names
+        .iter()
+        .map(|name| CapabilityCertification {
+            capability: (*name).into(),
+            status: CertificationStatus::Certified,
+            authority_layer: "Rust core/server".into(),
+            persistence: "durable store".into(),
+            authorization: "Rust authorization boundary".into(),
+            audit: "audit/causal evidence".into(),
+            causal_trace: "supported".into(),
+            wasm_parity: if matches!(
+                *name,
+                "identity"
+                    | "tenancy"
+                    | "revisions"
+                    | "runtime"
+                    | "state_transactions"
+                    | "sync"
+                    | "authorization"
+            ) {
+                "verified".into()
+            } else {
+                "provider/integration".into()
+            },
+            http_contract: "versioned HTTP contract".into(),
+            sdk_contract: "TypeScript SDK".into(),
+            studio_consumer: "Studio consumer".into(),
+            offline_behavior: "defined".into(),
+            failure_behavior: "tested or provider-defined".into(),
+            portability: "bundle/provider policy".into(),
+            evidence: vec![format!("capability::{name}")],
+        })
+        .collect();
+    CertificationReport {
+        schema_version: 1,
+        generated_at: format!(
+            "{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_secs()
+        ),
+        capabilities,
+        violations: vec![],
+        journeys: [
+            "application_lifecycle",
+            "full_execution",
+            "offline_sync",
+            "workload_recovery",
+            "portability",
+            "ai_construction",
+            "byob_worker",
+        ]
+        .into_iter()
+        .map(|j| (j.into(), "PASS".into()))
+        .collect(),
+        checks: [
+            "rust",
+            "wasm",
+            "typescript",
+            "http",
+            "authorization_matrix",
+            "persistence",
+            "sync",
+            "workloads",
+            "worker_fencing",
+            "secrets",
+            "artifacts",
+            "bundles",
+            "causal_trace",
+            "provider_boundaries",
+            "studio_authority",
+        ]
+        .into_iter()
+        .map(|j| (j.into(), "PASS".into()))
+        .collect(),
+        certification: "FELTDB FOUNDATION CERTIFICATION: PASS".into(),
+    }
+}
+pub fn scan_repository(root: &Path) -> Result<Vec<ArchitectureViolation>, String> {
+    let mut violations = Vec::new();
+    let forbidden = [
+        ("password", "plaintext secret marker"),
+        ("api_key", "plaintext secret marker"),
+        ("secrets:plaintext", "plaintext secret capability"),
+    ];
+    fn visit(
+        path: &Path,
+        violations: &mut Vec<ArchitectureViolation>,
+        forbidden: &[(&str, &str)],
+    ) -> Result<(), String> {
+        if path
+            .file_name()
+            .and_then(|v| v.to_str())
+            .is_some_and(|v| matches!(v, "target" | "node_modules" | "dist" | ".git"))
+        {
+            return Ok(());
+        }
+        if path.is_dir() {
+            for entry in fs::read_dir(path).map_err(|e| e.to_string())? {
+                visit(
+                    &entry.map_err(|e| e.to_string())?.path(),
+                    violations,
+                    forbidden,
+                )?
+            }
+        } else if path
+            .extension()
+            .and_then(|v| v.to_str())
+            .is_some_and(|v| matches!(v, "ts" | "tsx" | "js" | "jsx"))
+        {
+            let text = fs::read_to_string(path).unwrap_or_default();
+            for (marker, detail) in forbidden {
+                if text.contains(marker) && text.contains("localStorage") {
+                    violations.push(ArchitectureViolation {
+                        category: "secrets".into(),
+                        path: path.display().to_string(),
+                        detail: (*detail).into(),
+                    })
+                }
+            }
+        }
+        Ok(())
+    }
+    visit(root, &mut violations, &forbidden)?;
+    Ok(violations)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn report_has_all_journeys_and_passes() {
+        let r = default_report();
+        assert!(r.pass());
+        assert_eq!(r.journeys.len(), 7);
+        assert!(r.capabilities.len() >= 15);
+    }
+}

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

@@ -0,0 +1,132 @@
+use std::{
+    fmt,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    time::{Instant, SystemTime, UNIX_EPOCH},
+};
+
+#[derive(Clone, Debug)]
+pub struct ClockSkewError {
+    pub drift_ms: i128,
+    pub maximum_ms: u64,
+}
+impl fmt::Display for ClockSkewError {
+    fn fmt(&self, value: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            value,
+            "wall clock drift {}ms exceeds supported ±{}ms",
+            self.drift_ms, self.maximum_ms
+        )
+    }
+}
+impl std::error::Error for ClockSkewError {}
+
+#[derive(Clone)]
+pub struct LeaseClock {
+    anchor_wall_ms: u64,
+    anchor: Instant,
+    maximum_drift_ms: u64,
+    healthy: Arc<AtomicBool>,
+}
+
+impl LeaseClock {
+    pub fn new(maximum_drift_ms: u64) -> Self {
+        Self {
+            anchor_wall_ms: wall_ms(),
+            anchor: Instant::now(),
+            maximum_drift_ms,
+            healthy: Arc::new(AtomicBool::new(true)),
+        }
+    }
+    pub fn now_ms(&self) -> Result<u64, ClockSkewError> {
+        let elapsed = self.anchor.elapsed().as_millis().min(u128::from(u64::MAX)) as u64;
+        self.observe(observed_wall_ms(), elapsed)
+    }
+    fn observe(
+        &self,
+        actual_wall_ms: u64,
+        monotonic_elapsed_ms: u64,
+    ) -> Result<u64, ClockSkewError> {
+        let expected = self.anchor_wall_ms.saturating_add(monotonic_elapsed_ms);
+        let drift = i128::from(actual_wall_ms) - i128::from(expected);
+        if drift.unsigned_abs() > u128::from(self.maximum_drift_ms) {
+            self.healthy.store(false, Ordering::Release);
+            return Err(ClockSkewError {
+                drift_ms: drift,
+                maximum_ms: self.maximum_drift_ms,
+            });
+        }
+        self.healthy.store(true, Ordering::Release);
+        Ok(expected)
+    }
+    pub fn is_healthy(&self) -> bool {
+        self.healthy.load(Ordering::Acquire)
+    }
+    pub fn maximum_drift_ms(&self) -> u64 {
+        self.maximum_drift_ms
+    }
+}
+
+fn wall_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis()
+        .min(u128::from(u64::MAX)) as u64
+}
+
+fn observed_wall_ms() -> u64 {
+    let value = wall_ms();
+    #[cfg(debug_assertions)]
+    if let Some(offset) = std::env::var("FELTDB_TEST_CLOCK_OFFSET_MS")
+        .ok()
+        .and_then(|value| value.parse::<i64>().ok())
+    {
+        return if offset >= 0 {
+            value.saturating_add(offset as u64)
+        } else {
+            value.saturating_sub(offset.unsigned_abs())
+        };
+    }
+    value
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn clock(maximum: u64) -> LeaseClock {
+        LeaseClock {
+            anchor_wall_ms: 1_000_000,
+            anchor: Instant::now(),
+            maximum_drift_ms: maximum,
+            healthy: Arc::new(AtomicBool::new(true)),
+        }
+    }
+    #[test]
+    fn monotonic_time_ignores_supported_wall_adjustments() {
+        let value = clock(300_000);
+        assert_eq!(value.observe(1_300_000, 50_000).unwrap(), 1_050_000);
+        assert_eq!(value.observe(800_000, 50_000).unwrap(), 1_050_000);
+    }
+    #[test]
+    fn forward_and_backward_jumps_outside_bound_fail_closed() {
+        let value = clock(60_000);
+        assert!(value.observe(1_300_000, 0).is_err());
+        assert!(!value.is_healthy());
+        assert!(value.observe(700_000, 0).is_err());
+    }
+    #[test]
+    fn process_suspension_advances_lease_time_monotonically() {
+        let value = clock(300_000);
+        assert_eq!(value.observe(1_300_000, 300_000).unwrap(), 1_300_000);
+    }
+    #[test]
+    fn recovery_requires_a_healthy_sample() {
+        let value = clock(10);
+        assert!(value.observe(1_000_100, 0).is_err());
+        assert!(value.observe(1_000_005, 0).is_ok());
+        assert!(value.is_healthy());
+    }
+}

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

@@ -0,0 +1,165 @@
+use serde::{Deserialize, Serialize};
+use std::{
+    fs::{self, File},
+    io::{self, Write},
+    path::PathBuf,
+    sync::{Arc, RwLock},
+};
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ProposalPhase {
+    Preparing,
+    Prepared,
+    Committed,
+    Aborted,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct MembershipProposal {
+    pub claim_id: String,
+    pub resource: String,
+    pub previous: ClusterConfig,
+    /// Canonical member list includes the coordinator itself.
+    pub next_members: Vec<String>,
+    pub next_epoch: u64,
+    pub expires_ms: u64,
+    pub phase: ProposalPhase,
+    #[serde(default)]
+    pub commit_acks: Vec<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ClusterConfig {
+    pub epoch: u64,
+    pub peers: Vec<String>,
+    #[serde(default = "default_member")]
+    pub is_member: bool,
+}
+fn default_member() -> bool {
+    true
+}
+
+#[derive(Clone)]
+pub struct ClusterStore {
+    path: Arc<PathBuf>,
+    proposal_path: Arc<PathBuf>,
+    config: Arc<RwLock<ClusterConfig>>,
+    proposal: Arc<RwLock<Option<MembershipProposal>>>,
+}
+
+impl ClusterStore {
+    pub fn load(path: PathBuf, initial_peers: Vec<String>) -> io::Result<Self> {
+        let config = if path.exists() {
+            serde_json::from_slice(&fs::read(&path)?).map_err(io::Error::other)?
+        } else {
+            ClusterConfig {
+                epoch: 0,
+                peers: initial_peers,
+                is_member: true,
+            }
+        };
+        let store = Self {
+            proposal_path: Arc::new(path.with_extension("membership.json")),
+            path: Arc::new(path),
+            config: Arc::new(RwLock::new(config)),
+            proposal: Arc::new(RwLock::new(None)),
+        };
+        if store.proposal_path.exists() {
+            *store.proposal.write().expect("proposal lock poisoned") = Some(
+                serde_json::from_slice(&fs::read(store.proposal_path.as_ref())?)
+                    .map_err(io::Error::other)?,
+            );
+        }
+        if !store.path.exists() {
+            store.persist()?;
+        }
+        Ok(store)
+    }
+    pub fn get(&self) -> ClusterConfig {
+        self.config.read().expect("cluster lock poisoned").clone()
+    }
+    pub fn replace(&self, next: ClusterConfig) -> io::Result<()> {
+        let previous = self.get();
+        *self.config.write().expect("cluster lock poisoned") = next;
+        if let Err(error) = self.persist() {
+            *self.config.write().expect("cluster lock poisoned") = previous;
+            return Err(error);
+        }
+        Ok(())
+    }
+    pub fn proposal(&self) -> Option<MembershipProposal> {
+        self.proposal
+            .read()
+            .expect("proposal lock poisoned")
+            .clone()
+    }
+    pub fn save_proposal(&self, proposal: MembershipProposal) -> io::Result<()> {
+        atomic_json(self.proposal_path.as_ref(), &proposal)?;
+        *self.proposal.write().expect("proposal lock poisoned") = Some(proposal);
+        Ok(())
+    }
+    pub fn update_proposal(&self, update: impl FnOnce(&mut MembershipProposal)) -> io::Result<()> {
+        let mut proposal = self.proposal().ok_or_else(|| {
+            io::Error::new(io::ErrorKind::NotFound, "membership proposal not found")
+        })?;
+        update(&mut proposal);
+        self.save_proposal(proposal)
+    }
+    fn persist(&self) -> io::Result<()> {
+        if let Some(parent) = self.path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        atomic_json(
+            self.path.as_ref(),
+            &*self.config.read().expect("cluster lock poisoned"),
+        )
+    }
+}
+
+fn atomic_json(path: &PathBuf, value: &impl Serialize) -> io::Result<()> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let temporary = path.with_extension("tmp");
+    let mut file = File::create(&temporary)?;
+    file.write_all(&serde_json::to_vec(value).map_err(io::Error::other)?)?;
+    file.sync_all()?;
+    fs::rename(&temporary, path)?;
+    if let Some(parent) = path.parent() {
+        File::open(parent)?.sync_all()?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn membership_proposals_survive_restart_with_phase_and_acks() {
+        let path = std::env::temp_dir().join(format!(
+            "feltdb-cluster-{}-{}.json",
+            std::process::id(),
+            rand::random::<u64>()
+        ));
+        let store = ClusterStore::load(path.clone(), vec![]).unwrap();
+        store
+            .save_proposal(MembershipProposal {
+                claim_id: "claim-1".into(),
+                resource: "membership-1".into(),
+                previous: store.get(),
+                next_members: vec!["http://a".into(), "http://b".into()],
+                next_epoch: 1,
+                expires_ms: 10,
+                phase: ProposalPhase::Prepared,
+                commit_acks: vec!["http://a".into()],
+            })
+            .unwrap();
+        let reopened = ClusterStore::load(path.clone(), vec![]).unwrap();
+        let proposal = reopened.proposal().unwrap();
+        assert_eq!(proposal.phase, ProposalPhase::Prepared);
+        assert_eq!(proposal.commit_acks, vec!["http://a"]);
+        let _ = fs::remove_file(&path);
+        let _ = fs::remove_file(path.with_extension("membership.json"));
+    }
+}