@reventlessdev/reventless-local 3.0.0-alpha.249 → 3.0.0-alpha.251

package/tests/adapter/QueryDbResolvedFieldsTest.res

@@ -66,14 +66,20 @@ let plainCtx = ctxFor(~groups=["User"])
 let noArgs: JSON.t = JSON.Encode.object(Dict.make())
 
 let getString = (json: JSON.t, key: string): option<string> =>
-  json->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.string)
+  json
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get(key))
+  ->Option.flatMap(JSON.Decode.string)
 
 let names = (json: JSON.t): array<string> =>
   json->JSON.Decode.array->Option.getOr([])->Array.filterMap(item => item->getString("name"))
 
 // One Bus carrying both views, resolvers registered for the Orders view with the
 // two configs the PPX writes from `@resolves` / `@resolvesMany`.
-let buildFixture = async (~suffix: string, ~retired: option<Reventless.StateAnnotations.retiredSpec>) => {
+let buildFixture = async (
+  ~suffix: string,
+  ~retired: option<Reventless.StateAnnotations.retiredSpec>,
+) => {
   module Bus = LocalBus.Make()
   module Storage = LocalQueryDbStorage.Make(Bus)
   module Resolvers = QueryDbResolvers_GraphQL.Make(Bus)
@@ -144,10 +150,7 @@ let buildFixture = async (~suffix: string, ~retired: option<Reventless.StateAnno
   ReventlessCore.Plugin_Helpers.stateSchemaRegistry->Dict.set(
     productsName,
     productRowSchema
-    ->S.Metadata.set(
-      ~id=Reventless.StateAnnotations.stateAnnotationsId,
-      annotations(~retired),
-    )
+    ->S.Metadata.set(~id=Reventless.StateAnnotations.stateAnnotationsId, annotations(~retired))
     ->S.castToUnknown,
   )
 
@@ -169,7 +172,12 @@ let buildFixture = async (~suffix: string, ~retired: option<Reventless.StateAnno
     ~opts=({}: Pulumi.CustomResourceOptions.t),
   )
 
-  let _ = await productOps.save("p-1", {productId: "p-1", name: "Book", archived: false}, Init, None)
+  let _ = await productOps.save(
+    "p-1",
+    {productId: "p-1", name: "Book", archived: false},
+    Init,
+    None,
+  )
   let _ = await productOps.save("p-2", {productId: "p-2", name: "Pen", archived: true}, Init, None)
   let _ = await orderOps.save(
     "o-1",
@@ -188,10 +196,7 @@ let buildFixture = async (~suffix: string, ~retired: option<Reventless.StateAnno
     Dict.fromArray([
       ("orderId", JSON.Encode.string("o-1")),
       ("productId", JSON.Encode.string("p-1")),
-      (
-        "productIds",
-        ["p-1", "gone", "p-2"]->Array.map(JSON.Encode.string)->JSON.Encode.array,
-      ),
+      ("productIds", ["p-1", "gone", "p-2"]->Array.map(JSON.Encode.string)->JSON.Encode.array),
     ]),
   )
 
@@ -222,9 +227,7 @@ describe("QueryDb cross-table field resolvers", () => {
 
   testPromise("a foreign key naming no row resolves to nothing", async () => {
     let (resolverFor, _) = await buildFixture(~suffix="C", ~retired=None)
-    let orphan = JSON.Encode.object(
-      Dict.fromArray([("productId", JSON.Encode.string("nope"))]),
-    )
+    let orphan = JSON.Encode.object(Dict.fromArray([("productId", JSON.Encode.string("nope"))]))
     let product = await resolverFor("product")(orphan, noArgs, plainCtx)
     expect(product)->toBe(JSON.Encode.null)
   })

package/tests/adapter/QueryDbStorageSqliteTest.res

@@ -18,18 +18,12 @@ describe("QueryDbStorage_Sqlite", () => {
     let s = Storage.make(~name="rm1", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
     let ops = await s.operations->TestRunner.resolve
 
-    let _ = await ops.save(
-      "id1",
-      JSON.Encode.string("value1"),
-      ReventlessCore.QueryDb.Any,
-      None,
-    )
-
-    let items =
-      await ops.loadStream("id1")
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
+    let _ = await ops.save("id1", JSON.Encode.string("value1"), ReventlessCore.QueryDb.Any, None)
+
+    let items = await ops.loadStream("id1")
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
 
     expect(items->Array.length)->toBe(1)
     expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("value1"))
@@ -48,11 +42,10 @@ describe("QueryDbStorage_Sqlite", () => {
     let _ = await ops.save("k", JSON.Encode.string("a"), ReventlessCore.QueryDb.Any, None)
     let _ = await ops.save("k", JSON.Encode.string("b"), ReventlessCore.QueryDb.Any, None)
 
-    let items =
-      await ops.loadStream("k")
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
+    let items = await ops.loadStream("k")
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
 
     expect(items->Array.length)->toBe(1)
     expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("b"))
@@ -74,21 +67,18 @@ describe("QueryDbStorage_Sqlite", () => {
       ("id3", JSON.Encode.string("three"), None),
     ])
 
-    let items1 =
-      await ops.loadStream("id1")
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
-    let items2 =
-      await ops.loadStream("id2")
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
-    let items3 =
-      await ops.loadStream("id3")
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
+    let items1 = await ops.loadStream("id1")
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
+    let items2 = await ops.loadStream("id2")
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
+    let items3 = await ops.loadStream("id3")
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
 
     expect(items1->Array.length)->toBe(1)
     expect(items2->Array.length)->toBe(1)
@@ -108,11 +98,10 @@ describe("QueryDbStorage_Sqlite", () => {
     let _ = await ops.save("k", JSON.Encode.string("a"), ReventlessCore.QueryDb.Any, None)
     let _ = await ops.delete("k", None)
 
-    let items =
-      await ops.loadStream("k")
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
+    let items = await ops.loadStream("k")
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
 
     expect(items->Array.length)->toBe(0)
   })
@@ -120,8 +109,9 @@ describe("QueryDbStorage_Sqlite", () => {
   testPromise("items persist across a file reopen", async () => {
     let path = `/tmp/reventless-test-qdb-${Float.toString(Date.now())}.db`
 
-    // Session 1: write
     {
+      // Session 1: write
+
       module TestBus = LocalBus.Make()
       module DbProvider = {
         let db = SqliteDriver.openDb(~path)
@@ -129,12 +119,7 @@ describe("QueryDbStorage_Sqlite", () => {
       module Storage = QueryDbStorage_Sqlite.Make(TestBus, DbProvider)
       let s = Storage.make(~name="persist", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
       let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.save(
-        "k",
-        JSON.Encode.string("hello"),
-        ReventlessCore.QueryDb.Any,
-        None,
-      )
+      let _ = await ops.save("k", JSON.Encode.string("hello"), ReventlessCore.QueryDb.Any, None)
       DbProvider.db->SqliteDriver.close
     }
 
@@ -146,11 +131,10 @@ describe("QueryDbStorage_Sqlite", () => {
     module Storage2 = QueryDbStorage_Sqlite.Make(TestBus2, DbProvider2)
     let s2 = Storage2.make(~name="persist", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
     let ops2 = await s2.operations->TestRunner.resolve
-    let items =
-      await ops2.loadStream("k")
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
+    let items = await ops2.loadStream("k")
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
 
     expect(items->Array.length)->toBe(1)
     expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("hello"))

package/tests/adapter/QueryDbStorageTest.res

@@ -9,163 +9,209 @@ let opts: Pulumi.CustomResourceOptions.t = {}
 
 describe("QueryDbStorage_InMemory", () => {
   describe("save and load", () => {
-    testPromise("save stores state; loadStream retrieves it by id", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="rm1", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.save("id1", JSON.Encode.string("value1"), ReventlessCore.QueryDb.Any, None)
-      let items =
-        await ops.loadStream("id1")
+    testPromise(
+      "save stores state; loadStream retrieves it by id",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(~name="rm1", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+        let ops = await s.operations->TestRunner.resolve
+        let _ = await ops.save(
+          "id1",
+          JSON.Encode.string("value1"),
+          ReventlessCore.QueryDb.Any,
+          None,
+        )
+        let items = await ops.loadStream("id1")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      expect(items->Array.length)->toBe(1)
-      expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("value1"))
-    })
+        expect(items->Array.length)->toBe(1)
+        expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("value1"))
+      },
+    )
 
-    testPromise("loadStream returns empty for unknown id", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="rm2", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let items =
-        await ops.loadStream("unknown")
+    testPromise(
+      "loadStream returns empty for unknown id",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(~name="rm2", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+        let ops = await s.operations->TestRunner.resolve
+        let items = await ops.loadStream("unknown")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      expect(items->Array.length)->toBe(0)
-    })
+        expect(items->Array.length)->toBe(0)
+      },
+    )
 
-    testPromise("save overwrites previous state for same id", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="rm3", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.save("id1", JSON.Encode.string("old"), ReventlessCore.QueryDb.Any, None)
-      let _ = await ops.save("id1", JSON.Encode.string("new"), ReventlessCore.QueryDb.Any, None)
-      let items =
-        await ops.loadStream("id1")
+    testPromise(
+      "save overwrites previous state for same id",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(~name="rm3", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+        let ops = await s.operations->TestRunner.resolve
+        let _ = await ops.save("id1", JSON.Encode.string("old"), ReventlessCore.QueryDb.Any, None)
+        let _ = await ops.save("id1", JSON.Encode.string("new"), ReventlessCore.QueryDb.Any, None)
+        let items = await ops.loadStream("id1")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      expect(items->Array.length)->toBe(1)
-      expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("new"))
-    })
+        expect(items->Array.length)->toBe(1)
+        expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("new"))
+      },
+    )
 
-    testPromise("load delegates to loadStream (backward-compat)", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="load-compat", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.save("compat-id", JSON.Encode.string("compat-val"), ReventlessCore.QueryDb.Any, None)
-      let streamed = await ops.loadStream("compat-id")->Stream.runCollect->Effect.runPromise
-      let loaded = await ops.load("compat-id")
-      expect(loaded)->toEqual(Ok(streamed))
-    })
+    testPromise(
+      "load delegates to loadStream (backward-compat)",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(
+          ~name="load-compat",
+          ~indexes=[],
+          ~api=(),
+          ~apiRole=(),
+          ~owner=None,
+          ~opts,
+        )
+        let ops = await s.operations->TestRunner.resolve
+        let _ = await ops.save(
+          "compat-id",
+          JSON.Encode.string("compat-val"),
+          ReventlessCore.QueryDb.Any,
+          None,
+        )
+        let streamed = await ops.loadStream("compat-id")->Stream.runCollect->Effect.runPromise
+        let loaded = await ops.load("compat-id")
+        expect(loaded)->toEqual(Ok(streamed))
+      },
+    )
   })
 
   describe("saveBatch", () => {
-    testPromise("stores multiple items; loadStream retrieves each by id", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="rm4", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.saveBatch([
-        ("a", JSON.Encode.string("val-a"), None),
-        ("b", JSON.Encode.string("val-b"), None),
-      ])
-      let itemsA =
-        await ops.loadStream("a")
+    testPromise(
+      "stores multiple items; loadStream retrieves each by id",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(~name="rm4", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+        let ops = await s.operations->TestRunner.resolve
+        let _ = await ops.saveBatch([
+          ("a", JSON.Encode.string("val-a"), None),
+          ("b", JSON.Encode.string("val-b"), None),
+        ])
+        let itemsA = await ops.loadStream("a")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      let itemsB =
-        await ops.loadStream("b")
+        let itemsB = await ops.loadStream("b")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      expect(itemsA->Array.getUnsafe(0))->toEqual(JSON.Encode.string("val-a"))
-      expect(itemsB->Array.getUnsafe(0))->toEqual(JSON.Encode.string("val-b"))
-    })
+        expect(itemsA->Array.getUnsafe(0))->toEqual(JSON.Encode.string("val-a"))
+        expect(itemsB->Array.getUnsafe(0))->toEqual(JSON.Encode.string("val-b"))
+      },
+    )
   })
 
   describe("count", () => {
-    testPromise("returns the increment value (no real counting semantics)", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="rm5", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let result = await ops.count("id1", "field", 5)
-      expect(result)->toEqual(Ok(5))
-    })
+    testPromise(
+      "returns the increment value (no real counting semantics)",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(~name="rm5", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+        let ops = await s.operations->TestRunner.resolve
+        let result = await ops.count("id1", "field", 5)
+        expect(result)->toEqual(Ok(5))
+      },
+    )
   })
 
   describe("delete", () => {
-    testPromise("removes item; loadStream returns empty", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="rm6", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.save("del-id", JSON.Encode.string("v"), ReventlessCore.QueryDb.Any, None)
-      let _ = await ops.delete("del-id", None)
-      let items =
-        await ops.loadStream("del-id")
+    testPromise(
+      "removes item; loadStream returns empty",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(~name="rm6", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+        let ops = await s.operations->TestRunner.resolve
+        let _ = await ops.save("del-id", JSON.Encode.string("v"), ReventlessCore.QueryDb.Any, None)
+        let _ = await ops.delete("del-id", None)
+        let items = await ops.loadStream("del-id")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      expect(items->Array.length)->toBe(0)
-    })
+        expect(items->Array.length)->toBe(0)
+      },
+    )
 
-    testPromise("deleteBatch removes multiple items", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="rm7", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.saveBatch([
-        ("x", JSON.Encode.string("vx"), None),
-        ("y", JSON.Encode.string("vy"), None),
-      ])
-      let _ = await ops.deleteBatch([("x", None), ("y", None)])
-      let rx =
-        await ops.loadStream("x")
+    testPromise(
+      "deleteBatch removes multiple items",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(~name="rm7", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+        let ops = await s.operations->TestRunner.resolve
+        let _ = await ops.saveBatch([
+          ("x", JSON.Encode.string("vx"), None),
+          ("y", JSON.Encode.string("vy"), None),
+        ])
+        let _ = await ops.deleteBatch([("x", None), ("y", None)])
+        let rx = await ops.loadStream("x")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      let ry =
-        await ops.loadStream("y")
+        let ry = await ops.loadStream("y")
         ->Stream.runCollect
         ->Effect.catchAll(_ => Effect.succeed([]))
         ->Effect.runPromise
-      expect(rx->Array.length)->toBe(0)
-      expect(ry->Array.length)->toBe(0)
-    })
+        expect(rx->Array.length)->toBe(0)
+        expect(ry->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("scan registration", () => {
-    testPromise("after save, scan function returns all stored items", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="scan-rm", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.save("s1", JSON.Encode.string("item1"), ReventlessCore.QueryDb.Any, None)
-      let _ = await ops.save("s2", JSON.Encode.string("item2"), ReventlessCore.QueryDb.Any, None)
-      let scanFn = TestBus.getQueryDbScan("scan-rm")->Option.getOr(() => [])
-      let all = scanFn()
-      expect(all->Array.length)->toBe(2)
-    })
+    testPromise(
+      "after save, scan function returns all stored items",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(~name="scan-rm", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
+        let ops = await s.operations->TestRunner.resolve
+        let _ = await ops.save("s1", JSON.Encode.string("item1"), ReventlessCore.QueryDb.Any, None)
+        let _ = await ops.save("s2", JSON.Encode.string("item2"), ReventlessCore.QueryDb.Any, None)
+        let scanFn = TestBus.getQueryDbScan("scan-rm")->Option.getOr(() => [])
+        let all = scanFn()
+        expect(all->Array.length)->toBe(2)
+      },
+    )
 
-    testPromise("after delete, scan function excludes deleted item", async () => {
-      module TestBus = LocalBus.Make()
-      module Storage = LocalQueryDbStorage.Make(TestBus)
-      let s = Storage.make(~name="scan-rm2", ~indexes=[], ~api=(), ~apiRole=(), ~owner=None, ~opts)
-      let ops = await s.operations->TestRunner.resolve
-      let _ = await ops.save("keep", JSON.Encode.string("keep"), ReventlessCore.QueryDb.Any, None)
-      let _ = await ops.save("gone", JSON.Encode.string("gone"), ReventlessCore.QueryDb.Any, None)
-      let _ = await ops.delete("gone", None)
-      let scanFn = TestBus.getQueryDbScan("scan-rm2")->Option.getOr(() => [])
-      let all = scanFn()
-      expect(all->Array.length)->toBe(1)
-    })
+    testPromise(
+      "after delete, scan function excludes deleted item",
+      async () => {
+        module TestBus = LocalBus.Make()
+        module Storage = LocalQueryDbStorage.Make(TestBus)
+        let s = Storage.make(
+          ~name="scan-rm2",
+          ~indexes=[],
+          ~api=(),
+          ~apiRole=(),
+          ~owner=None,
+          ~opts,
+        )
+        let ops = await s.operations->TestRunner.resolve
+        let _ = await ops.save("keep", JSON.Encode.string("keep"), ReventlessCore.QueryDb.Any, None)
+        let _ = await ops.save("gone", JSON.Encode.string("gone"), ReventlessCore.QueryDb.Any, None)
+        let _ = await ops.delete("gone", None)
+        let scanFn = TestBus.getQueryDbScan("scan-rm2")->Option.getOr(() => [])
+        let all = scanFn()
+        expect(all->Array.length)->toBe(1)
+      },
+    )
   })
 })

package/tests/adapter/QueryDbUnionRoundTripTest.res

@@ -76,11 +76,10 @@ describe("QueryDb round-trips a union field", () => {
     )
 
     // The stored row, as any read door would hand it back.
-    let stored =
-      await jsonOps.loadStream("c-1")
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
+    let stored = await jsonOps.loadStream("c-1")
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
     let typename =
       stored
       ->Array.get(0)
@@ -91,11 +90,10 @@ describe("QueryDb round-trips a union field", () => {
       ->Option.flatMap(JSON.Decode.string)
     expect(typename)->toEqual(Some("GeolocationLocated"))
 
-    let items =
-      await Ops.loadStream("c-1"->CustomersSpec.Id.makeFromString)
-      ->Stream.runCollect
-      ->Effect.catchAll(_ => Effect.succeed([]))
-      ->Effect.runPromise
+    let items = await Ops.loadStream("c-1"->CustomersSpec.Id.makeFromString)
+    ->Stream.runCollect
+    ->Effect.catchAll(_ => Effect.succeed([]))
+    ->Effect.runPromise
     switch items {
     | [{geolocation: Located({lat, lng})}] => expect((lat, lng))->toEqual((48.2082, 16.3738))
     | _ => expect("round trip")->toBe("Located with its point intact")