@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/QueryDbStorageSqliteTest.res.mjs

@@ -0,0 +1,126 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Effect from "effect/Effect";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as QueryDbStorage_Sqlite$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+function makeFreshDb() {
+  return SqliteDriver$ReventlessLocal.openDb(":memory:");
+}
+
+globalThis.describe("QueryDbStorage_Sqlite", () => {
+  globalThis.test("save then loadStream round-trips an item", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("rm1", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.save("id1", "value1", "Any", undefined);
+    let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("id1")), param => Effect.succeed([])));
+    globalThis.expect(items.length).toBe(1);
+    globalThis.expect(items[0]).toEqual("value1");
+  });
+  globalThis.test("save overwrites existing item at same (id, subKey)", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("rm2", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.save("k", "a", "Any", undefined);
+    await ops.save("k", "b", "Any", undefined);
+    let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("k")), param => Effect.succeed([])));
+    globalThis.expect(items.length).toBe(1);
+    globalThis.expect(items[0]).toEqual("b");
+  });
+  globalThis.test("saveBatch atomically writes several items", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("rm3", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.saveBatch([
+      [
+        "id1",
+        "one",
+        undefined
+      ],
+      [
+        "id2",
+        "two",
+        undefined
+      ],
+      [
+        "id3",
+        "three",
+        undefined
+      ]
+    ]);
+    let items1 = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("id1")), param => Effect.succeed([])));
+    let items2 = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("id2")), param => Effect.succeed([])));
+    let items3 = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("id3")), param => Effect.succeed([])));
+    globalThis.expect(items1.length).toBe(1);
+    globalThis.expect(items2.length).toBe(1);
+    globalThis.expect(items3.length).toBe(1);
+  });
+  globalThis.test("delete removes an item from a partition", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(":memory:");
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("rm4", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.save("k", "a", "Any", undefined);
+    await ops.delete("k", undefined);
+    let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("k")), param => Effect.succeed([])));
+    globalThis.expect(items.length).toBe(0);
+  });
+  globalThis.test("items persist across a file reopen", async () => {
+    let path = `/tmp/reventless-test-qdb-` + Date.now().toString() + `.db`;
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let db = SqliteDriver$ReventlessLocal.openDb(path);
+    let DbProvider = {
+      db: db
+    };
+    let Storage = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus)(DbProvider);
+    let s = Storage.make("persist", [], undefined, undefined, undefined, undefined, opts);
+    let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+    await ops.save("k", "hello", "Any", undefined);
+    SqliteDriver$ReventlessLocal.close(db);
+    let TestBus2 = LocalBus$ReventlessLocal.Make({});
+    let db$1 = SqliteDriver$ReventlessLocal.openDb(path);
+    let DbProvider2 = {
+      db: db$1
+    };
+    let Storage2 = QueryDbStorage_Sqlite$ReventlessLocal.Make(TestBus2)(DbProvider2);
+    let s2 = Storage2.make("persist", [], undefined, undefined, undefined, undefined, opts);
+    let ops2 = await TestRunner$ReventlessLocal.resolve(s2.operations);
+    let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops2.loadStream("k")), param => Effect.succeed([])));
+    globalThis.expect(items.length).toBe(1);
+    globalThis.expect(items[0]).toEqual("hello");
+    return SqliteDriver$ReventlessLocal.close(db$1);
+  });
+});
+
+export {
+  opts,
+  makeFreshDb,
+}
+/*  Not a pure module */

package/tests/adapter/QueryDbStorageTest.res

@@ -0,0 +1,171 @@
+// Unit tests for QueryDbStorage_InMemory.
+// Covers save, loadStream, saveBatch, count, delete, deleteBatch, and scan registration.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+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 = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="rm1", ~indexes=[], ~api=(), ~apiRole=(), ~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"))
+    })
+
+    testPromise("loadStream returns empty for unknown id", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="rm2", ~indexes=[], ~api=(), ~apiRole=(), ~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)
+    })
+
+    testPromise("save overwrites previous state for same id", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="rm3", ~indexes=[], ~api=(), ~apiRole=(), ~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"))
+    })
+
+    testPromise("load delegates to loadStream (backward-compat)", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="load-compat", ~indexes=[], ~api=(), ~apiRole=(), ~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 = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="rm4", ~indexes=[], ~api=(), ~apiRole=(), ~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")
+        ->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"))
+    })
+  })
+
+  describe("count", () => {
+    testPromise("returns the increment value (no real counting semantics)", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="rm5", ~indexes=[], ~api=(), ~apiRole=(), ~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 = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="rm6", ~indexes=[], ~api=(), ~apiRole=(), ~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)
+    })
+
+    testPromise("deleteBatch removes multiple items", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="rm7", ~indexes=[], ~api=(), ~apiRole=(), ~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")
+        ->Stream.runCollect
+        ->Effect.catchAll(_ => Effect.succeed([]))
+        ->Effect.runPromise
+      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 = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="scan-rm", ~indexes=[], ~api=(), ~apiRole=(), ~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 = QueryDbStorage_InMemory.Make(TestBus)
+      let s = Storage.make(~name="scan-rm2", ~indexes=[], ~api=(), ~apiRole=(), ~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/QueryDbStorageTest.res.mjs

@@ -0,0 +1,170 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as QueryDbStorage_InMemory$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+globalThis.describe("QueryDbStorage_InMemory", () => {
+  globalThis.describe("save and load", () => {
+    globalThis.test("save stores state; loadStream retrieves it by id", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("rm1", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("id1", "value1", "Any", undefined);
+      let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("id1")), param => Effect.succeed([])));
+      globalThis.expect(items.length).toBe(1);
+      globalThis.expect(items[0]).toEqual("value1");
+    });
+    globalThis.test("loadStream returns empty for unknown id", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("rm2", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("unknown")), param => Effect.succeed([])));
+      globalThis.expect(items.length).toBe(0);
+    });
+    globalThis.test("save overwrites previous state for same id", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("rm3", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("id1", "old", "Any", undefined);
+      await ops.save("id1", "new", "Any", undefined);
+      let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("id1")), param => Effect.succeed([])));
+      globalThis.expect(items.length).toBe(1);
+      globalThis.expect(items[0]).toEqual("new");
+    });
+    globalThis.test("load delegates to loadStream (backward-compat)", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("load-compat", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("compat-id", "compat-val", "Any", undefined);
+      let streamed = await Effect.runPromise(Stream.runCollect(ops.loadStream("compat-id")));
+      let loaded = await ops.load("compat-id");
+      globalThis.expect(loaded).toEqual({
+        TAG: "Ok",
+        _0: streamed
+      });
+    });
+  });
+  globalThis.describe("saveBatch", () => {
+    globalThis.test("stores multiple items; loadStream retrieves each by id", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("rm4", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.saveBatch([
+        [
+          "a",
+          "val-a",
+          undefined
+        ],
+        [
+          "b",
+          "val-b",
+          undefined
+        ]
+      ]);
+      let itemsA = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("a")), param => Effect.succeed([])));
+      let itemsB = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("b")), param => Effect.succeed([])));
+      globalThis.expect(itemsA[0]).toEqual("val-a");
+      globalThis.expect(itemsB[0]).toEqual("val-b");
+    });
+  });
+  globalThis.describe("count", () => {
+    globalThis.test("returns the increment value (no real counting semantics)", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("rm5", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let result = await ops.count("id1", "field", 5);
+      globalThis.expect(result).toEqual({
+        TAG: "Ok",
+        _0: 5
+      });
+    });
+  });
+  globalThis.describe("delete", () => {
+    globalThis.test("removes item; loadStream returns empty", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("rm6", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("del-id", "v", "Any", undefined);
+      await ops.delete("del-id", undefined);
+      let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("del-id")), param => Effect.succeed([])));
+      globalThis.expect(items.length).toBe(0);
+    });
+    globalThis.test("deleteBatch removes multiple items", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("rm7", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.saveBatch([
+        [
+          "x",
+          "vx",
+          undefined
+        ],
+        [
+          "y",
+          "vy",
+          undefined
+        ]
+      ]);
+      await ops.deleteBatch([
+        [
+          "x",
+          undefined
+        ],
+        [
+          "y",
+          undefined
+        ]
+      ]);
+      let rx = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("x")), param => Effect.succeed([])));
+      let ry = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream("y")), param => Effect.succeed([])));
+      globalThis.expect(rx.length).toBe(0);
+      globalThis.expect(ry.length).toBe(0);
+    });
+  });
+  globalThis.describe("scan registration", () => {
+    globalThis.test("after save, scan function returns all stored items", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("scan-rm", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("s1", "item1", "Any", undefined);
+      await ops.save("s2", "item2", "Any", undefined);
+      let scanFn = Stdlib_Option.getOr(TestBus.getQueryDbScan("scan-rm"), () => []);
+      let all = scanFn();
+      globalThis.expect(all.length).toBe(2);
+    });
+    globalThis.test("after delete, scan function excludes deleted item", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("scan-rm2", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("keep", "keep", "Any", undefined);
+      await ops.save("gone", "gone", "Any", undefined);
+      await ops.delete("gone", undefined);
+      let scanFn = Stdlib_Option.getOr(TestBus.getQueryDbScan("scan-rm2"), () => []);
+      let all = scanFn();
+      globalThis.expect(all.length).toBe(1);
+    });
+  });
+});
+
+export {
+  opts,
+}
+/*  Not a pure module */

package/tests/adapter/QueryEngineTest.res

@@ -0,0 +1,152 @@
+// Unit tests for LocalQueryEngine.
+// Verifies query (by id and key) and scan operations via the bus storage registry.
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+let opts: Pulumi.CustomResourceOptions.t = {}
+
+describe("LocalQueryEngine", () => {
+  describe("query", () => {
+    testPromise("query by id returns items saved in the matching QueryDbStorage", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      module QE = LocalQueryEngine.Make(TestBus)
+      let s = Storage.make(~name="users", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ = await ops.save("user-1", JSON.Encode.string("Alice"), ReventlessCore.QueryDb.Any, None)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let items = await engine.query(
+        ~readModelName="users",
+        ~id=Reventless.QueryEngine.String("user-1"),
+      )
+      expect(items->Array.length)->toBe(1)
+      expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("Alice"))
+    })
+
+    testPromise("query with explicit key overrides the id parameter", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      module QE = LocalQueryEngine.Make(TestBus)
+      let s = Storage.make(~name="products", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ =
+        await ops.save("prod-key", JSON.Encode.string("Widget"), ReventlessCore.QueryDb.Any, None)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let items = await engine.query(
+        ~readModelName="products",
+        ~key="prod-key",
+        ~id=Reventless.QueryEngine.String("ignored"),
+      )
+      expect(items->Array.length)->toBe(1)
+      expect(items->Array.getUnsafe(0))->toEqual(JSON.Encode.string("Widget"))
+    })
+
+    testPromise("query for unknown readModelName returns empty array", async () => {
+      module TestBus = LocalBus.Make()
+      module QE = LocalQueryEngine.Make(TestBus)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let items = await engine.query(
+        ~readModelName="no-such-model",
+        ~id=Reventless.QueryEngine.String("any"),
+      )
+      expect(items->Array.length)->toBe(0)
+    })
+
+    testPromise("query with Int id converts to string key for lookup", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      module QE = LocalQueryEngine.Make(TestBus)
+      let s = Storage.make(~name="counters", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ = await ops.save("42", JSON.Encode.int(100), ReventlessCore.QueryDb.Any, None)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let items = await engine.query(
+        ~readModelName="counters",
+        ~id=Reventless.QueryEngine.Int(42),
+      )
+      expect(items->Array.length)->toBe(1)
+    })
+  })
+
+  describe("scan", () => {
+    testPromise("scan returns all items from the matching QueryDbStorage", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      module QE = LocalQueryEngine.Make(TestBus)
+      let s = Storage.make(~name="orders", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ = await ops.save("o1", JSON.Encode.string("order1"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("o2", JSON.Encode.string("order2"), ReventlessCore.QueryDb.Any, None)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let items = await engine.scan(~readModelName="orders", ~filterConfigs=[], ~limit=100)
+      expect(items->Array.length)->toBe(2)
+    })
+
+    testPromise("scan for unknown readModelName returns empty array", async () => {
+      module TestBus = LocalBus.Make()
+      module QE = LocalQueryEngine.Make(TestBus)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let items = await engine.scan(~readModelName="no-such-model", ~filterConfigs=[], ~limit=100)
+      expect(items->Array.length)->toBe(0)
+    })
+  })
+
+  describe("scan with ~limit", () => {
+    testPromise("~limit=2 on a 5-item QueryDb returns exactly 2 items", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      module QE = LocalQueryEngine.Make(TestBus)
+      let s = Storage.make(~name="items", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ = await ops.save("k1", JSON.Encode.string("a"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("k2", JSON.Encode.string("b"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("k3", JSON.Encode.string("c"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("k4", JSON.Encode.string("d"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("k5", JSON.Encode.string("e"), ReventlessCore.QueryDb.Any, None)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let result = await engine.scan(~readModelName="items", ~filterConfigs=[], ~limit=2)
+      expect(result->Array.length)->toBe(2)
+    })
+
+    testPromise("~limit larger than total returns all items (no padding)", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      module QE = LocalQueryEngine.Make(TestBus)
+      let s = Storage.make(~name="things", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ = await ops.save("t1", JSON.Encode.string("x"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("t2", JSON.Encode.string("y"), ReventlessCore.QueryDb.Any, None)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let result = await engine.scan(~readModelName="things", ~filterConfigs=[], ~limit=100)
+      expect(result->Array.length)->toBe(2)
+    })
+
+    testPromise("~limit=0 returns empty array", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      module QE = LocalQueryEngine.Make(TestBus)
+      let s = Storage.make(~name="stuff", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ = await ops.save("s1", JSON.Encode.string("z"), ReventlessCore.QueryDb.Any, None)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let result = await engine.scan(~readModelName="stuff", ~filterConfigs=[], ~limit=0)
+      expect(result->Array.length)->toBe(0)
+    })
+
+    testPromise("~limit=3 on a 3-item QueryDb returns all 3 items", async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = QueryDbStorage_InMemory.Make(TestBus)
+      module QE = LocalQueryEngine.Make(TestBus)
+      let s = Storage.make(~name="widgets", ~indexes=[], ~api=(), ~apiRole=(), ~opts)
+      let ops = await s.operations->TestRunner.resolve
+      let _ = await ops.save("w1", JSON.Encode.string("p"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("w2", JSON.Encode.string("q"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("w3", JSON.Encode.string("r"), ReventlessCore.QueryDb.Any, None)
+      let engine = await QE.make(Dict.make())->TestRunner.resolve
+      let result = await engine.scan(~readModelName="widgets", ~filterConfigs=[], ~limit=3)
+      expect(result->Array.length)->toBe(3)
+    })
+  })
+})