@reventlessdev/reventless-core 3.0.0-alpha.259 → 3.0.0-alpha.261

package/tests/plugin/PluginStructureTest.res.mjs

@@ -1555,6 +1555,12 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
     globalThis.test("@sensitive reaches an event variant's payload, not only state", () => {
       globalThis.expect(Sensitive$Reventless.variantFieldNames(PsAnnotatedView$ReventlessCore.consumedEventSchema, "ItemRecorded")).toEqual(["contact"]);
     });
+    globalThis.test("@default flows through the PPX to JSON Schema's `default`", () => {
+      globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "quantity"), s => getProperty(s, "default"))).toEqual(1);
+    });
+    globalThis.test("@default leaves the field's own shape alone", () => {
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "quantity"), s => getProperty(s, "type")), Stdlib_JSON.Decode.string)).toBe("integer");
+    });
     globalThis.test("@metric flows through the PPX to x-reventless-metric {aggregate,label}", () => {
       let metricObj = Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "total"), s => getProperty(s, "x-reventless-metric"));
       globalThis.expect([

package/tests/plugin/Plugin_EventQuerySchemaTest.res

@@ -52,13 +52,13 @@ describe("Plugin_EventQuerySchema.generate", () => {
       ),
     )
     expect(sdl->String.includes("type EventMeta {"))->toBe(true)
-    ["user", "time", "service", "msgId", "correlationId", "causationId"]->Array.forEach(f =>
-      expect(sdl->String.includes(f))->toBe(true)
+    ["user", "time", "service", "msgId", "correlationId", "causationId"]->Array.forEach(
+      f => expect(sdl->String.includes(f))->toBe(true),
     )
     // Transport / tracing detail and the cross-cutting context bag must not
     // leave the server — see the module comment.
-    ["ip:", "traceparent", "schemaVersion", "headers"]->Array.forEach(f =>
-      expect(sdl->String.includes(f))->toBe(false)
+    ["ip:", "traceparent", "schemaVersion", "headers"]->Array.forEach(
+      f => expect(sdl->String.includes(f))->toBe(false),
     )
   })
 
@@ -70,9 +70,14 @@ describe("Plugin_EventQuerySchema.generate", () => {
       ),
     )
     expect(sdl->String.includes("type Ordering_OrderEventRecord {"))->toBe(true)
-    ["position: String!", "eventType: String!", "payload: AWSJSON!", "tags: [EventTag!]!", "meta: EventMeta!", "recordedAt: String!"]->Array.forEach(
-      f => expect(sdl->String.includes(f))->toBe(true),
-    )
+    [
+      "position: String!",
+      "eventType: String!",
+      "payload: AWSJSON!",
+      "tags: [EventTag!]!",
+      "meta: EventMeta!",
+      "recordedAt: String!",
+    ]->Array.forEach(f => expect(sdl->String.includes(f))->toBe(true))
   })
 
   testSync("filter offers the entity shortcut and the precise tag pair", () => {
@@ -83,9 +88,15 @@ describe("Plugin_EventQuerySchema.generate", () => {
       ),
     )
     expect(sdl->String.includes("input Ordering_OrderEventHistoryFilter {"))->toBe(true)
-    ["entityId: ID", "tagKey: String", "tagValue: String", "eventTypes: [String!]", "user: String", "timeFrom: String", "timeTo: String"]->Array.forEach(
-      f => expect(sdl->String.includes(f))->toBe(true),
-    )
+    [
+      "entityId: ID",
+      "tagKey: String",
+      "tagValue: String",
+      "eventTypes: [String!]",
+      "user: String",
+      "timeFrom: String",
+      "timeTo: String",
+    ]->Array.forEach(f => expect(sdl->String.includes(f))->toBe(true))
   })
 
   testSync("a plugin with no event logs emits nothing at all", () => {

package/tests/plugin/SchemaWalkerTest.res

@@ -1,6 +1,5 @@
 open JestGlobals
 
-
 @schema
 type simpleRecord = {
   label: string,
@@ -21,28 +20,41 @@ describe("SchemaWalker:", () => {
     testSync("kind is record", () => expect(result.kind)->toBe("record"))
     testSync("constructors is absent", () => expect(result.constructors)->toEqual(None))
 
-    testSync("fields are sorted alphabetically", () => {
-      let names = result.fields->Array.map(f => f.name)
-      expect(names)->toEqual(["count", "label", "rating"])
-    })
+    testSync(
+      "fields are sorted alphabetically",
+      () => {
+        let names = result.fields->Array.map(f => f.name)
+        expect(names)->toEqual(["count", "label", "rating"])
+      },
+    )
 
-    testSync("required string field", () => {
-      let f = result.fields->Array.getUnsafe(1)
-      expect((f.typeDescription, f.isRequired))->toEqual(("string", true))
-    })
+    testSync(
+      "required string field",
+      () => {
+        let f = result.fields->Array.getUnsafe(1)
+        expect((f.typeDescription, f.isRequired))->toEqual(("string", true))
+      },
+    )
 
-    testSync("required int field typeDescription is number", () => {
-      let f = result.fields->Array.getUnsafe(0)
-      expect((f.typeDescription, f.isRequired))->toEqual(("number", true))
-    })
+    testSync(
+      "required int field typeDescription is number",
+      () => {
+        let f = result.fields->Array.getUnsafe(0)
+        expect((f.typeDescription, f.isRequired))->toEqual(("number", true))
+      },
+    )
 
-    testSync("optional float field", () => {
-      let f = result.fields->Array.getUnsafe(2)
-      expect((f.typeDescription, f.isRequired))->toEqual(("option<number>", false))
-    })
+    testSync(
+      "optional float field",
+      () => {
+        let f = result.fields->Array.getUnsafe(2)
+        expect((f.typeDescription, f.isRequired))->toEqual(("option<number>", false))
+      },
+    )
 
-    testSync("structuralHash is non-empty", () =>
-      expect(result.structuralHash->String.length > 0)->toBe(true)
+    testSync(
+      "structuralHash is non-empty",
+      () => expect(result.structuralHash->String.length > 0)->toBe(true),
     )
   })
 
@@ -52,63 +64,97 @@ describe("SchemaWalker:", () => {
     testSync("kind is variant", () => expect(result.kind)->toBe("variant"))
     testSync("fields array is empty", () => expect(result.fields)->toEqual([]))
 
-    testSync("payload-less constructor Removed is excluded", () => {
-      let ctors = result.constructors->Option.getOr([])
-      let names = ctors->Array.map(c => c.name)->Array.toSorted(String.compare)
-      expect(names)->toEqual(["Added", "Renamed"])
-    })
-
-    testSync("Added constructor has sorted fields", () => {
-      let ctors = result.constructors->Option.getOr([])
-      let added = ctors->Array.find(c => c.name == "Added")->Option.getOr({Plugin_BuiltHook.name: "", fields: []})
-      expect(added.fields->Array.map(f => f.name))->toEqual(["id", "name"])
-    })
-
-    testSync("Renamed constructor has sorted fields", () => {
-      let ctors = result.constructors->Option.getOr([])
-      let renamed = ctors->Array.find(c => c.name == "Renamed")->Option.getOr({Plugin_BuiltHook.name: "", fields: []})
-      expect(renamed.fields->Array.map(f => f.name))->toEqual(["id", "newName"])
-    })
-
-    testSync("structuralHash is non-empty", () =>
-      expect(result.structuralHash->String.length > 0)->toBe(true)
+    testSync(
+      "payload-less constructor Removed is excluded",
+      () => {
+        let ctors = result.constructors->Option.getOr([])
+        let names = ctors->Array.map(c => c.name)->Array.toSorted(String.compare)
+        expect(names)->toEqual(["Added", "Renamed"])
+      },
+    )
+
+    testSync(
+      "Added constructor has sorted fields",
+      () => {
+        let ctors = result.constructors->Option.getOr([])
+        let added =
+          ctors
+          ->Array.find(c => c.name == "Added")
+          ->Option.getOr({Plugin_BuiltHook.name: "", fields: []})
+        expect(added.fields->Array.map(f => f.name))->toEqual(["id", "name"])
+      },
+    )
+
+    testSync(
+      "Renamed constructor has sorted fields",
+      () => {
+        let ctors = result.constructors->Option.getOr([])
+        let renamed =
+          ctors
+          ->Array.find(c => c.name == "Renamed")
+          ->Option.getOr({Plugin_BuiltHook.name: "", fields: []})
+        expect(renamed.fields->Array.map(f => f.name))->toEqual(["id", "newName"])
+      },
+    )
+
+    testSync(
+      "structuralHash is non-empty",
+      () => expect(result.structuralHash->String.length > 0)->toBe(true),
     )
   })
 
   describe("hash properties", () => {
-    testSync("same schema produces identical hash on repeated calls", () => {
-      let h1 = SchemaWalker.walk("X", simpleRecordSchema).structuralHash
-      let h2 = SchemaWalker.walk("X", simpleRecordSchema).structuralHash
-      expect(h1)->toBe(h2)
-    })
-
-    testSync("typeName does not affect structuralHash", () => {
-      let h1 = SchemaWalker.walk("TypeA", simpleRecordSchema).structuralHash
-      let h2 = SchemaWalker.walk("TypeB", simpleRecordSchema).structuralHash
-      expect(h1)->toBe(h2)
-    })
-
-    testSync("structurally distinct schemas produce different hashes", () => {
-      let h1 = SchemaWalker.walk("R", simpleRecordSchema).structuralHash
-      let h2 = SchemaWalker.walk("V", simpleVariantSchema).structuralHash
-      expect(h1 == h2)->toBe(false)
-    })
+    testSync(
+      "same schema produces identical hash on repeated calls",
+      () => {
+        let h1 = SchemaWalker.walk("X", simpleRecordSchema).structuralHash
+        let h2 = SchemaWalker.walk("X", simpleRecordSchema).structuralHash
+        expect(h1)->toBe(h2)
+      },
+    )
+
+    testSync(
+      "typeName does not affect structuralHash",
+      () => {
+        let h1 = SchemaWalker.walk("TypeA", simpleRecordSchema).structuralHash
+        let h2 = SchemaWalker.walk("TypeB", simpleRecordSchema).structuralHash
+        expect(h1)->toBe(h2)
+      },
+    )
+
+    testSync(
+      "structurally distinct schemas produce different hashes",
+      () => {
+        let h1 = SchemaWalker.walk("R", simpleRecordSchema).structuralHash
+        let h2 = SchemaWalker.walk("V", simpleVariantSchema).structuralHash
+        expect(h1 == h2)->toBe(false)
+      },
+    )
   })
 
   describe("scalar / unsupported schema", () => {
-    testSync("plain string schema → kind unknown", () => {
-      let result = SchemaWalker.walk("Scalar", S.string)
-      expect(result.kind)->toBe("unknown")
-    })
-
-    testSync("plain string schema → empty fields", () => {
-      let result = SchemaWalker.walk("Scalar", S.string)
-      expect(result.fields)->toEqual([])
-    })
-
-    testSync("plain string schema → empty structuralHash", () => {
-      let result = SchemaWalker.walk("Scalar", S.string)
-      expect(result.structuralHash)->toBe("")
-    })
+    testSync(
+      "plain string schema → kind unknown",
+      () => {
+        let result = SchemaWalker.walk("Scalar", S.string)
+        expect(result.kind)->toBe("unknown")
+      },
+    )
+
+    testSync(
+      "plain string schema → empty fields",
+      () => {
+        let result = SchemaWalker.walk("Scalar", S.string)
+        expect(result.fields)->toEqual([])
+      },
+    )
+
+    testSync(
+      "plain string schema → empty structuralHash",
+      () => {
+        let result = SchemaWalker.walk("Scalar", S.string)
+        expect(result.structuralHash)->toBe("")
+      },
+    )
   })
 })

package/tests/plugin/StateChange/PsReserveStock.res

@@ -49,9 +49,9 @@ type error = OutOfStock
 
 @schema
 type event =
-  StockReserved({
-    @partitionTag reservationId: string,
-    @ref("AvailableProducts") productIds: array<string>,
-  })
+  | StockReserved({
+      @partitionTag reservationId: string,
+      @ref("AvailableProducts") productIds: array<string>,
+    })
 
 let decide = (_state, _command): result<array<event>, error> => Ok([])

package/tests/plugin/StateView/PsAnnotatedView.res

@@ -16,10 +16,10 @@ type consumedEvent =
       // On the event, not just the state: a renderer composes from an event
       // payload, so this is the case the marker has to reach.
       @sensitive contact: string,
+      @default(1) quantity: int,
     })
 
-@live(false)
-@schema
+@live(false) @schema
 type state = {
   @id itemId: string,
   @subId version: string,
@@ -27,10 +27,12 @@ type state = {
   name: string,
   @semantic("currency") @metric({aggregate: "sum", label: "Revenue"}) total: float,
   @sensitive contact: string,
+  @default(1) quantity: int,
 }
 
 let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
   switch event {
-  | ItemRecorded({itemId, ownerId, version, name, total, contact}) =>
-    [Set(itemId, {itemId, ownerId, version, name, total, contact})]
+  | ItemRecorded({itemId, ownerId, version, name, total, contact, quantity}) => [
+      Set(itemId, {itemId, ownerId, version, name, total, contact, quantity}),
+    ]
   }

package/tests/plugin/StateView/PsAnnotatedView.res.mjs

@@ -4,6 +4,7 @@ import * as Sury from "sury";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
 import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
+import * as FieldDefault$Reventless from "@reventlessdev/reventless-spec/src/components/FieldDefault.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 
 let consumedEventSchema = Sury.$schema(s => ({
@@ -13,7 +14,8 @@ let consumedEventSchema = Sury.$schema(s => ({
   version: s.m(Sury.string),
   name: s.m(Sury.string),
   total: s.m(Sury.float),
-  contact: s.m(Sensitive$Reventless.string)
+  contact: s.m(Sensitive$Reventless.string),
+  quantity: s.m(FieldDefault$Reventless.int(Sury.int, 1))
 }));
 
 let stateSchema = Sury.$schema(s => ({
@@ -22,7 +24,8 @@ let stateSchema = Sury.$schema(s => ({
   ownerId: s.m(Sury.string),
   name: s.m(Sury.string),
   total: s.m(Sury.float),
-  contact: s.m(Sensitive$Reventless.string)
+  contact: s.m(Sensitive$Reventless.string),
+  quantity: s.m(FieldDefault$Reventless.int(Sury.int, 1))
 }));
 
 function project(param) {
@@ -37,7 +40,8 @@ function project(param) {
         ownerId: event.ownerId,
         name: event.name,
         total: event.total,
-        contact: event.contact
+        contact: event.contact,
+        quantity: event.quantity
       }
     }];
 }

package/tests/plugin/StateView/PsCustomersView.res

@@ -5,8 +5,7 @@
 @@reventless.spec("Customers")
 
 @schema
-type consumedEvent =
-  | CustomerAdded({customerId: string, firstName: string, lastName: string})
+type consumedEvent = CustomerAdded({customerId: string, firstName: string, lastName: string})
 
 @schema
 type state = {
@@ -17,6 +16,7 @@ type state = {
 
 let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
   switch event {
-  | CustomerAdded({customerId, firstName, lastName}) =>
-    [Set(customerId, {customerId, firstName, lastName})]
+  | CustomerAdded({customerId, firstName, lastName}) => [
+      Set(customerId, {customerId, firstName, lastName}),
+    ]
   }

package/tests/plugin/StateView/PsShipmentsView.res

@@ -21,6 +21,7 @@ type state = {shipmentId: string, @lifecycle shipmentStatus: shipmentStatus}
 let project = ({event}: Reventless.StateViewSlice.consumed<consumedEvent>) =>
   switch event {
   | ShipmentBooked({shipmentId}) => [Set(shipmentId, {shipmentId, shipmentStatus: Booked})]
-  | ShipmentDispatched({shipmentId}) =>
-    [Update(shipmentId, s => {...s, shipmentStatus: Dispatched})]
+  | ShipmentDispatched({shipmentId}) => [
+      Update(shipmentId, s => {...s, shipmentStatus: Dispatched}),
+    ]
   }

package/tests/projection/LifecycleTrailTest.res

@@ -87,10 +87,7 @@ describe("the lifecycle trail:", () => {
   // Derived from the log and the envelope's own time, so the same events in the
   // same order produce the same trail however often they are replayed.
   testSync("a rebuild from the same events produces an identical trail", () => {
-    let events = [
-      (nine, Set("o1", placed)),
-      (ten, Update("o1", s => {...s, lifecycle: Shipped})),
-    ]
+    let events = [(nine, Set("o1", placed)), (ten, Update("o1", s => {...s, lifecycle: Shipped}))]
     expect(run(events)->statesOf)->toEqual(run(events)->statesOf)
   })
 

package/tests/projection/ProjectionOptimizeTest.res

@@ -14,25 +14,29 @@ describe("Projection.optimizeActions", () => {
     let optimized = Projection.optimizeActions([Delete("a"), Update("a", x => x + 1), Set("a", 99)])
     // Was 3 (with a duplicated Update("a")) before the fix.
     expect(optimized->Array.length)->toBe(2)
-    let sets =
-      optimized->Array.filterMap(a =>
+    let sets = optimized->Array.filterMap(
+      a =>
         switch a {
         | Set(id, s) => Some((id, s))
         | _ => None
-        }
-      )
+        },
+    )
     expect(sets)->toEqual([("a", 99)])
   })
 
   testSync("merges a same-id Create+Update chain into a single Create", () => {
-    let optimized = Projection.optimizeActions([Create("a", 0), Update("a", x => x + 1), Update("a", x => x + 10)])
-    let creates =
-      optimized->Array.filterMap(a =>
+    let optimized = Projection.optimizeActions([
+      Create("a", 0),
+      Update("a", x => x + 1),
+      Update("a", x => x + 10),
+    ])
+    let creates = optimized->Array.filterMap(
+      a =>
         switch a {
         | Create(id, s) => Some((id, s))
         | _ => None
-        }
-      )
+        },
+    )
     expect(creates)->toEqual([("a", 11)])
   })
 })

package/tests/querydb/QueryDbFixtures.res

@@ -1,4 +1,3 @@
-
 // ─────────────────────────────────────────────────────────────
 // Test state spec
 // ─────────────────────────────────────────────────────────────

package/tests/querydb/QueryDbOperationsTest.res

@@ -12,83 +12,118 @@ let _ = beforeEach(() => reset())
 
 describe("QueryDb_Operations:", () => {
   describe("loadStream", () => {
-    testPromise("returns empty stream for unknown id", async () => {
-      let result = await Ops.loadStream("unknown-id")->Stream.runCollect->Effect.runPromise
-      expect(result)->toEqual([])
-    })
+    testPromise(
+      "returns empty stream for unknown id",
+      async () => {
+        let result = await Ops.loadStream("unknown-id")->Stream.runCollect->Effect.runPromise
+        expect(result)->toEqual([])
+      },
+    )
 
-    testPromise("decodes saved state back to typed state", async () => {
-      let state: ItemQueryDbSpec.state = {name: "Widget", count: 5}
-      let _ = await Ops.save("item-1", state, Init, None)
-      let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
-      switch result {
-      | [s] => expect((s.name, s.count))->toEqual(("Widget", 5))
-      | _ => expect("unexpected result")->toEqual("Ok([state])")
-      }
-    })
+    testPromise(
+      "decodes saved state back to typed state",
+      async () => {
+        let state: ItemQueryDbSpec.state = {name: "Widget", count: 5}
+        let _ = await Ops.save("item-1", state, Init, None)
+        let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
+        switch result {
+        | [s] => expect((s.name, s.count))->toEqual(("Widget", 5))
+        | _ => expect("unexpected result")->toEqual("Ok([state])")
+        }
+      },
+    )
 
-    testPromise("returns updated state after overwrite", async () => {
-      let _ = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
-      let _ = await Ops.save("item-1", {name: "Widget Updated", count: 2}, Overwrite, None)
-      let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
-      switch result {
-      | [s] => expect(s.name)->toBe("Widget Updated")
-      | _ => expect("unexpected result")->toEqual("Ok([state])")
-      }
-    })
+    testPromise(
+      "returns updated state after overwrite",
+      async () => {
+        let _ = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
+        let _ = await Ops.save("item-1", {name: "Widget Updated", count: 2}, Overwrite, None)
+        let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
+        switch result {
+        | [s] => expect(s.name)->toBe("Widget Updated")
+        | _ => expect("unexpected result")->toEqual("Ok([state])")
+        }
+      },
+    )
   })
 
   describe("save", () => {
-    testPromise("returns Ok on success", async () => {
-      let result = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
-      expect(Result.isOk(result))->toBe(true)
-    })
+    testPromise(
+      "returns Ok on success",
+      async () => {
+        let result = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
+        expect(Result.isOk(result))->toBe(true)
+      },
+    )
 
-    testPromise("stores id field in JSON", async () => {
-      let _ = await Ops.save("item-42", {name: "Widget", count: 0}, Init, None)
-      let stored = store.contents->Dict.get("item-42")->Option.getOr([])
-      expect(stored->Array.length)->toBe(1)
-      let json = stored->Array.getUnsafe(0)
-      let idField =
-        json
-        ->JSON.Decode.object
-        ->Option.flatMap(d => d->Dict.get("id"))
-        ->Option.flatMap(j => switch j { | JSON.String(s) => Some(s) | _ => None })
-      expect(idField)->toEqual(Some("item-42"))
-    })
+    testPromise(
+      "stores id field in JSON",
+      async () => {
+        let _ = await Ops.save("item-42", {name: "Widget", count: 0}, Init, None)
+        let stored = store.contents->Dict.get("item-42")->Option.getOr([])
+        expect(stored->Array.length)->toBe(1)
+        let json = stored->Array.getUnsafe(0)
+        let idField =
+          json
+          ->JSON.Decode.object
+          ->Option.flatMap(d => d->Dict.get("id"))
+          ->Option.flatMap(
+            j =>
+              switch j {
+              | JSON.String(s) => Some(s)
+              | _ => None
+              },
+          )
+        expect(idField)->toEqual(Some("item-42"))
+      },
+    )
 
-    testPromise("returns Error when storage fails", async () => {
-      failNextWrite := true
-      let result = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
-      expect(Result.isError(result))->toBe(true)
-    })
+    testPromise(
+      "returns Error when storage fails",
+      async () => {
+        failNextWrite := true
+        let result = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
+        expect(Result.isError(result))->toBe(true)
+      },
+    )
   })
 
   describe("saveBatch", () => {
-    testPromise("saves multiple states", async () => {
-      let batch = [
-        ("item-1", ({name: "A", count: 1}: ItemQueryDbSpec.state), None),
-        ("item-2", ({name: "B", count: 2}: ItemQueryDbSpec.state), None),
-      ]
-      let _ = await Ops.saveBatch(batch)
-      let r1 = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
-      let r2 = await Ops.loadStream("item-2")->Stream.runCollect->Effect.runPromise
-      expect((r1->Array.length > 0, r2->Array.length > 0))->toEqual((true, true))
-    })
+    testPromise(
+      "saves multiple states",
+      async () => {
+        let batch = [
+          ("item-1", ({name: "A", count: 1}: ItemQueryDbSpec.state), None),
+          ("item-2", ({name: "B", count: 2}: ItemQueryDbSpec.state), None),
+        ]
+        let _ = await Ops.saveBatch(batch)
+        let r1 = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
+        let r2 = await Ops.loadStream("item-2")->Stream.runCollect->Effect.runPromise
+        expect((r1->Array.length > 0, r2->Array.length > 0))->toEqual((true, true))
+      },
+    )
 
-    testPromise("returns Error when storage fails", async () => {
-      failNextWrite := true
-      let result = await Ops.saveBatch([("item-1", ({name: "A", count: 1}: ItemQueryDbSpec.state), None)])
-      expect(Result.isError(result))->toBe(true)
-    })
+    testPromise(
+      "returns Error when storage fails",
+      async () => {
+        failNextWrite := true
+        let result = await Ops.saveBatch([
+          ("item-1", ({name: "A", count: 1}: ItemQueryDbSpec.state), None),
+        ])
+        expect(Result.isError(result))->toBe(true)
+      },
+    )
   })
 
   describe("delete", () => {
-    testPromise("removes state from storage", async () => {
-      let _ = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
-      let _ = await Ops.delete("item-1", None)
-      let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
-      expect(result)->toEqual([])
-    })
+    testPromise(
+      "removes state from storage",
+      async () => {
+        let _ = await Ops.save("item-1", {name: "Widget", count: 1}, Init, None)
+        let _ = await Ops.delete("item-1", None)
+        let result = await Ops.loadStream("item-1")->Stream.runCollect->Effect.runPromise
+        expect(result)->toEqual([])
+      },
+    )
   })
 })