@feltdb/core 0.8.4 → 0.8.5

package/dist/create/server-source/crates/feltdb/tests/pr34_query_collection.rs

@@ -166,7 +166,8 @@ fn a_scan_result_survives_concurrent_mutation() {
     // The scan returns owned records, so mutation after the lock is released
     // cannot invalidate or rewrite what the caller already holds.
     for index in 0..200 {
-        db.delete(&format!("items:record-{index:05}")).expect("delete");
+        db.delete(&format!("items:record-{index:05}"))
+            .expect("delete");
     }
 
     assert_eq!(matches.len(), 50);

package/dist/create/server-source/crates/feltdb/tests/pr35_equality_index.rs

@@ -41,7 +41,8 @@ fn database() -> (TempDir, FeltDb) {
 /// A database with `status` and `tenantId` indexed on `items`.
 fn indexed() -> (TempDir, FeltDb) {
     let (directory, db) = database();
-    db.create_equality_index("items", "status").expect("declare");
+    db.create_equality_index("items", "status")
+        .expect("declare");
     db.create_equality_index("items", "tenantId")
         .expect("declare");
     (directory, db)
@@ -53,7 +54,9 @@ fn indexed() -> (TempDir, FeltDb) {
 fn assert_index_matches_state(db: &FeltDb, after: &str) {
     match db.verify_equality_index().expect("verify") {
         Ok(()) => {}
-        Err(divergence) => panic!("index diverged from authoritative state after {after}: {divergence}"),
+        Err(divergence) => {
+            panic!("index diverged from authoritative state after {after}: {divergence}")
+        }
     }
 }
 
@@ -67,7 +70,11 @@ fn ids(db: &FeltDb, field: &str, value: Value) -> Vec<String> {
     candidates(db, field, value)
         .expect("the field is indexed and the value is indexable")
         .into_iter()
-        .map(|key| key.split_once(':').map(|(_, id)| id.to_string()).unwrap_or(key))
+        .map(|key| {
+            key.split_once(':')
+                .map(|(_, id)| id.to_string())
+                .unwrap_or(key)
+        })
         .collect()
 }
 
@@ -155,7 +162,11 @@ fn an_update_that_leaves_the_indexed_field_alone_leaves_the_index_alone() {
     db.update("items:a", &json!({ "status": "active", "note": "after" }))
         .expect("update");
 
-    assert_eq!(snapshot(&db), before, "an unrelated field change is invisible to the index");
+    assert_eq!(
+        snapshot(&db),
+        before,
+        "an unrelated field change is invisible to the index"
+    );
     assert_index_matches_state(&db, "an unrelated field changing");
 }
 
@@ -260,7 +271,11 @@ fn unindexable_values_are_excluded_rather_than_coerced() {
     put(&db, "object", json!({ "status": { "state": "active" } }));
     put(&db, "array", json!({ "status": ["active"] }));
     put(&db, "scalar", json!({ "status": "active" }));
-    put(&db, "not-an-object", json!("items are usually objects, but need not be"));
+    put(
+        &db,
+        "not-an-object",
+        json!("items are usually objects, but need not be"),
+    );
 
     assert_eq!(
         ids(&db, "status", json!("active")),
@@ -351,8 +366,16 @@ fn conditional_creation_maintains_the_index_when_it_wins_and_not_when_it_loses()
         key: "items:a".into(),
         value: Some(json!({ "status": "active" })),
     };
-    db.apply_atomic_transaction_guarded("pr35-put-1", None, None, &[], &[absent.clone()], &[write.clone()], None)
-        .expect("the record is absent, so the creation wins");
+    db.apply_atomic_transaction_guarded(
+        "pr35-put-1",
+        None,
+        None,
+        &[],
+        &[absent.clone()],
+        &[write.clone()],
+        None,
+    )
+    .expect("the record is absent, so the creation wins");
     assert_eq!(ids(&db, "status", json!("active")), vec!["a".to_string()]);
     assert_index_matches_state(&db, "a conditional creation that won");
 
@@ -520,14 +543,17 @@ fn declaring_an_index_populates_it_from_state_that_already_exists() {
         None,
         "before declaration there is no index to consult",
     );
-    assert!(db.create_equality_index("items", "status").expect("declare"));
+    assert!(db
+        .create_equality_index("items", "status")
+        .expect("declare"));
     assert_eq!(
         ids(&db, "status", json!("active")),
         vec!["a".to_string()],
         "declaration derives the index from the records already held",
     );
     assert!(
-        !db.create_equality_index("items", "status").expect("declare"),
+        !db.create_equality_index("items", "status")
+            .expect("declare"),
         "re-declaring an existing index reports that it created nothing",
     );
     assert_index_matches_state(&db, "declaring an index over existing state");
@@ -548,8 +574,11 @@ fn an_explicit_rebuild_reproduces_the_maintained_index_exactly() {
         );
     }
     db.delete("items:record-000").expect("delete");
-    db.update("items:record-001", &json!({ "status": "active", "tenantId": "tenant-9" }))
-        .expect("update");
+    db.update(
+        "items:record-001",
+        &json!({ "status": "active", "tenantId": "tenant-9" }),
+    )
+    .expect("update");
 
     let maintained = snapshot(&db);
     db.rebuild_equality_indexes().expect("rebuild");
@@ -567,8 +596,10 @@ fn reopening_the_database_rebuilds_the_index_from_durable_state() {
 
     let before = {
         let db = FeltDb::open(&path).expect("open");
-        db.create_equality_index("items", "status").expect("declare");
-        db.create_equality_index("items", "tenantId").expect("declare");
+        db.create_equality_index("items", "status")
+            .expect("declare");
+        db.create_equality_index("items", "tenantId")
+            .expect("declare");
         for step in 0..48 {
             db.insert(
                 &format!("items:record-{step:03}"),
@@ -577,8 +608,11 @@ fn reopening_the_database_rebuilds_the_index_from_durable_state() {
             .expect("insert");
         }
         db.delete("items:record-005").expect("delete");
-        db.update("items:record-006", &json!({ "status": "active", "tenantId": "tenant-0" }))
-            .expect("update");
+        db.update(
+            "items:record-006",
+            &json!({ "status": "active", "tenantId": "tenant-0" }),
+        )
+        .expect("update");
         db.apply_atomic_transaction_guarded(
             "pr35-restart-tx",
             None,
@@ -587,7 +621,10 @@ fn reopening_the_database_rebuilds_the_index_from_durable_state() {
             &[],
             &[
                 mutation("items:record-007", None),
-                mutation("items:record-100", Some(json!({ "status": "active", "tenantId": "tenant-1" }))),
+                mutation(
+                    "items:record-100",
+                    Some(json!({ "status": "active", "tenantId": "tenant-1" })),
+                ),
             ],
             None,
         )
@@ -600,8 +637,12 @@ fn reopening_the_database_rebuilds_the_index_from_durable_state() {
         reopened.equality_indexes().expect("indexes").is_empty(),
         "an index is derived state: nothing about it is read back from the log",
     );
-    reopened.create_equality_index("items", "status").expect("declare");
-    reopened.create_equality_index("items", "tenantId").expect("declare");
+    reopened
+        .create_equality_index("items", "status")
+        .expect("declare");
+    reopened
+        .create_equality_index("items", "tenantId")
+        .expect("declare");
 
     assert_eq!(
         snapshot(&reopened),
@@ -699,8 +740,11 @@ fn indexed_execution_returns_exactly_what_the_scan_returns() {
 
     // The conjunction actually narrows rather than merely re-filtering: the
     // intersection is smaller than either side.
-    let both = indexed_query(&db, &[("status", json!("active")), ("tenantId", json!("tenant-1"))])
-        .expect("both fields are indexed");
+    let both = indexed_query(
+        &db,
+        &[("status", json!("active")), ("tenantId", json!("tenant-1"))],
+    )
+    .expect("both fields are indexed");
     let one = indexed_query(&db, &[("status", json!("active"))]).expect("indexed");
     assert!(!both.is_empty() && both.len() < one.len());
 }
@@ -718,8 +762,11 @@ fn the_index_selects_candidates_and_the_predicate_still_decides() {
         "the index answers with candidates, both of which satisfy only the indexed condition",
     );
 
-    let result = indexed_query(&db, &[("status", json!("active")), ("role", json!("admin"))])
-        .expect("indexed");
+    let result = indexed_query(
+        &db,
+        &[("status", json!("active")), ("role", json!("admin"))],
+    )
+    .expect("indexed");
     assert_eq!(
         result,
         vec!["items:a".to_string()],
@@ -834,14 +881,19 @@ fn concurrent_mutation_and_indexed_query_stay_coherent() {
         // mean a partially committed transaction became queryable.
         for (sibling, count) in halves {
             if count != 2 {
-                failures.push(format!("transaction pair {sibling} was observed {count} times, not 2"));
+                failures.push(format!(
+                    "transaction pair {sibling} was observed {count} times, not 2"
+                ));
             }
         }
         observations += 1;
     }
 
     running.store(false, Ordering::Relaxed);
-    let cycles: usize = writers.into_iter().map(|handle| handle.join().expect("writer")).sum();
+    let cycles: usize = writers
+        .into_iter()
+        .map(|handle| handle.join().expect("writer"))
+        .sum();
 
     assert!(cycles > 0, "the writers actually mutated the collection");
     assert!(observations > 0, "the reader actually queried");
@@ -881,7 +933,10 @@ fn indexed_and_scan_execution_agree_on_a_concurrently_built_state() {
     for conditions in [
         vec![("status", json!("active"))],
         vec![("tenantId", json!("tenant-3"))],
-        vec![("status", json!("archived")), ("tenantId", json!("tenant-2"))],
+        vec![
+            ("status", json!("archived")),
+            ("tenantId", json!("tenant-2")),
+        ],
     ] {
         assert_eq!(
             indexed_query(&db, &conditions).expect("indexed"),

package/dist/create/server-source/crates/feltdb/tests/pr7_self_authorization_proof.rs

@@ -17,10 +17,8 @@
 
 use feltdb::{
     state_contract::{
-        StateSchema, CollectionSchema, FieldSchema, FieldType, PrimitiveType,
-        FieldConstraints,
-        AuthorizationContext, CanonicalQuery, begin_read, execute_query,
-        QueryFilter,
+        begin_read, execute_query, AuthorizationContext, CanonicalQuery, CollectionSchema,
+        FieldConstraints, FieldSchema, FieldType, PrimitiveType, QueryFilter, StateSchema,
     },
     FeltDb,
 };
@@ -324,8 +322,7 @@ fn pr7_phase3_self_authorization_proof() -> Result<(), Box<dyn std::error::Error
         field_projections: Default::default(),
     };
 
-    let _bob_context = begin_read(&db, &schema, "app", bob_auth)
-        .map_err(|e| format!("{:?}", e))?;
+    let _bob_context = begin_read(&db, &schema, "app", bob_auth).map_err(|e| format!("{:?}", e))?;
 
     // Query as Bob with self(user) policy
     let _query = CanonicalQuery {
@@ -360,8 +357,8 @@ fn pr7_phase3_self_authorization_proof() -> Result<(), Box<dyn std::error::Error
         field_projections: Default::default(),
     };
 
-    let _alice_context = begin_read(&db, &schema, "app", alice_auth)
-        .map_err(|e| format!("{:?}", e))?;
+    let _alice_context =
+        begin_read(&db, &schema, "app", alice_auth).map_err(|e| format!("{:?}", e))?;
 
     println!("  • Alice is member of Org A");
     println!("  • Invitation.organization = {}", org_a_id);

package/dist/create/server-source/crates/feltdb/tests/pr8_vocabulary_assessment.rs

@@ -17,8 +17,7 @@
 
 use feltdb::{
     state_contract::{
-        StateSchema, CollectionSchema, FieldSchema, FieldType, PrimitiveType,
-        FieldConstraints,
+        CollectionSchema, FieldConstraints, FieldSchema, FieldType, PrimitiveType, StateSchema,
     },
     FeltDb,
 };
@@ -150,10 +149,7 @@ fn pr8_resource_inventory_and_pattern_mapping() -> Result<(), Box<dyn std::error
     for primitive in primitives {
         let count = resources
             .iter()
-            .filter(|r| {
-                r.read_policy.contains(primitive)
-                    || r.write_policy.contains(primitive)
-            })
+            .filter(|r| r.read_policy.contains(primitive) || r.write_policy.contains(primitive))
             .count();
         if count > 0 {
             println!("  ✓ {} - Used in {} resources", primitive, count);
@@ -184,37 +180,35 @@ fn pr8_pattern_class_1_personal_identity_scoped() -> Result<(), Box<dyn std::err
         schema_version: 1,
         application_id: "saas-portal".to_string(),
         revision_id: "rev-1".to_string(),
-        collections: vec![
-            CollectionSchema {
-                name: "User".to_string(),
-                version: 1,
-                fields: vec![
-                    FieldSchema {
-                        name: "_id".to_string(),
-                        field_type: FieldType::Primitive {
-                            primitive: PrimitiveType::String,
-                        },
-                        nullable: false,
-                        required: true,
-                        default: None,
-                        constraints: FieldConstraints::default(),
-                        computed: None,
+        collections: vec![CollectionSchema {
+            name: "User".to_string(),
+            version: 1,
+            fields: vec![
+                FieldSchema {
+                    name: "_id".to_string(),
+                    field_type: FieldType::Primitive {
+                        primitive: PrimitiveType::String,
                     },
-                    FieldSchema {
-                        name: "email".to_string(),
-                        field_type: FieldType::Primitive {
-                            primitive: PrimitiveType::String,
-                        },
-                        nullable: false,
-                        required: true,
-                        default: None,
-                        constraints: FieldConstraints::default(),
-                        computed: None,
+                    nullable: false,
+                    required: true,
+                    default: None,
+                    constraints: FieldConstraints::default(),
+                    computed: None,
+                },
+                FieldSchema {
+                    name: "email".to_string(),
+                    field_type: FieldType::Primitive {
+                        primitive: PrimitiveType::String,
                     },
-                ],
-                indexes: vec![],
-            },
-        ],
+                    nullable: false,
+                    required: true,
+                    default: None,
+                    constraints: FieldConstraints::default(),
+                    computed: None,
+                },
+            ],
+            indexes: vec![],
+        }],
     };
 
     // Setup test data
@@ -415,11 +409,17 @@ fn pr8_pattern_class_2_organizational_relational() -> Result<(), Box<dyn std::er
     let org_a_id = "org-a";
     let proj_id = "proj-1";
 
-    db.insert("User#user-alice", json!({ "_id": alice_id, "email": "alice@example.com" }))
-        .map_err(|e| format!("{:?}", e))?;
+    db.insert(
+        "User#user-alice",
+        json!({ "_id": alice_id, "email": "alice@example.com" }),
+    )
+    .map_err(|e| format!("{:?}", e))?;
 
-    db.insert("User#user-bob", json!({ "_id": bob_id, "email": "bob@example.com" }))
-        .map_err(|e| format!("{:?}", e))?;
+    db.insert(
+        "User#user-bob",
+        json!({ "_id": bob_id, "email": "bob@example.com" }),
+    )
+    .map_err(|e| format!("{:?}", e))?;
 
     db.insert(
         "Organization#org-a",
@@ -672,11 +672,17 @@ fn pr8_pattern_class_4_composition_multiple_audiences() -> Result<(), Box<dyn st
     let org_a_id = "org-a";
     let inv_id = "inv-1";
 
-    db.insert("User#user-alice", json!({ "_id": alice_id, "email": "alice@example.com" }))
-        .map_err(|e| format!("{:?}", e))?;
+    db.insert(
+        "User#user-alice",
+        json!({ "_id": alice_id, "email": "alice@example.com" }),
+    )
+    .map_err(|e| format!("{:?}", e))?;
 
-    db.insert("User#user-bob", json!({ "_id": bob_id, "email": "bob@example.com" }))
-        .map_err(|e| format!("{:?}", e))?;
+    db.insert(
+        "User#user-bob",
+        json!({ "_id": bob_id, "email": "bob@example.com" }),
+    )
+    .map_err(|e| format!("{:?}", e))?;
 
     db.insert(
         "Organization#org-a",
@@ -853,7 +859,9 @@ fn pr8_final_conclusion() -> Result<(), Box<dyn std::error::Error>> {
 
     println!("RESULTS\n");
     println!("  Gaps: NONE");
-    println!("  Redundancies: owner (minor - can be expressed as self, but kept for convenience)\n");
+    println!(
+        "  Redundancies: owner (minor - can be expressed as self, but kept for convenience)\n"
+    );
 
     println!("VERDICT: VOCABULARY IS COMPLETE ✓\n");
 

package/dist/create/server-source/crates/feltdb/tests/pr9_phase2_boundary_tests.rs

@@ -22,15 +22,14 @@
 
 use feltdb::{
     state_contract::{
-        StateSchema, CollectionSchema, FieldSchema, FieldType, PrimitiveType,
-        FieldConstraints, AuthorizationContext, begin_read, execute_query,
-        CanonicalQuery, QueryFilter,
+        begin_read, execute_query, AuthorizationContext, CanonicalQuery, CollectionSchema,
+        FieldConstraints, FieldSchema, FieldType, PrimitiveType, QueryFilter, StateSchema,
     },
     FeltDb,
 };
 use serde_json::{json, Value};
-use tempfile::TempDir;
 use std::fmt;
+use tempfile::TempDir;
 
 /// Result of testing an operation at the FeltDB boundary
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -322,19 +321,31 @@ impl TeamBoundaryTestFixture {
         let team_id = "team-backend".to_string();
 
         // Create users
-        db.insert("User#user-owner", json!({ "_id": owner_id, "email": "owner@example.com" }))
-            .map_err(|e| format!("{:?}", e))?;
-        db.insert("User#user-admin", json!({ "_id": admin_id, "email": "admin@example.com" }))
-            .map_err(|e| format!("{:?}", e))?;
-        db.insert("User#user-member", json!({ "_id": member_id, "email": "member@example.com" }))
-            .map_err(|e| format!("{:?}", e))?;
+        db.insert(
+            "User#user-owner",
+            json!({ "_id": owner_id, "email": "owner@example.com" }),
+        )
+        .map_err(|e| format!("{:?}", e))?;
+        db.insert(
+            "User#user-admin",
+            json!({ "_id": admin_id, "email": "admin@example.com" }),
+        )
+        .map_err(|e| format!("{:?}", e))?;
+        db.insert(
+            "User#user-member",
+            json!({ "_id": member_id, "email": "member@example.com" }),
+        )
+        .map_err(|e| format!("{:?}", e))?;
         db.insert(
             "User#user-non-member",
             json!({ "_id": non_member_id, "email": "nonmember@example.com" }),
         )
         .map_err(|e| format!("{:?}", e))?;
-        db.insert("User#user-revoked", json!({ "_id": revoked_id, "email": "revoked@example.com" }))
-            .map_err(|e| format!("{:?}", e))?;
+        db.insert(
+            "User#user-revoked",
+            json!({ "_id": revoked_id, "email": "revoked@example.com" }),
+        )
+        .map_err(|e| format!("{:?}", e))?;
         db.insert(
             "User#user-cross-tenant",
             json!({ "_id": cross_tenant_id, "email": "cross@example.com" }),
@@ -342,10 +353,16 @@ impl TeamBoundaryTestFixture {
         .map_err(|e| format!("{:?}", e))?;
 
         // Create organizations
-        db.insert("Organization#org-main", json!({ "_id": org_id, "name": "Main Org" }))
-            .map_err(|e| format!("{:?}", e))?;
-        db.insert("Organization#org-other", json!({ "_id": cross_org_id, "name": "Other Org" }))
-            .map_err(|e| format!("{:?}", e))?;
+        db.insert(
+            "Organization#org-main",
+            json!({ "_id": org_id, "name": "Main Org" }),
+        )
+        .map_err(|e| format!("{:?}", e))?;
+        db.insert(
+            "Organization#org-other",
+            json!({ "_id": cross_org_id, "name": "Other Org" }),
+        )
+        .map_err(|e| format!("{:?}", e))?;
 
         // Create org memberships (establishes organization access)
         db.insert(

package/dist/create/server-source/crates/feltdb/tests/pr9_phase3a_path_a_tests.rs

@@ -18,8 +18,8 @@
 
 use feltdb::{
     state_contract::{
-        StateSchema, CollectionSchema, FieldSchema, FieldType, PrimitiveType,
-        FieldConstraints, AuthorizationContext,
+        AuthorizationContext, CollectionSchema, FieldConstraints, FieldSchema, FieldType,
+        PrimitiveType, StateSchema,
     },
     FeltDb,
 };
@@ -66,13 +66,28 @@ impl PathATestFixture {
         let team_id = "team-backend".to_string();
 
         // Create users
-        db.insert("User#user-owner", json!({"_id": owner_id, "email": "owner@example.com"}))?;
-        db.insert("User#user-admin", json!({"_id": admin_id, "email": "admin@example.com"}))?;
-        db.insert("User#user-member", json!({"_id": member_id, "email": "member@example.com"}))?;
-        db.insert("User#user-non-member", json!({"_id": non_member_id, "email": "non-member@example.com"}))?;
+        db.insert(
+            "User#user-owner",
+            json!({"_id": owner_id, "email": "owner@example.com"}),
+        )?;
+        db.insert(
+            "User#user-admin",
+            json!({"_id": admin_id, "email": "admin@example.com"}),
+        )?;
+        db.insert(
+            "User#user-member",
+            json!({"_id": member_id, "email": "member@example.com"}),
+        )?;
+        db.insert(
+            "User#user-non-member",
+            json!({"_id": non_member_id, "email": "non-member@example.com"}),
+        )?;
 
         // Create organization
-        db.insert("Organization#org-1", json!({"_id": org_id, "name": "Org 1"}))?;
+        db.insert(
+            "Organization#org-1",
+            json!({"_id": org_id, "name": "Org 1"}),
+        )?;
 
         // Create memberships for all users in the organization
         db.insert(

package/dist/create/server-source/crates/feltdb/tests/pr9_phase3c_authorized_mutations.rs

@@ -3,10 +3,7 @@
 //! Test that the new authorized mutation API properly enforces authorization.
 //! Authorization evaluation happens INSIDE the FeltDB boundary, before mutations are applied.
 
-use feltdb::{
-    state_contract::AuthorizationContext,
-    FeltDb,
-};
+use feltdb::{state_contract::AuthorizationContext, FeltDb};
 use serde_json::json;
 use tempfile::TempDir;
 
@@ -43,7 +40,11 @@ fn authorized_insert_requires_state_write_capability() -> Result<(), Box<dyn std
         json!({"_id": "user-1", "name": "Alice"}),
         &authorized_context,
     );
-    assert!(result.is_ok(), "Authorized insert should succeed: {:?}", result);
+    assert!(
+        result.is_ok(),
+        "Authorized insert should succeed: {:?}",
+        result
+    );
 
     // Verify record was inserted
     let value = db.get::<serde_json::Value>("User#user-1")?;
@@ -63,7 +64,10 @@ fn authorized_insert_requires_state_write_capability() -> Result<(), Box<dyn std
 
     // Verify unauthorized insert did not create record
     let value = db.get::<serde_json::Value>("User#user-2")?;
-    assert!(value.is_none(), "Unauthorized insert should not create record");
+    assert!(
+        value.is_none(),
+        "Unauthorized insert should not create record"
+    );
 
     Ok(())
 }
@@ -123,11 +127,18 @@ fn authorized_delete_requires_state_write_capability() -> Result<(), Box<dyn std
 
     // Authorized delete should succeed
     let result = db.delete_with_authorization("Team#team-1", &authorized_context);
-    assert!(result.is_ok(), "Authorized delete should succeed: {:?}", result);
+    assert!(
+        result.is_ok(),
+        "Authorized delete should succeed: {:?}",
+        result
+    );
 
     // Verify record is deleted
     let value = db.get::<serde_json::Value>("Team#team-1")?;
-    assert!(value.is_none(), "Record should be deleted after authorized delete");
+    assert!(
+        value.is_none(),
+        "Record should be deleted after authorized delete"
+    );
 
     Ok(())
 }
@@ -167,7 +178,13 @@ fn authorized_update_requires_state_write_capability() -> Result<(), Box<dyn std
     )?;
 
     let original = db.get::<serde_json::Value>("Organization#org-1")?;
-    assert_eq!(original.as_ref().and_then(|v| v.get("name")).and_then(|v| v.as_str()), Some("Acme Corp"));
+    assert_eq!(
+        original
+            .as_ref()
+            .and_then(|v| v.get("name"))
+            .and_then(|v| v.as_str()),
+        Some("Acme Corp")
+    );
 
     // Unauthorized update should fail
     let result = db.update_with_authorization(
@@ -184,7 +201,10 @@ fn authorized_update_requires_state_write_capability() -> Result<(), Box<dyn std
     // Verify record was not changed
     let value = db.get::<serde_json::Value>("Organization#org-1")?;
     assert_eq!(
-        value.as_ref().and_then(|v| v.get("name")).and_then(|v| v.as_str()),
+        value
+            .as_ref()
+            .and_then(|v| v.get("name"))
+            .and_then(|v| v.as_str()),
         Some("Acme Corp"),
         "Unauthorized update should not change record"
     );
@@ -195,12 +215,19 @@ fn authorized_update_requires_state_write_capability() -> Result<(), Box<dyn std
         json!({"_id": "org-1", "name": "Acme Inc"}),
         &authorized_context,
     );
-    assert!(result.is_ok(), "Authorized update should succeed: {:?}", result);
+    assert!(
+        result.is_ok(),
+        "Authorized update should succeed: {:?}",
+        result
+    );
 
     // Verify record was updated
     let value = db.get::<serde_json::Value>("Organization#org-1")?;
     assert_eq!(
-        value.as_ref().and_then(|v| v.get("name")).and_then(|v| v.as_str()),
+        value
+            .as_ref()
+            .and_then(|v| v.get("name"))
+            .and_then(|v| v.as_str()),
         Some("Acme Inc"),
         "Authorized update should change record"
     );
@@ -276,16 +303,8 @@ fn atomic_transaction_with_authorization_denies_on_any_mutation_failure(
     };
 
     // Create initial records
-    db.insert_with_authorization(
-        "User#user-1",
-        json!({"_id": "user-1"}),
-        &authorized_context,
-    )?;
-    db.insert_with_authorization(
-        "Team#team-1",
-        json!({"_id": "team-1"}),
-        &authorized_context,
-    )?;
+    db.insert_with_authorization("User#user-1", json!({"_id": "user-1"}), &authorized_context)?;
+    db.insert_with_authorization("Team#team-1", json!({"_id": "team-1"}), &authorized_context)?;
 
     // Attempt atomic transaction with unauthorized context
     // Should be rejected without applying ANY mutations