@feltdb/core 0.7.2 → 0.7.4

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

@@ -7,7 +7,6 @@
 /// - DistributedExecutor: Orchestrates consistency semantics
 ///
 /// Invariant: All replicas converge to identical state_hash for same operations
-
 use crate::causal_dependency_barrier::CausalDependencyBarrier;
 use crate::convergence::VectorClock;
 use crate::durable_operation_log::OperationLog;
@@ -136,11 +135,7 @@ impl ReplicaState {
     }
 
     /// Update replica state after transaction
-    pub fn apply_transaction(
-        &mut self,
-        envelope: &TransactionEnvelope,
-        new_state_hash: StateHash,
-    ) {
+    pub fn apply_transaction(&mut self, envelope: &TransactionEnvelope, new_state_hash: StateHash) {
         self.vector_clock.merge(&envelope.vector_clock);
         self.vector_clock.increment(&self.node_id);
         self.state_hash = new_state_hash;
@@ -276,7 +271,10 @@ impl CausalCapacity {
 
     /// A bound small enough to be reached by a test through the real path.
     pub fn new(max_pending_entries: usize, max_pending_bytes: usize) -> Self {
-        Self { max_pending_entries, max_pending_bytes }
+        Self {
+            max_pending_entries,
+            max_pending_bytes,
+        }
     }
 }
 
@@ -393,8 +391,12 @@ impl DistributedTransactionExecutor {
     /// source `next_origin_sequence` is recovered from.
     pub fn origin_sequence_high_water(&self) -> std::collections::BTreeMap<String, u64> {
         let mut marks = std::collections::BTreeMap::new();
-        let Some(ref log) = self.operation_log else { return marks };
-        let Ok(envelopes) = log.load_all() else { return marks };
+        let Some(ref log) = self.operation_log else {
+            return marks;
+        };
+        let Ok(envelopes) = log.load_all() else {
+            return marks;
+        };
         for envelope in envelopes {
             let entry = marks
                 .entry(envelope.envelope_id.originating_node.clone())
@@ -516,7 +518,9 @@ impl DistributedTransactionExecutor {
 
     /// The size local work would contribute, measured before it is executed.
     fn operations_bytes(operations: &[Operation]) -> usize {
-        serde_json::to_string(operations).map(|json| json.len()).unwrap_or(0)
+        serde_json::to_string(operations)
+            .map(|json| json.len())
+            .unwrap_or(0)
     }
 
     /// Execute local work unconditionally.
@@ -582,8 +586,10 @@ impl DistributedTransactionExecutor {
         // Step 6: A locally executed operation is applied, so it advances the
         // frontier exactly as a replicated one does. Own writes are always
         // causally eligible: they are built on the frontier they advance.
-        self.causal_barrier
-            .record_applied(&Self::barrier_key(&envelope.envelope_id), &envelope.vector_clock);
+        self.causal_barrier.record_applied(
+            &Self::barrier_key(&envelope.envelope_id),
+            &envelope.vector_clock,
+        );
 
         Ok(envelope)
     }
@@ -712,7 +718,9 @@ impl DistributedTransactionExecutor {
     /// per-operation constant, so a large envelope consumes its actual byte
     /// count.
     fn envelope_bytes(envelope: &TransactionEnvelope) -> usize {
-        serde_json::to_string(envelope).map(|json| json.len()).unwrap_or(0)
+        serde_json::to_string(envelope)
+            .map(|json| json.len())
+            .unwrap_or(0)
     }
 
     /// Apply one envelope and advance the applied frontier.
@@ -741,8 +749,10 @@ impl DistributedTransactionExecutor {
 
         // The frontier advances here and only here, so it describes what has
         // been successfully applied rather than what was claimed or received.
-        self.causal_barrier
-            .record_applied(&Self::barrier_key(&envelope.envelope_id), &envelope.vector_clock);
+        self.causal_barrier.record_applied(
+            &Self::barrier_key(&envelope.envelope_id),
+            &envelope.vector_clock,
+        );
 
         Ok(state_hash)
     }
@@ -816,16 +826,14 @@ impl DistributedTransactionExecutor {
             return Ok(0);
         }
         let by_key = self.log_by_key()?;
-        let mut keys: Vec<String> = self
-            .deferred
-            .iter()
-            .map(Self::barrier_key)
-            .collect();
+        let mut keys: Vec<String> = self.deferred.iter().map(Self::barrier_key).collect();
         keys.sort();
 
         let mut admitted = 0;
         for key in keys {
-            let Some(envelope) = by_key.get(&key).cloned() else { continue };
+            let Some(envelope) = by_key.get(&key).cloned() else {
+                continue;
+            };
             let dependencies = Self::dependencies_of(&envelope);
             let payload_bytes = Self::envelope_bytes(&envelope);
 
@@ -888,9 +896,7 @@ impl DistributedTransactionExecutor {
             .clocks
             .iter()
             .filter(|(node, required)| frontier.get(node) < **required)
-            .map(|(node, required)| {
-                format!("{}@{} (have {})", node, required, frontier.get(node))
-            })
+            .map(|(node, required)| format!("{}@{} (have {})", node, required, frontier.get(node)))
             .collect();
         missing.sort();
         missing
@@ -1021,11 +1027,7 @@ impl DistributedTransactionExecutor {
             return true;
         }
 
-        let first_hash = self
-            .replicas
-            .values()
-            .next()
-            .map(|r| r.state_hash.clone());
+        let first_hash = self.replicas.values().next().map(|r| r.state_hash.clone());
 
         if let Some(first) = first_hash {
             self.replicas.values().all(|r| r.state_hash == first)
@@ -1122,6 +1124,27 @@ impl DistributedTransactionExecutor {
             );
         }
 
+        // Restore the observable local replica state from the same applied
+        // subset. Recovery previously rebuilt the barrier and canonical data
+        // but left this counter and clock at their constructor values, making
+        // a fully recovered node report that it had applied zero operations.
+        let applied_keys = self.causal_barrier.applied_keys();
+        let operations_applied = envelopes
+            .iter()
+            .filter(|envelope| applied_keys.contains(&Self::barrier_key(&envelope.envelope_id)))
+            .map(|envelope| envelope.operations.len() as u64)
+            .sum();
+        let recovered_clock = self.causal_barrier.get_frontier().clone();
+        let recovered_hash = self
+            .canonical_state()
+            .map(|state| state.hash())
+            .unwrap_or_else(|_| StateHash::from_hex("0".repeat(64)));
+        if let Some(local) = self.replicas.get_mut(&self.local_node_id) {
+            local.vector_clock = recovered_clock;
+            local.operations_applied = operations_applied;
+            local.state_hash = recovered_hash;
+        }
+
         // Identity is recovered from the same log, and this is the half that
         // was missing: the causal frontier was already rebuilt here, so a
         // restarted origin came back knowing its causal position and not its
@@ -1201,7 +1224,10 @@ mod tests {
 
     #[test]
     fn test_replica_state_creation() {
-        let state = ReplicaState::new("node1".to_string(), StateHash::from_hex("hash0".to_string()));
+        let state = ReplicaState::new(
+            "node1".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         assert_eq!(state.node_id, "node1");
         assert_eq!(state.operations_applied, 0);
@@ -1224,7 +1250,10 @@ mod tests {
             StateHash::from_hex("hash0".to_string()),
         );
 
-        executor.register_replica("node2".to_string(), StateHash::from_hex("hash0".to_string()));
+        executor.register_replica(
+            "node2".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         assert!(executor.replicas.contains_key("node2"));
     }
@@ -1247,8 +1276,14 @@ mod tests {
             StateHash::from_hex("hash0".to_string()),
         );
 
-        executor.register_replica("node2".to_string(), StateHash::from_hex("hash0".to_string()));
-        executor.register_replica("node3".to_string(), StateHash::from_hex("hash0".to_string()));
+        executor.register_replica(
+            "node2".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
+        executor.register_replica(
+            "node3".to_string(),
+            StateHash::from_hex("hash0".to_string()),
+        );
 
         assert!(executor.check_convergence());
     }
@@ -1260,7 +1295,10 @@ mod tests {
             StateHash::from_hex("hash0".to_string()),
         );
 
-        executor.register_replica("node2".to_string(), StateHash::from_hex("hash1".to_string()));
+        executor.register_replica(
+            "node2".to_string(),
+            StateHash::from_hex("hash1".to_string()),
+        );
 
         assert!(!executor.check_convergence());
     }

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

@@ -57,6 +57,7 @@ pub mod adversarial_transport;
 pub mod replica_membership;
 pub mod replica_acknowledgements;
 pub mod replication_manager;
+pub mod authority_failover;
 pub mod metrics;
 pub mod query_performance;
 pub mod durable_sync;

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

@@ -137,6 +137,36 @@ impl IdentityStore {
             .identities
             .clone())
     }
+    pub fn sign_up(&self, email: &str, password: &str, display_name: Option<String>) -> Result<(Identity, IdentitySession, String), String> {
+        let normalized = email.trim().to_lowercase();
+        if normalized.is_empty() || password.len() < 8 { return Err("email and a password of at least 8 characters are required".into()); }
+        if self.state.read().map_err(|_| "identity lock poisoned")?.identities.iter().any(|value| value.email.as_deref() == Some(&normalized)) {
+            return Err("identity already exists".into());
+        }
+        let mut identity = self.normalize("password", &normalized, Some(normalized.clone()), display_name, serde_json::json!({}))?;
+        identity.status = IdentityStatus::Active;
+        let mut state = self.state.write().map_err(|_| "identity lock poisoned")?;
+        if let Some(stored) = state.identities.iter_mut().find(|value| value.identity_id == identity.identity_id) { stored.status = IdentityStatus::Active; }
+        state.password_hashes.insert(identity.subject_id.clone(), Self::hash_password(password)?);
+        self.persist(&state)?;
+        drop(state);
+        let (session, token) = self.issue_session(&identity, "password", None, 15 * 60)?;
+        Ok((identity, session, token))
+    }
+    pub fn sign_in(&self, email: &str, password: &str) -> Result<(Identity, IdentitySession, String), String> {
+        let normalized = email.trim().to_lowercase();
+        let state = self.state.read().map_err(|_| "identity lock poisoned")?;
+        let identity = state.identities.iter().find(|value| value.email.as_deref() == Some(&normalized) && value.status == IdentityStatus::Active).cloned().ok_or("invalid credentials")?;
+        let valid = state.password_hashes.get(&identity.subject_id).is_some_and(|hash| Self::verify_password(hash, password));
+        drop(state);
+        if !valid { return Err("invalid credentials".into()); }
+        let (session, token) = self.issue_session(&identity, "password", None, 15 * 60)?;
+        Ok((identity, session, token))
+    }
+    pub fn authenticate_session(&self, token: &str) -> Option<IdentitySession> {
+        let current = now();
+        self.state.read().ok()?.sessions.iter().find(|value| value.refresh_hash.as_deref().is_some_and(|hash| Self::verify_password(hash, token)) && value.status == "active" && value.expires_at > current).cloned()
+    }
     pub fn sessions(&self, subject: &str) -> Result<Vec<IdentitySession>, String> {
         Ok(self
             .state
@@ -154,9 +184,10 @@ impl IdentityStore {
         provider: &str,
         device: Option<String>,
         ttl: u64,
-    ) -> Result<IdentitySession, String> {
+    ) -> Result<(IdentitySession, String), String> {
         let mut s = self.state.write().map_err(|_| "identity lock poisoned")?;
         let t = now();
+        let token = id("session_token");
         let x = IdentitySession {
             session_id: id("session"),
             identity_id: identity.identity_id.clone(),
@@ -168,11 +199,11 @@ impl IdentityStore {
             provider: provider.into(),
             status: "active".into(),
             revocation_reason: None,
-            refresh_hash: Some(id("refresh")),
+            refresh_hash: Some(Self::hash_password(&token)?),
         };
         s.sessions.push(x.clone());
         self.persist(&s)?;
-        Ok(x)
+        Ok((x, token))
     }
     pub fn revoke_session(&self, subject: &str, session: &str, reason: &str) -> Result<(), String> {
         let mut s = self.state.write().map_err(|_| "identity lock poisoned")?;
@@ -247,4 +278,16 @@ mod tests {
         assert!(IdentityStore::verify_password(&h, "correct horse"));
         assert!(!IdentityStore::verify_password(&h, "wrong"));
     }
+    #[test]
+    fn actor_tokens_are_short_lived_hashed_and_revocable() {
+        let p = std::env::temp_dir().join(format!("identity-session-{}.json", id("test")));
+        let store = IdentityStore::load(&p).unwrap();
+        let (identity, session, token) = store.sign_up("actor@example.com", "correct horse", Some("Actor".into())).unwrap();
+        assert!(session.expires_at - session.issued_at <= 15 * 60);
+        assert_ne!(session.refresh_hash.as_deref(), Some(token.as_str()));
+        assert_eq!(store.authenticate_session(&token).unwrap().subject_id, identity.subject_id);
+        store.revoke_session(&identity.subject_id, &session.session_id, "test").unwrap();
+        assert!(store.authenticate_session(&token).is_none());
+        let _ = std::fs::remove_file(p);
+    }
 }