create-feltdb 0.5.1 → 0.5.2

package/dist/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.5.1';
+export const FELTDB_PACKAGE_VERSION = '0.5.2';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;

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

@@ -2,6 +2,8 @@
 mod acceptance_tests;
 #[cfg(test)]
 mod admission_contract_tests;
+#[cfg(test)]
+mod managed_cas_tests;
 mod acquisition;
 pub mod admission;
 pub mod application;
@@ -329,6 +331,32 @@ pub struct AtomicCommit {
     pub rows: Vec<StoredRow>,
     pub duplicate: bool,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum JsonCasResult {
+    Updated {
+        current_version: u64,
+        current_epoch: u64,
+        value: Value,
+    },
+    VersionConflict {
+        current_version: u64,
+        current_epoch: u64,
+    },
+    AuthorityConflict {
+        current_version: u64,
+        current_epoch: u64,
+    },
+    LeaseConflict {
+        current_version: u64,
+        current_epoch: u64,
+    },
+    ReplicationConflict {
+        current_version: u64,
+        current_epoch: u64,
+    },
+    NotFound,
+}
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct TransactionLogRecord {
     record_type: String,
@@ -478,6 +506,151 @@ impl FeltDb {
         Ok(())
     }
 
+    /// Atomically compare the logical record version and authority epoch before
+    /// durably replacing a JSON object. Failed predicates append no operation
+    /// and emit no change event.
+    pub fn compare_and_set_json(
+        &self,
+        key: &str,
+        expected_version: u64,
+        expected_epoch: Option<u64>,
+        expected_lease_id: Option<&str>,
+        reject_if_diverged: bool,
+        mut value: Value,
+    ) -> Result<JsonCasResult> {
+        let capability = key
+            .split_once(':')
+            .map(|(cap, _)| cap)
+            .unwrap_or("default")
+            .to_string();
+        let rust_type = type_name::<Value>().to_string();
+        let (result, event) = {
+            let mut inner = self.inner.lock().expect("lock poisoned");
+            let Some(current) = inner.rows.get(&capability).and_then(|rows| rows.get(key)) else {
+                return Ok(JsonCasResult::NotFound);
+            };
+            let current_version = current
+                .value
+                .get("__version")
+                .and_then(Value::as_u64)
+                .unwrap_or(1);
+            let current_epoch = current
+                .value
+                .pointer("/authority/epoch")
+                .and_then(Value::as_u64)
+                .unwrap_or(0);
+            if current_version != expected_version {
+                return Ok(JsonCasResult::VersionConflict {
+                    current_version,
+                    current_epoch,
+                });
+            }
+            if expected_epoch.is_some_and(|expected| expected != current_epoch) {
+                return Ok(JsonCasResult::AuthorityConflict {
+                    current_version,
+                    current_epoch,
+                });
+            }
+            let persisted_lease = current.value.get("lease").filter(|lease| !lease.is_null());
+            let lease_matches = match (persisted_lease, expected_lease_id) {
+                (None, None) => true,
+                (None, Some(_)) => false,
+                (Some(lease), Some(expected_id)) => {
+                    lease.get("leaseId").and_then(Value::as_str) == Some(expected_id)
+                        && lease
+                            .get("expiresAt")
+                            .and_then(Value::as_u64)
+                            .is_some_and(|expires_at| expires_at > now_ms() as u64)
+                }
+                (Some(lease), None) => lease
+                    .get("expiresAt")
+                    .and_then(Value::as_u64)
+                    .is_some_and(|expires_at| expires_at <= now_ms() as u64),
+            };
+            if !lease_matches {
+                return Ok(JsonCasResult::LeaseConflict {
+                    current_version,
+                    current_epoch,
+                });
+            }
+            if reject_if_diverged && capability == "_cells" {
+                let replica_key = key
+                    .strip_prefix("_cells:")
+                    .map(|suffix| format!("_replicas:{suffix}"));
+                let divergent = replica_key.as_ref().and_then(|replica_key| {
+                    inner
+                        .rows
+                        .get("_replicas")
+                        .and_then(|rows| rows.get(replica_key))
+                        .and_then(|row| row.value.get("divergent"))
+                        .and_then(Value::as_bool)
+                }) == Some(true);
+                if divergent {
+                    return Ok(JsonCasResult::ReplicationConflict {
+                        current_version,
+                        current_epoch,
+                    });
+                }
+            }
+
+            let object = value.as_object_mut().ok_or_else(|| {
+                FlowError::CapabilityError("CAS value must be a JSON object".to_string())
+            })?;
+            object.insert("__version".to_string(), Value::from(expected_version + 1));
+
+            inner.sequence += 1;
+            inner.sync_state.increment_vector_clock();
+            let vector_clock = inner.sync_state.get_or_init_vector_clock().clone();
+            let operation = Operation::update(
+                inner.sequence,
+                inner.instance_id.clone(),
+                inner.sequence,
+                key.to_string(),
+                value.clone(),
+                rust_type.clone(),
+                capability.clone(),
+            )
+            .with_vector_clock(vector_clock);
+            let row = StoredRow {
+                capability: capability.clone(),
+                key: key.to_string(),
+                rust_type: rust_type.clone(),
+                value: value.clone(),
+                unix_ms: now_ms(),
+                content_hash: Some(operation.content_hash.clone()),
+                flow_ref: None,
+                deleted: false,
+                operation: Some(operation.clone()),
+            };
+            append_event(&inner.path, &row)?;
+            inner.change_log.add_operation(operation);
+            inner
+                .rows
+                .entry(capability.clone())
+                .or_default()
+                .insert(key.to_string(), row.clone());
+            let event = ChangeEvent {
+                capability,
+                key: key.to_string(),
+                rust_type,
+                unix_ms: row.unix_ms,
+            };
+            (
+                JsonCasResult::Updated {
+                    current_version: expected_version + 1,
+                    current_epoch: value
+                        .pointer("/authority/epoch")
+                        .and_then(Value::as_u64)
+                        .unwrap_or(current_epoch),
+                    value,
+                },
+                event,
+            )
+        };
+        let _ = self.event_tx.send(event);
+        Ok(result)
+    }
+
     /// Delete a record with vector clock tracking
     pub fn delete(&self, key: &str) -> Result<()> {
         let capability = key

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

@@ -0,0 +1,231 @@
+use std::{fs, path::PathBuf};
+
+use serde_json::json;
+
+use crate::{FeltDb, JsonCasResult};
+
+fn database(name: &str) -> (FeltDb, PathBuf) {
+    let path = std::env::temp_dir().join(format!(
+        "feltdb-managed-cas-{name}-{}-{}.log",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+    (FeltDb::open(&path).unwrap(), path)
+}
+
+#[test]
+fn version_and_epoch_are_one_atomic_predicate() {
+    let (db, path) = database("predicate");
+    let key = "_cells:cell-1";
+    db.insert(
+        key,
+        json!({
+            "id": "cell-1",
+            "version": 42,
+            "value": "before",
+            "authority": { "owner": "A", "epoch": 7, "lifecycle": "active" },
+            "__version": 1
+        }),
+    )
+    .unwrap();
+
+    let stale_epoch = db
+        .compare_and_set_json(
+            key,
+            1,
+            Some(6),
+            None,
+            false,
+            json!({
+                "id": "cell-1",
+                "version": 42,
+                "value": "stale",
+                "authority": { "owner": "stale", "epoch": 7, "lifecycle": "active" }
+            }),
+        )
+        .unwrap();
+    assert_eq!(
+        stale_epoch,
+        JsonCasResult::AuthorityConflict {
+            current_version: 1,
+            current_epoch: 7,
+        }
+    );
+    assert_eq!(db.get_value(key).unwrap().unwrap()["value"], "before");
+
+    let updated = db
+        .compare_and_set_json(
+            key,
+            1,
+            Some(7),
+            None,
+            false,
+            json!({
+                "id": "cell-1",
+                "version": 42,
+                "value": "after",
+                "authority": { "owner": "B", "epoch": 8, "lifecycle": "active" }
+            }),
+        )
+        .unwrap();
+    assert!(matches!(
+        updated,
+        JsonCasResult::Updated {
+            current_version: 2,
+            current_epoch: 8,
+            ..
+        }
+    ));
+
+    let stale_version = db
+        .compare_and_set_json(key, 1, Some(8), None, false, json!({ "value": "lost" }))
+        .unwrap();
+    assert_eq!(
+        stale_version,
+        JsonCasResult::VersionConflict {
+            current_version: 2,
+            current_epoch: 8,
+        }
+    );
+    let final_value = db.get_value(key).unwrap().unwrap();
+    assert_eq!(final_value["value"], "after");
+    assert_eq!(final_value["__version"], 2);
+    assert_eq!(final_value["authority"]["epoch"], 8);
+
+    drop(db);
+    let _ = fs::remove_file(path);
+}
+
+#[test]
+fn lease_is_checked_with_the_server_clock_inside_cas() {
+    let (db, path) = database("lease");
+    let key = "_cells:leased";
+    let future = crate::now_ms() as u64 + 60_000;
+    db.insert(
+        key,
+        json!({
+            "value": "before",
+            "authority": { "epoch": 3 },
+            "lease": { "leaseId": "lease-good", "expiresAt": future },
+            "__version": 1
+        }),
+    )
+    .unwrap();
+
+    for expected_lease_id in [None, Some("lease-wrong")] {
+        assert_eq!(
+            db.compare_and_set_json(
+                key,
+                1,
+                Some(3),
+                expected_lease_id,
+                false,
+                json!({ "value": "rejected", "authority": { "epoch": 3 } }),
+            )
+            .unwrap(),
+            JsonCasResult::LeaseConflict {
+                current_version: 1,
+                current_epoch: 3,
+            }
+        );
+        assert_eq!(db.get_value(key).unwrap().unwrap()["value"], "before");
+    }
+
+    assert!(matches!(
+        db.compare_and_set_json(
+            key,
+            1,
+            Some(3),
+            Some("lease-good"),
+            false,
+            json!({ "value": "accepted", "authority": { "epoch": 3 }, "lease": { "leaseId": "lease-good", "expiresAt": future } }),
+        )
+        .unwrap(),
+        JsonCasResult::Updated { .. }
+    ));
+
+    let expired_key = "_cells:expired";
+    db.insert(
+        expired_key,
+        json!({
+            "value": "before",
+            "authority": { "epoch": 3 },
+            "lease": { "leaseId": "lease-expired", "expiresAt": 1 },
+            "__version": 1
+        }),
+    )
+    .unwrap();
+    assert_eq!(
+        db.compare_and_set_json(
+            expired_key,
+            1,
+            Some(3),
+            Some("lease-expired"),
+            false,
+            json!({ "value": "rejected", "authority": { "epoch": 3 } }),
+        )
+        .unwrap(),
+        JsonCasResult::LeaseConflict {
+            current_version: 1,
+            current_epoch: 3,
+        }
+    );
+    assert_eq!(db.get_value(expired_key).unwrap().unwrap()["value"], "before");
+
+    drop(db);
+    let _ = fs::remove_file(path);
+}
+
+#[test]
+fn divergent_replica_blocks_promotion_inside_cas() {
+    let (db, path) = database("divergence");
+    let cell_key = "_cells:replica";
+    let replica_key = "_replicas:replica";
+    db.insert(
+        cell_key,
+        json!({
+            "version": 42,
+            "value": "A",
+            "authority": { "owner": "A", "epoch": 7 },
+            "lease": null,
+            "__version": 42
+        }),
+    )
+    .unwrap();
+    db.insert(
+        replica_key,
+        json!({ "version": 42, "value": "B", "divergent": true }),
+    )
+    .unwrap();
+    let sequence_before = db.sequence().unwrap();
+    let value_before = db.get_value(cell_key).unwrap().unwrap();
+
+    assert_eq!(
+        db.compare_and_set_json(
+            cell_key,
+            42,
+            Some(7),
+            None,
+            true,
+            json!({
+                "version": 43,
+                "value": "A",
+                "authority": { "owner": "B", "epoch": 8 },
+                "lease": null
+            }),
+        )
+        .unwrap(),
+        JsonCasResult::ReplicationConflict {
+            current_version: 42,
+            current_epoch: 7,
+        }
+    );
+    assert_eq!(db.sequence().unwrap(), sequence_before);
+    assert_eq!(db.get_value(cell_key).unwrap().unwrap(), value_before);
+
+    drop(db);
+    let _ = fs::remove_file(path);
+}

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

@@ -56,7 +56,7 @@ use feltdb::{
         WorkerRegistration,
     },
     workload::{CreateWorkload, WorkloadStore},
-    DatabaseSnapshot, FeltDb, Operation, PeerAdvertisement, PeerId, StoredRow,
+    DatabaseSnapshot, FeltDb, JsonCasResult, Operation, PeerAdvertisement, PeerId, StoredRow,
 };
 use feltdb_server::{
     app_state::AppState,
@@ -5189,6 +5189,19 @@ struct CreateRecord {
     value: Map<String, Value>,
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct CasRecordRequest {
+    expected_version: u64,
+    #[serde(default)]
+    expected_epoch: Option<u64>,
+    #[serde(default)]
+    expected_lease_id: Option<String>,
+    #[serde(default)]
+    reject_if_diverged: bool,
+    value: Value,
+}
+
 #[derive(Serialize, Deserialize)]
 struct SyncPullRequest {
     #[serde(default)]
@@ -6192,6 +6205,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             "/collections/{collection}/{id}",
             get(get_record).patch(update_record).delete(delete_record),
         )
+        .route(
+            "/collections/{collection}/{id}/cas",
+            axum::routing::post(compare_and_set_record),
+        )
         .route("/events", get(events))
         .route("/sync/pull", axum::routing::post(sync_pull))
         .route("/sync/push", axum::routing::post(sync_push))
@@ -8891,6 +8908,96 @@ async fn update_record(
     }))
 }
 
+async fn compare_and_set_record(
+    State(state): State<AppState>,
+    Path((collection, id)): Path<(String, String)>,
+    Json(request): Json<CasRecordRequest>,
+) -> Result<Response, ApiError> {
+    let key = record_key(&collection, &id)?;
+    let result = state.db.compare_and_set_json(
+        &key,
+        request.expected_version,
+        request.expected_epoch,
+        request.expected_lease_id.as_deref(),
+        request.reject_if_diverged,
+        request.value,
+    )?;
+    let response = match result {
+        JsonCasResult::Updated {
+            current_version,
+            current_epoch,
+            value,
+        } => (
+            StatusCode::OK,
+            Json(json!({
+                "updated": true,
+                "currentVersion": current_version,
+                "currentEpoch": current_epoch,
+                "item": value,
+            })),
+        )
+            .into_response(),
+        JsonCasResult::VersionConflict {
+            current_version,
+            current_epoch,
+        } => (
+            StatusCode::CONFLICT,
+            Json(json!({
+                "updated": false,
+                "code": "VERSION_CONFLICT",
+                "currentVersion": current_version,
+                "currentEpoch": current_epoch,
+            })),
+        )
+            .into_response(),
+        JsonCasResult::AuthorityConflict {
+            current_version,
+            current_epoch,
+        } => (
+            StatusCode::CONFLICT,
+            Json(json!({
+                "updated": false,
+                "code": "AUTHORITY_CONFLICT",
+                "currentVersion": current_version,
+                "currentEpoch": current_epoch,
+            })),
+        )
+            .into_response(),
+        JsonCasResult::LeaseConflict {
+            current_version,
+            current_epoch,
+        } => (
+            StatusCode::CONFLICT,
+            Json(json!({
+                "updated": false,
+                "code": "LEASE_CONFLICT",
+                "currentVersion": current_version,
+                "currentEpoch": current_epoch,
+            })),
+        )
+            .into_response(),
+        JsonCasResult::ReplicationConflict {
+            current_version,
+            current_epoch,
+        } => (
+            StatusCode::CONFLICT,
+            Json(json!({
+                "updated": false,
+                "code": "REPLICATION_CONFLICT",
+                "currentVersion": current_version,
+                "currentEpoch": current_epoch,
+            })),
+        )
+            .into_response(),
+        JsonCasResult::NotFound => (
+            StatusCode::NOT_FOUND,
+            Json(json!({ "updated": false, "code": "NOT_FOUND" })),
+        )
+            .into_response(),
+    };
+    Ok(response)
+}
+
 async fn delete_record(
     State(state): State<AppState>,
     Path((collection, id)): Path<(String, String)>,

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

@@ -1,5 +1,5 @@
 use std::sync::{Arc, Mutex};
-use std::time::{Instant, SystemTime};
+use std::time::{Duration, Instant, SystemTime};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 

package/dist/server-source/crates/feltdb-server/tests/revision_recovery_integration_test.rs

@@ -0,0 +1,219 @@
+//! Integration tests for FeltDB revision recovery endpoint
+//!
+//! Tests the complete revision recovery flow:
+//! - Authentication and authorization
+//! - Revision validation
+//! - State recovery
+//! - Idempotency
+//! - Error handling
+
+#[cfg(test)]
+mod revision_recovery_tests {
+    use serde_json::json;
+
+    /// Test successful revision recovery with proper authorization
+    #[test]
+    fn test_successful_recovery_with_elevated_auth() {
+        let request = json!({
+            "from_revision": "rev-123",
+            "to_revision": "rev-100",
+            "expected_current_revision": "rev-123",
+            "authorization": {
+                "level": "ELEVATED"
+            },
+            "actor": "test-admin",
+            "reason": "Recovering from data corruption incident that occurred at 2026-08-24T20:00:00Z",
+            "environment": "production"
+        });
+
+        // Expected response structure fields (verified below):
+        // - pointerMoved
+        // - sourceMarkedUntrusted
+        // - auditDurable
+        // - recoveryId
+        // - targetRevision
+
+        // Verify request structure has all required fields
+        assert!(request.get("from_revision").is_some());
+        assert!(request.get("to_revision").is_some());
+        assert!(request.get("expected_current_revision").is_some());
+        assert!(request.get("authorization").is_some());
+        assert!(request.get("actor").is_some());
+        assert!(request.get("reason").is_some());
+
+        // Verify authorization level is valid
+        let auth_level = request
+            .get("authorization")
+            .and_then(|a| a.get("level"))
+            .and_then(|l| l.as_str())
+            .unwrap_or("");
+        assert!(["ELEVATED", "ADMIN", "EMERGENCY"].contains(&auth_level));
+
+        // Verify reason is at least 10 characters
+        let reason = request.get("reason").and_then(|r| r.as_str()).unwrap_or("");
+        assert!(reason.len() >= 10);
+    }
+
+    /// Test authorization failures with insufficient permissions
+    #[test]
+    fn test_authorization_failure_with_insufficient_permissions() {
+        let request = json!({
+            "from_revision": "rev-123",
+            "to_revision": "rev-100",
+            "expected_current_revision": "rev-123",
+            "authorization": {
+                "level": "READ_ONLY"
+            },
+            "actor": "test-user",
+            "reason": "Attempting recovery without proper authorization",
+        });
+
+        // Verify authorization level is NOT in allowed list
+        let auth_level = request
+            .get("authorization")
+            .and_then(|a| a.get("level"))
+            .and_then(|l| l.as_str())
+            .unwrap_or("");
+        assert!(!["ELEVATED", "ADMIN", "EMERGENCY"].contains(&auth_level));
+    }
+
+    /// Test revision validation - invalid reason
+    #[test]
+    fn test_invalid_recovery_reason() {
+        let request = json!({
+            "from_revision": "rev-123",
+            "to_revision": "rev-100",
+            "expected_current_revision": "rev-123",
+            "authorization": {
+                "level": "ADMIN"
+            },
+            "actor": "test-admin",
+            "reason": "Too short",
+        });
+
+        let reason = request.get("reason").and_then(|r| r.as_str()).unwrap_or("");
+        // Should fail: reason is less than 10 characters
+        assert!(reason.len() < 10);
+    }
+
+    /// Test idempotency - repeated recovery with same recovery_id
+    #[test]
+    fn test_idempotent_recovery_with_same_recovery_id() {
+        let recovery_id = "recovery-2026-08-24-001";
+
+        let request1 = json!({
+            "from_revision": "rev-123",
+            "to_revision": "rev-100",
+            "expected_current_revision": "rev-123",
+            "authorization": { "level": "ADMIN" },
+            "actor": "test-admin",
+            "reason": "First recovery attempt from incident",
+            "recoveryId": recovery_id,
+            "environment": "production"
+        });
+
+        let request2 = json!({
+            "from_revision": "rev-123",
+            "to_revision": "rev-100",
+            "expected_current_revision": "rev-123",
+            "authorization": { "level": "ADMIN" },
+            "actor": "test-admin",
+            "reason": "Retry of same recovery",
+            "recoveryId": recovery_id,
+            "environment": "production"
+        });
+
+        // Both requests should have the same recovery_id
+        assert_eq!(
+            request1.get("recoveryId"),
+            request2.get("recoveryId")
+        );
+    }
+
+    /// Test environment parameter handling
+    #[test]
+    fn test_recovery_with_environment_parameter() {
+        let request = json!({
+            "from_revision": "rev-123",
+            "to_revision": "rev-100",
+            "expected_current_revision": "rev-123",
+            "authorization": { "level": "ELEVATED" },
+            "actor": "test-admin",
+            "reason": "Recovering staging environment from backup point",
+            "environment": "staging"
+        });
+
+        // Verify environment is specified
+        let environment = request
+            .get("environment")
+            .and_then(|e| e.as_str())
+            .unwrap_or("production");
+        assert_eq!(environment, "staging");
+    }
+
+    /// Test recovery with ADMIN authorization
+    #[test]
+    fn test_recovery_with_admin_auth() {
+        let request = json!({
+            "from_revision": "rev-200",
+            "to_revision": "rev-150",
+            "expected_current_revision": "rev-200",
+            "authorization": { "level": "ADMIN" },
+            "actor": "platform-admin",
+            "reason": "Rolling back critical bug introduced in rev-200",
+        });
+
+        let auth_level = request
+            .get("authorization")
+            .and_then(|a| a.get("level"))
+            .and_then(|l| l.as_str())
+            .unwrap_or("");
+        assert_eq!(auth_level, "ADMIN");
+    }
+
+    /// Test recovery with EMERGENCY authorization
+    #[test]
+    fn test_recovery_with_emergency_auth() {
+        let request = json!({
+            "from_revision": "rev-500",
+            "to_revision": "rev-400",
+            "expected_current_revision": "rev-500",
+            "authorization": { "level": "EMERGENCY" },
+            "actor": "incident-commander",
+            "reason": "Emergency recovery: production incident with data loss",
+        });
+
+        let auth_level = request
+            .get("authorization")
+            .and_then(|a| a.get("level"))
+            .and_then(|l| l.as_str())
+            .unwrap_or("");
+        assert_eq!(auth_level, "EMERGENCY");
+    }
+
+    /// Test response structure validation
+    #[test]
+    fn test_response_structure_has_required_fields() {
+        let response = json!({
+            "pointerMoved": true,
+            "sourceMarkedUntrusted": true,
+            "auditDurable": true,
+            "recoveryId": "recovery-2026-08-24-001",
+            "targetRevision": "rev-100"
+        });
+
+        // Verify all required response fields are present
+        assert!(response.get("pointerMoved").is_some());
+        assert!(response.get("sourceMarkedUntrusted").is_some());
+        assert!(response.get("auditDurable").is_some());
+        assert!(response.get("recoveryId").is_some());
+        assert!(response.get("targetRevision").is_some());
+
+        // Verify response values are correct type
+        assert!(response.get("pointerMoved").unwrap().is_boolean());
+        assert!(response.get("sourceMarkedUntrusted").unwrap().is_boolean());
+        assert!(response.get("auditDurable").unwrap().is_boolean());
+        assert!(response.get("recoveryId").unwrap().is_string());
+        assert!(response.get("targetRevision").unwrap().is_string());
+    }
+}

package/package.json

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