@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/adapter/QueryEngineTest.res.mjs

@@ -0,0 +1,148 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as LocalQueryEngine$ReventlessLocal from "../../src/adapter/QueryEngine/LocalQueryEngine.res.mjs";
+import * as QueryDbStorage_InMemory$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let opts = {};
+
+globalThis.describe("LocalQueryEngine", () => {
+  globalThis.describe("query", () => {
+    globalThis.test("query by id returns items saved in the matching QueryDbStorage", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("users", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("user-1", "Alice", "Any", undefined);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let items = await engine.query("users", undefined, {
+        TAG: "String",
+        _0: "user-1"
+      }, undefined, undefined, undefined, undefined);
+      globalThis.expect(items.length).toBe(1);
+      globalThis.expect(items[0]).toEqual("Alice");
+    });
+    globalThis.test("query with explicit key overrides the id parameter", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("products", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("prod-key", "Widget", "Any", undefined);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let items = await engine.query("products", "prod-key", {
+        TAG: "String",
+        _0: "ignored"
+      }, undefined, undefined, undefined, undefined);
+      globalThis.expect(items.length).toBe(1);
+      globalThis.expect(items[0]).toEqual("Widget");
+    });
+    globalThis.test("query for unknown readModelName returns empty array", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let items = await engine.query("no-such-model", undefined, {
+        TAG: "String",
+        _0: "any"
+      }, undefined, undefined, undefined, undefined);
+      globalThis.expect(items.length).toBe(0);
+    });
+    globalThis.test("query with Int id converts to string key for lookup", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("counters", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("42", 100, "Any", undefined);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let items = await engine.query("counters", undefined, {
+        TAG: "Int",
+        _0: 42
+      }, undefined, undefined, undefined, undefined);
+      globalThis.expect(items.length).toBe(1);
+    });
+  });
+  globalThis.describe("scan", () => {
+    globalThis.test("scan returns all items from the matching QueryDbStorage", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("orders", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("o1", "order1", "Any", undefined);
+      await ops.save("o2", "order2", "Any", undefined);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let items = await engine.scan("orders", [], 100);
+      globalThis.expect(items.length).toBe(2);
+    });
+    globalThis.test("scan for unknown readModelName returns empty array", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let items = await engine.scan("no-such-model", [], 100);
+      globalThis.expect(items.length).toBe(0);
+    });
+  });
+  globalThis.describe("scan with ~limit", () => {
+    globalThis.test("~limit=2 on a 5-item QueryDb returns exactly 2 items", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("items", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("k1", "a", "Any", undefined);
+      await ops.save("k2", "b", "Any", undefined);
+      await ops.save("k3", "c", "Any", undefined);
+      await ops.save("k4", "d", "Any", undefined);
+      await ops.save("k5", "e", "Any", undefined);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let result = await engine.scan("items", [], 2);
+      globalThis.expect(result.length).toBe(2);
+    });
+    globalThis.test("~limit larger than total returns all items (no padding)", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("things", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("t1", "x", "Any", undefined);
+      await ops.save("t2", "y", "Any", undefined);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let result = await engine.scan("things", [], 100);
+      globalThis.expect(result.length).toBe(2);
+    });
+    globalThis.test("~limit=0 returns empty array", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("stuff", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("s1", "z", "Any", undefined);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let result = await engine.scan("stuff", [], 0);
+      globalThis.expect(result.length).toBe(0);
+    });
+    globalThis.test("~limit=3 on a 3-item QueryDb returns all 3 items", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = QueryDbStorage_InMemory$ReventlessLocal.Make(TestBus);
+      let QE = LocalQueryEngine$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("widgets", [], undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      await ops.save("w1", "p", "Any", undefined);
+      await ops.save("w2", "q", "Any", undefined);
+      await ops.save("w3", "r", "Any", undefined);
+      let engine = await TestRunner$ReventlessLocal.resolve(QE.make({}));
+      let result = await engine.scan("widgets", [], 3);
+      globalThis.expect(result.length).toBe(3);
+    });
+  });
+});
+
+export {
+  opts,
+}
+/*  Not a pure module */

package/tests/adapter/ScheduledPublisherTest.res

@@ -0,0 +1,199 @@
+// Unit tests for LocalScheduledPublisher.
+// Uses fake timers to verify createSchedule, deleteSchedule, and reset.
+
+open JestGlobals
+
+// ─────────────────────────────────────────────────────────────
+// Fake timer bindings
+// ─────────────────────────────────────────────────────────────
+
+type jestObj
+@module("@jest/globals") external jest: jestObj = "jest"
+@send external useFakeTimers: jestObj => unit = "useFakeTimers"
+@send external useRealTimers: jestObj => unit = "useRealTimers"
+@send external runAllTimers: jestObj => unit = "runAllTimers"
+@send external advanceTimersByTime: (jestObj, int) => unit = "advanceTimersByTime"
+
+let _ = beforeAll(() => {
+  jest->useFakeTimers
+})
+
+// ─────────────────────────────────────────────────────────────
+// Pulumi mock (needed for Pulumi.Output.make in ScheduledPublisher)
+// ─────────────────────────────────────────────────────────────
+
+let _ = TestRunner.setup()
+
+// ─────────────────────────────────────────────────────────────
+// Restore real timers after all tests in this file
+// ─────────────────────────────────────────────────────────────
+
+let _ = afterAll(() => {
+  jest->useRealTimers
+})
+
+// ─────────────────────────────────────────────────────────────
+// Helper: create a topic resource with a known name
+// ─────────────────────────────────────────────────────────────
+
+let makeTopicResource = (topicName: string): ReventlessInfra.Adapter.resolvedResource => {
+  name: topicName,
+  id: topicName,
+  urn: topicName,
+  resourceInfo: NoInfo,
+  service: "memory:InMemory",
+  role: "",
+  region: "",
+  resourceType: "",
+  configuration: Dict.make(),
+  tags: Dict.make(),
+}
+
+describe("LocalScheduledPublisher", () => {
+  describe("createSchedule", () => {
+    testPromise("single-shot schedule fires event after runAllTimers", async () => {
+      module TestBus = LocalBus.Make()
+      module SP = LocalScheduledPublisher.Make(TestBus)
+      let count: ref<int> = ref(0)
+      TestBus.subscribeToEvents("sched-topic", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let pub = SP.make(~name="scheduler", ~opts={})
+      let ops = await pub.operations->TestRunner.resolve
+      let schedule: Reventless.Schedule.schedule = {
+        name: "one-shot",
+        rate: Reventless.Schedule.Single(2024, 1, 1, 0, 0),
+        payload: "{}",
+      }
+      await ops.createSchedule([makeTopicResource("sched-topic")], schedule)
+      jest->runAllTimers
+      // Two microtask ticks: publishEvent uses Effect.all(concurrency=unbounded) which forks
+      // child fibers via startFork — one tick for the child fiber to offer to the Queue,
+      // a second tick for the drain fiber to run the callback.
+      let _ = await Promise.resolve(())
+      let _ = await Promise.resolve(())
+      expect(count.contents)->toBe(1)
+      SP.reset()
+    })
+
+    testPromise("recurring schedule fires on each interval advance", async () => {
+      module TestBus = LocalBus.Make()
+      module SP = LocalScheduledPublisher.Make(TestBus)
+      let count: ref<int> = ref(0)
+      TestBus.subscribeToEvents("repeat-topic", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let pub = SP.make(~name="scheduler2", ~opts={})
+      let ops = await pub.operations->TestRunner.resolve
+      let schedule: Reventless.Schedule.schedule = {
+        name: "every-minute",
+        rate: Reventless.Schedule.Minutes(1),
+        payload: "{}",
+      }
+      await ops.createSchedule([makeTopicResource("repeat-topic")], schedule)
+      jest->advanceTimersByTime(60 * 1000)
+      let _ = await Promise.resolve(())
+      let _ = await Promise.resolve(())
+      jest->advanceTimersByTime(60 * 1000)
+      let _ = await Promise.resolve(())
+      let _ = await Promise.resolve(())
+      expect(count.contents)->toBe(2)
+      SP.reset()
+    })
+  })
+
+  describe("deleteSchedule", () => {
+    testPromise("clears a named schedule; advancing timers does not fire it", async () => {
+      module TestBus = LocalBus.Make()
+      module SP = LocalScheduledPublisher.Make(TestBus)
+      let count: ref<int> = ref(0)
+      TestBus.subscribeToEvents("del-topic", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let pub = SP.make(~name="scheduler3", ~opts={})
+      let ops = await pub.operations->TestRunner.resolve
+      let schedule: Reventless.Schedule.schedule = {
+        name: "to-delete",
+        rate: Reventless.Schedule.Minutes(1),
+        payload: "{}",
+      }
+      await ops.createSchedule([makeTopicResource("del-topic")], schedule)
+      await ops.deleteSchedule([], "to-delete")
+      jest->advanceTimersByTime(60 * 1000)
+      expect(count.contents)->toBe(0)
+      SP.reset()
+    })
+  })
+
+  describe("reset", () => {
+    testPromise("clears all active timers; subsequent advance does not fire", async () => {
+      module TestBus = LocalBus.Make()
+      module SP = LocalScheduledPublisher.Make(TestBus)
+      let count: ref<int> = ref(0)
+      TestBus.subscribeToEvents("reset-topic", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let pub = SP.make(~name="scheduler4", ~opts={})
+      let ops = await pub.operations->TestRunner.resolve
+      let schedule: Reventless.Schedule.schedule = {
+        name: "reset-sched",
+        rate: Reventless.Schedule.Minutes(5),
+        payload: "{}",
+      }
+      await ops.createSchedule([makeTopicResource("reset-topic")], schedule)
+      SP.reset()
+      jest->advanceTimersByTime(5 * 60 * 1000)
+      expect(count.contents)->toBe(0)
+    })
+  })
+
+  describe("rateToMs", () => {
+    testPromise("Minutes(n) fires after n minutes", async () => {
+      module TestBus = LocalBus.Make()
+      module SP = LocalScheduledPublisher.Make(TestBus)
+      let count: ref<int> = ref(0)
+      TestBus.subscribeToEvents("rate-topic", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let pub = SP.make(~name="rate-scheduler", ~opts={})
+      let ops = await pub.operations->TestRunner.resolve
+      let schedule: Reventless.Schedule.schedule = {
+        name: "rate-sched",
+        rate: Reventless.Schedule.Minutes(3),
+        payload: "{}",
+      }
+      await ops.createSchedule([makeTopicResource("rate-topic")], schedule)
+      // Advance by slightly less than 3 minutes — should not fire
+      jest->advanceTimersByTime(3 * 60 * 1000 - 1)
+      expect(count.contents)->toBe(0)
+      // Advance the remaining millisecond — now fires; two ticks for Effect.all drain
+      jest->advanceTimersByTime(1)
+      let _ = await Promise.resolve(())
+      let _ = await Promise.resolve(())
+      expect(count.contents)->toBe(1)
+      SP.reset()
+    })
+
+    testPromise("Hours(n) fires after n hours", async () => {
+      module TestBus = LocalBus.Make()
+      module SP = LocalScheduledPublisher.Make(TestBus)
+      let count: ref<int> = ref(0)
+      TestBus.subscribeToEvents("hours-topic", async (_, _, _) => {
+        count := count.contents + 1
+      })
+      let pub = SP.make(~name="hours-scheduler", ~opts={})
+      let ops = await pub.operations->TestRunner.resolve
+      let schedule: Reventless.Schedule.schedule = {
+        name: "hours-sched",
+        rate: Reventless.Schedule.Hours(2),
+        payload: "{}",
+      }
+      await ops.createSchedule([makeTopicResource("hours-topic")], schedule)
+      jest->advanceTimersByTime(2 * 60 * 60 * 1000)
+      let _ = await Promise.resolve(())
+      let _ = await Promise.resolve(())
+      expect(count.contents)->toBe(1)
+      SP.reset()
+    })
+  })
+})

package/tests/adapter/ScheduledPublisherTest.res.mjs

@@ -0,0 +1,203 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Globals from "@jest/globals";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as LocalScheduledPublisher$ReventlessLocal from "../../src/adapter/Scheduler/LocalScheduledPublisher.res.mjs";
+
+globalThis.beforeAll(() => {
+  Globals.jest.useFakeTimers();
+});
+
+TestRunner$ReventlessLocal.setup();
+
+globalThis.afterAll(() => {
+  Globals.jest.useRealTimers();
+});
+
+function makeTopicResource(topicName) {
+  return {
+    name: topicName,
+    id: topicName,
+    urn: topicName,
+    resourceInfo: "NoInfo",
+    service: "memory:InMemory",
+    role: "",
+    region: "",
+    resourceType: "",
+    configuration: {},
+    tags: {}
+  };
+}
+
+globalThis.describe("LocalScheduledPublisher", () => {
+  globalThis.describe("createSchedule", () => {
+    globalThis.test("single-shot schedule fires event after runAllTimers", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("sched-topic", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      let pub = SP.make("scheduler", {});
+      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
+      await ops.createSchedule([makeTopicResource("sched-topic")], {
+        name: "one-shot",
+        rate: {
+          TAG: "Single",
+          _0: 2024,
+          _1: 1,
+          _2: 1,
+          _3: 0,
+          _4: 0
+        },
+        payload: "{}"
+      });
+      Globals.jest.runAllTimers();
+      await Promise.resolve();
+      await Promise.resolve();
+      globalThis.expect(count.contents).toBe(1);
+      return SP.reset();
+    });
+    globalThis.test("recurring schedule fires on each interval advance", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("repeat-topic", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      let pub = SP.make("scheduler2", {});
+      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
+      await ops.createSchedule([makeTopicResource("repeat-topic")], {
+        name: "every-minute",
+        rate: {
+          TAG: "Minutes",
+          _0: 1
+        },
+        payload: "{}"
+      });
+      Globals.jest.advanceTimersByTime(60000);
+      await Promise.resolve();
+      await Promise.resolve();
+      Globals.jest.advanceTimersByTime(60000);
+      await Promise.resolve();
+      await Promise.resolve();
+      globalThis.expect(count.contents).toBe(2);
+      return SP.reset();
+    });
+  });
+  globalThis.describe("deleteSchedule", () => {
+    globalThis.test("clears a named schedule; advancing timers does not fire it", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("del-topic", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      let pub = SP.make("scheduler3", {});
+      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
+      await ops.createSchedule([makeTopicResource("del-topic")], {
+        name: "to-delete",
+        rate: {
+          TAG: "Minutes",
+          _0: 1
+        },
+        payload: "{}"
+      });
+      await ops.deleteSchedule([], "to-delete");
+      Globals.jest.advanceTimersByTime(60000);
+      globalThis.expect(count.contents).toBe(0);
+      return SP.reset();
+    });
+  });
+  globalThis.describe("reset", () => {
+    globalThis.test("clears all active timers; subsequent advance does not fire", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("reset-topic", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      let pub = SP.make("scheduler4", {});
+      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
+      await ops.createSchedule([makeTopicResource("reset-topic")], {
+        name: "reset-sched",
+        rate: {
+          TAG: "Minutes",
+          _0: 5
+        },
+        payload: "{}"
+      });
+      SP.reset();
+      Globals.jest.advanceTimersByTime(300000);
+      globalThis.expect(count.contents).toBe(0);
+    });
+  });
+  globalThis.describe("rateToMs", () => {
+    globalThis.test("Minutes(n) fires after n minutes", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("rate-topic", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      let pub = SP.make("rate-scheduler", {});
+      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
+      await ops.createSchedule([makeTopicResource("rate-topic")], {
+        name: "rate-sched",
+        rate: {
+          TAG: "Minutes",
+          _0: 3
+        },
+        payload: "{}"
+      });
+      Globals.jest.advanceTimersByTime(179999);
+      globalThis.expect(count.contents).toBe(0);
+      Globals.jest.advanceTimersByTime(1);
+      await Promise.resolve();
+      await Promise.resolve();
+      globalThis.expect(count.contents).toBe(1);
+      return SP.reset();
+    });
+    globalThis.test("Hours(n) fires after n hours", async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let SP = LocalScheduledPublisher$ReventlessLocal.Make(TestBus);
+      let count = {
+        contents: 0
+      };
+      TestBus.subscribeToEvents("hours-topic", async (param, param$1, param$2) => {
+        count.contents = count.contents + 1 | 0;
+      });
+      let pub = SP.make("hours-scheduler", {});
+      let ops = await TestRunner$ReventlessLocal.resolve(pub.operations);
+      await ops.createSchedule([makeTopicResource("hours-topic")], {
+        name: "hours-sched",
+        rate: {
+          TAG: "Hours",
+          _0: 2
+        },
+        payload: "{}"
+      });
+      Globals.jest.advanceTimersByTime(7200000);
+      await Promise.resolve();
+      await Promise.resolve();
+      globalThis.expect(count.contents).toBe(1);
+      return SP.reset();
+    });
+  });
+});
+
+export {
+  makeTopicResource,
+}
+/*  Not a pure module */

package/tests/adapter/SortKey_FilterTest.res

@@ -0,0 +1,103 @@
+// Unit tests for SortKey_Filter — the pure sort key filtering utility.
+
+open JestGlobals
+
+let makeItem = (sk: string) => {
+  let d = Dict.make()
+  d->Dict.set("_subId", JSON.Encode.string(sk))
+  JSON.Encode.object(d)
+}
+
+let items = [
+  makeItem("art/2026-01"),
+  makeItem("art/2026-02"),
+  makeItem("math/2026-01"),
+  makeItem("math/2026-02"),
+  makeItem("science/2026-01"),
+]
+
+let skField = "_subId"
+
+let getSks = result =>
+  result.SortKey_Filter.items->Array.map(item =>
+    item->JSON.Decode.object->Option.flatMap(d => d->Dict.get(skField))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+  )
+
+describe("SortKey_Filter.apply:", () => {
+  testPromise("no filters returns all items in order", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField)
+    expect(r.items->Array.length)->toBe(5)
+    expect(getSks(r))->toEqual(["art/2026-01", "art/2026-02", "math/2026-01", "math/2026-02", "science/2026-01"])
+    expect(r.nextToken)->toBe(None)
+  })
+
+  testPromise("prefix filters to matching sort keys", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~prefix="math")
+    expect(getSks(r))->toEqual(["math/2026-01", "math/2026-02"])
+    expect(r.nextToken)->toBe(None)
+  })
+
+  testPromise("from filters to sort keys >= from", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~from="math/2026-01")
+    expect(getSks(r))->toEqual(["math/2026-01", "math/2026-02", "science/2026-01"])
+  })
+
+  testPromise("to filters to sort keys <= to", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~to_="art/2026-02")
+    expect(getSks(r))->toEqual(["art/2026-01", "art/2026-02"])
+  })
+
+  testPromise("from+to gives BETWEEN range", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~from="art/2026-02", ~to_="math/2026-01")
+    expect(getSks(r))->toEqual(["art/2026-02", "math/2026-01"])
+  })
+
+  testPromise("eq filters to exact match only", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~eq="math/2026-02")
+    expect(getSks(r))->toEqual(["math/2026-02"])
+  })
+
+  testPromise("reverse returns items in descending order", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~reverse=true)
+    expect(getSks(r))->toEqual(["science/2026-01", "math/2026-02", "math/2026-01", "art/2026-02", "art/2026-01"])
+  })
+
+  testPromise("limit returns first N items", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~limit=2)
+    expect(getSks(r))->toEqual(["art/2026-01", "art/2026-02"])
+    expect(r.nextToken)->toBe(Some("2"))
+  })
+
+  testPromise("nextToken resumes from offset", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~limit=2, ~offset=2)
+    expect(getSks(r))->toEqual(["math/2026-01", "math/2026-02"])
+    expect(r.nextToken)->toBe(Some("4"))
+  })
+
+  testPromise("last page has no nextToken", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~limit=2, ~offset=4)
+    expect(getSks(r))->toEqual(["science/2026-01"])
+    expect(r.nextToken)->toBe(None)
+  })
+
+  testPromise("prefix + limit + nextToken paginates correctly", async () => {
+    let r1 = SortKey_Filter.apply(~items, ~skField, ~prefix="art", ~limit=1)
+    expect(getSks(r1))->toEqual(["art/2026-01"])
+    expect(r1.nextToken)->toBe(Some("1"))
+    let r2 = SortKey_Filter.apply(~items, ~skField, ~prefix="art", ~limit=1, ~offset=1)
+    expect(getSks(r2))->toEqual(["art/2026-02"])
+    expect(r2.nextToken)->toBe(None)
+  })
+
+  testPromise("reverse + limit returns last N items", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~reverse=true, ~limit=3)
+    expect(getSks(r))->toEqual(["science/2026-01", "math/2026-02", "math/2026-01"])
+    expect(r.nextToken)->toBe(Some("3"))
+  })
+
+  testPromise("eq with no match returns empty", async () => {
+    let r = SortKey_Filter.apply(~items, ~skField, ~eq="nonexistent")
+    expect(r.items->Array.length)->toBe(0)
+    expect(r.nextToken)->toBe(None)
+  })
+})