@rotorsoft/act-tck 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -352,6 +352,14 @@ var runStoreTck = (options) => {
         (0, import_vitest3.expect)(backward.map((e) => e.id)).toEqual(
           [...committed].reverse().map((c) => c.id)
         );
+        const latest = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          backward: true,
+          limit: 1
+        });
+        (0, import_vitest3.expect)(latest).toHaveLength(1);
+        (0, import_vitest3.expect)(latest[0].id).toBe(committed.at(-1).id);
       });
       (0, import_vitest3.it)("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
@@ -908,6 +916,169 @@ var runStoreTck = (options) => {
         (0, import_vitest3.expect)(got2.priority).toBe(5);
       });
     });
+    (0, import_vitest3.describe)("lanes", () => {
+      (0, import_vitest3.it)("subscribe defaults lane to 'default' when omitted", async () => {
+        const s = `lane-default-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.lane), {
+          stream: s,
+          stream_exact: true
+        });
+        (0, import_vitest3.expect)(seen).toEqual(["default"]);
+      });
+      (0, import_vitest3.it)("subscribe records the lane passed in", async () => {
+        const s = `lane-set-${uid()}`;
+        await store.subscribe([{ stream: s, lane: "slow" }]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.lane), {
+          stream: s,
+          stream_exact: true
+        });
+        (0, import_vitest3.expect)(seen).toEqual(["slow"]);
+      });
+      (0, import_vitest3.it)("subscribe re-lanes existing streams on subsequent calls", async () => {
+        const s = `lane-upsert-${uid()}`;
+        await store.subscribe([{ stream: s, lane: "slow" }]);
+        await store.subscribe([{ stream: s, lane: "fast" }]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.lane), {
+          stream: s,
+          stream_exact: true
+        });
+        (0, import_vitest3.expect)(seen).toEqual(["fast"]);
+      });
+      (0, import_vitest3.it)("claim() filters by lane when supplied and returns lane on the Lease", async () => {
+        const tag = uid();
+        const src1 = `lane-claim-src1-${tag}`;
+        const src2 = `lane-claim-src2-${tag}`;
+        const subDefault = `lane-claim-def-${tag}`;
+        const subSlow = `lane-claim-slow-${tag}`;
+        await store.commit(
+          src1,
+          [inc(1)],
+          makeMeta({ stream: src1 })
+        );
+        await store.commit(
+          src2,
+          [inc(1)],
+          makeMeta({ stream: src2 })
+        );
+        await store.subscribe([
+          { stream: subDefault, source: src1 },
+          { stream: subSlow, source: src2, lane: "slow" }
+        ]);
+        const slow = await store.claim(50, 0, `w-slow-${tag}`, 1e3, "slow");
+        const slowMine = slow.filter(
+          (l) => l.stream === subDefault || l.stream === subSlow
+        );
+        (0, import_vitest3.expect)(slowMine.map((l) => l.stream)).toEqual([subSlow]);
+        (0, import_vitest3.expect)(slowMine[0]?.lane).toBe("slow");
+        await store.ack(slowMine.map((l) => ({ ...l, at: l.at + 1 })));
+        const all = await store.claim(50, 0, `w-all-${tag}`, 1e3);
+        const allMine = all.filter((l) => l.stream === subDefault || l.stream === subSlow).map((l) => ({ stream: l.stream, lane: l.lane }));
+        (0, import_vitest3.expect)(allMine).toEqual(
+          import_vitest3.expect.arrayContaining([
+            { stream: subDefault, lane: "default" },
+            { stream: subSlow, lane: "slow" }
+          ])
+        );
+      });
+      (0, import_vitest3.it)("query_streams filters by lane", async () => {
+        const tag = uid();
+        const a = `lane-q-a-${tag}`;
+        const b = `lane-q-b-${tag}`;
+        const c = `lane-q-c-${tag}`;
+        await store.subscribe([
+          { stream: a, lane: "qslow" },
+          { stream: b, lane: "qfast" },
+          { stream: c, lane: "qslow" }
+        ]);
+        const seen = [];
+        await store.query_streams((p) => seen.push(p.stream), {
+          lane: "qslow",
+          stream: `lane-q-.*-${tag}`,
+          limit: 100
+        });
+        (0, import_vitest3.expect)(seen.sort()).toEqual([a, c]);
+      });
+      (0, import_vitest3.it)("prioritize filters by lane", async () => {
+        const tag = uid();
+        const a = `lane-pri-a-${tag}`;
+        const b = `lane-pri-b-${tag}`;
+        await store.subscribe([
+          { stream: a, lane: `pslow-${tag}` },
+          { stream: b, lane: `pfast-${tag}` }
+        ]);
+        const updated = await store.prioritize({ lane: `pslow-${tag}` }, 7);
+        (0, import_vitest3.expect)(updated).toBe(1);
+        const seen = /* @__PURE__ */ new Map();
+        await store.query_streams((p) => seen.set(p.stream, p.priority), {
+          stream: `lane-pri-.*-${tag}`,
+          limit: 100
+        });
+        (0, import_vitest3.expect)(seen.get(a)).toBe(7);
+        (0, import_vitest3.expect)(seen.get(b)).toBe(0);
+      });
+      (0, import_vitest3.it)("reset filters by lane", async () => {
+        const tag = uid();
+        const src = `lane-reset-src-${tag}`;
+        const a = `lane-reset-a-${tag}`;
+        const b = `lane-reset-b-${tag}`;
+        await store.commit(
+          src,
+          [inc(1)],
+          makeMeta({ stream: src })
+        );
+        await store.subscribe([
+          { stream: a, source: src, lane: `rslow-${tag}` },
+          { stream: b, source: src, lane: `rfast-${tag}` }
+        ]);
+        const leases = await store.claim(50, 0, `w-${tag}`, 5e3);
+        const mine = leases.filter((l) => l.stream === a || l.stream === b);
+        await store.ack(mine.map((l) => ({ ...l, at: l.at + 1 })));
+        const count = await store.reset({ lane: `rslow-${tag}` });
+        (0, import_vitest3.expect)(count).toBe(1);
+        const ats = /* @__PURE__ */ new Map();
+        for (const name of [a, b]) {
+          await store.query_streams((p) => ats.set(p.stream, p.at), {
+            stream: name,
+            stream_exact: true
+          });
+        }
+        (0, import_vitest3.expect)(ats.get(a)).toBe(-1);
+        (0, import_vitest3.expect)(ats.get(b)).toBeGreaterThanOrEqual(0);
+      });
+      (0, import_vitest3.it)("unblock filters by lane", async () => {
+        const tag = uid();
+        const src = `lane-ub-src-${tag}`;
+        const a = `lane-ub-a-${tag}`;
+        const b = `lane-ub-b-${tag}`;
+        await store.commit(
+          src,
+          [inc(1)],
+          makeMeta({ stream: src })
+        );
+        await store.subscribe([
+          { stream: a, source: src, lane: `uslow-${tag}` },
+          { stream: b, source: src, lane: `ufast-${tag}` }
+        ]);
+        const leases = await store.claim(50, 0, `w-${tag}`, 5e3);
+        const mine = leases.filter((l) => l.stream === a || l.stream === b);
+        await store.block(mine.map((l) => ({ ...l, error: "boom" })));
+        const count = await store.unblock({ lane: `uslow-${tag}` });
+        (0, import_vitest3.expect)(count).toBe(1);
+        const blocked = /* @__PURE__ */ new Map();
+        for (const name of [a, b]) {
+          await store.query_streams((p) => blocked.set(p.stream, p.blocked), {
+            stream: name,
+            stream_exact: true
+          });
+        }
+        (0, import_vitest3.expect)(blocked.get(a)).toBe(false);
+        (0, import_vitest3.expect)(blocked.get(b)).toBe(true);
+      });
+    });
     (0, import_vitest3.describe)("truncate", () => {
       (0, import_vitest3.it)("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
@@ -1060,6 +1231,229 @@ var runStoreTck = (options) => {
         (0, import_vitest3.expect)(unblocked).toEqual([sibling]);
       });
     });
+    (0, import_vitest3.describe)("query_stats", () => {
+      (0, import_vitest3.it)("array input \u2014 returns head per stream, absent when not in input", async () => {
+        const tag = uid();
+        const sA = `qst-${tag}-a`;
+        const sB = `qst-${tag}-b`;
+        const sUnasked = `qst-${tag}-unasked`;
+        await store.commit(
+          sA,
+          [inc(1), inc(2)],
+          makeMeta({ stream: sA })
+        );
+        await store.commit(
+          sB,
+          [dec(5)],
+          makeMeta({ stream: sB })
+        );
+        await store.commit(
+          sUnasked,
+          [inc(99)],
+          makeMeta({ stream: sUnasked })
+        );
+        const stats = await store.query_stats([sA, sB]);
+        (0, import_vitest3.expect)(stats.size).toBe(2);
+        (0, import_vitest3.expect)(stats.get(sA)?.head.name).toBe("Incremented");
+        (0, import_vitest3.expect)((stats.get(sA)?.head.data).amount).toBe(2);
+        (0, import_vitest3.expect)(stats.get(sB)?.head.name).toBe("Decremented");
+        (0, import_vitest3.expect)((stats.get(sB)?.head.data).amount).toBe(5);
+        (0, import_vitest3.expect)(stats.has(sUnasked)).toBe(false);
+        const empty = await store.query_stats([]);
+        (0, import_vitest3.expect)(empty.size).toBe(0);
+        const unknown = await store.query_stats([`qst-${tag}-missing`]);
+        (0, import_vitest3.expect)(unknown.size).toBe(0);
+      });
+      (0, import_vitest3.it)("tail returns the earliest event per stream", async () => {
+        const tag = uid();
+        const s = `qst-tail-${tag}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(s, [inc(2)], makeMeta({ stream: s }));
+        await store.commit(s, [inc(3)], makeMeta({ stream: s }));
+        const stats = await store.query_stats([s], {
+          tail: true
+        });
+        const r = stats.get(s);
+        (0, import_vitest3.expect)(r?.head.name).toBe("Incremented");
+        (0, import_vitest3.expect)((r?.head.data).amount).toBe(3);
+        (0, import_vitest3.expect)(r?.tail?.name).toBe("Incremented");
+        (0, import_vitest3.expect)((r?.tail?.data).amount).toBe(1);
+      });
+      (0, import_vitest3.it)("count + names \u2014 full aggregates including framework markers", async () => {
+        const tag = uid();
+        const s = `qst-cn-${tag}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.truncate([{ stream: s, snapshot: { count: 99 } }]);
+        await store.commit(
+          s,
+          [inc(2), inc(3), dec(1)],
+          makeMeta({ stream: s })
+        );
+        const stats = await store.query_stats([s], {
+          count: true,
+          names: true
+        });
+        const r = stats.get(s);
+        (0, import_vitest3.expect)(r?.count).toBe(4);
+        (0, import_vitest3.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
+        (0, import_vitest3.expect)(r?.names?.Incremented).toBe(2);
+        (0, import_vitest3.expect)(r?.names?.Decremented).toBe(1);
+        (0, import_vitest3.expect)(r?.names?.[import_act.SNAP_EVENT]).toBe(1);
+      });
+      (0, import_vitest3.it)("exclude shifts head past filtered events; stream absent when all filtered", async () => {
+        const tag = uid();
+        const s = `qst-excl-${tag}`;
+        const sAllOut = `qst-allout-${tag}`;
+        await store.commit(
+          s,
+          [inc(1), dec(2), inc(3)],
+          makeMeta({ stream: s })
+        );
+        await store.commit(
+          sAllOut,
+          [inc(7)],
+          makeMeta({ stream: sAllOut })
+        );
+        const all = await store.query_stats([s]);
+        (0, import_vitest3.expect)(all.get(s)?.head.name).toBe("Incremented");
+        (0, import_vitest3.expect)((all.get(s)?.head.data).amount).toBe(3);
+        const excl = await store.query_stats([s], {
+          exclude: ["Incremented"]
+        });
+        (0, import_vitest3.expect)(excl.get(s)?.head.name).toBe("Decremented");
+        (0, import_vitest3.expect)((excl.get(s)?.head.data).amount).toBe(2);
+        const wipe = await store.query_stats([sAllOut], {
+          exclude: ["Incremented", "Decremented", "Reset"]
+        });
+        (0, import_vitest3.expect)(wipe.has(sAllOut)).toBe(false);
+        const noTomb = await store.query_stats([s], {
+          exclude: [import_act.TOMBSTONE_EVENT]
+        });
+        (0, import_vitest3.expect)(noTomb.get(s)?.head.name).toBe("Incremented");
+      });
+      (0, import_vitest3.it)("before \u2014 time travel narrows head/tail/count", async () => {
+        const tag = uid();
+        const s = `qst-tt-${tag}`;
+        const c1 = await store.commit(
+          s,
+          [inc(1)],
+          makeMeta({ stream: s })
+        );
+        const c2 = await store.commit(
+          s,
+          [inc(2)],
+          makeMeta({ stream: s })
+        );
+        await store.commit(s, [inc(3)], makeMeta({ stream: s }));
+        const before = c2[0].id;
+        const stats = await store.query_stats([s], {
+          tail: true,
+          count: true,
+          before
+        });
+        const r = stats.get(s);
+        (0, import_vitest3.expect)(r?.count).toBe(1);
+        (0, import_vitest3.expect)(r?.head.id).toBe(c1[0].id);
+        (0, import_vitest3.expect)(r?.tail?.id).toBe(c1[0].id);
+        const empty = await store.query_stats([s], {
+          before: 0
+        });
+        (0, import_vitest3.expect)(empty.has(s)).toBe(false);
+      });
+      (0, import_vitest3.it)("filter form \u2014 stream regex, stream_exact, empty {} match", async () => {
+        const tag = uid();
+        const sA = `qsf-${tag}-orders-1`;
+        const sB = `qsf-${tag}-orders-2`;
+        const sOther = `qsf-${tag}-users-1`;
+        await store.commit(
+          sA,
+          [inc(1)],
+          makeMeta({ stream: sA })
+        );
+        await store.commit(
+          sB,
+          [inc(2)],
+          makeMeta({ stream: sB })
+        );
+        await store.commit(
+          sOther,
+          [inc(3)],
+          makeMeta({ stream: sOther })
+        );
+        const orders = await store.query_stats({
+          stream: `^qsf-${tag}-orders-`
+        });
+        (0, import_vitest3.expect)([...orders.keys()].sort()).toEqual([sA, sB].sort());
+        const exact = await store.query_stats({
+          stream: sA,
+          stream_exact: true
+        });
+        (0, import_vitest3.expect)([...exact.keys()]).toEqual([sA]);
+        const all = await store.query_stats({
+          stream: `^qsf-${tag}-`
+        });
+        (0, import_vitest3.expect)([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
+      });
+      (0, import_vitest3.it)("compose with query_streams for subscription-level filters", async () => {
+        const tag = uid();
+        const a = `qsc-${tag}-a`;
+        const b = `qsc-${tag}-b`;
+        await store.subscribe([{ stream: a }, { stream: b }]);
+        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
+        await store.commit(b, [inc(2)], makeMeta({ stream: b }));
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const mine = leased.find((l) => l.stream === a);
+        (0, import_vitest3.expect)(mine).toBeDefined();
+        const others = leased.filter((l) => l.stream !== a);
+        await store.ack(others);
+        await store.block([{ ...mine, error: "boom" }]);
+        const blockedNames = [];
+        await store.query_streams((p) => blockedNames.push(p.stream), {
+          stream: `^qsc-${tag}-`,
+          blocked: true
+        });
+        (0, import_vitest3.expect)(blockedNames).toEqual([a]);
+        const stats = await store.query_stats(blockedNames);
+        (0, import_vitest3.expect)(stats.get(a)?.head.name).toBe("Incremented");
+        (0, import_vitest3.expect)(stats.has(b)).toBe(false);
+      });
+      (0, import_vitest3.it)("empty filter {} \u2014 matches every event-bearing stream", async () => {
+        const tag = uid();
+        const a = `qse-${tag}-a`;
+        const b = `qse-${tag}-b`;
+        await store.commit(a, [inc(1)], makeMeta({ stream: a }));
+        await store.commit(b, [dec(2)], makeMeta({ stream: b }));
+        const all = await store.query_stats({});
+        (0, import_vitest3.expect)(all.has(a)).toBe(true);
+        (0, import_vitest3.expect)(all.has(b)).toBe(true);
+      });
+      (0, import_vitest3.it)("stat-flag combinations \u2014 count-only, names-only, tail-only", async () => {
+        const tag = uid();
+        const s = `qsfl-${tag}`;
+        await store.commit(
+          s,
+          [inc(1), inc(2), dec(3)],
+          makeMeta({ stream: s })
+        );
+        const c = await store.query_stats([s], {
+          count: true
+        });
+        (0, import_vitest3.expect)(c.get(s)?.count).toBe(3);
+        (0, import_vitest3.expect)(c.get(s)?.names).toBeUndefined();
+        (0, import_vitest3.expect)(c.get(s)?.tail).toBeUndefined();
+        const n = await store.query_stats([s], {
+          names: true
+        });
+        (0, import_vitest3.expect)(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
+        (0, import_vitest3.expect)(n.get(s)?.count).toBeUndefined();
+        (0, import_vitest3.expect)(n.get(s)?.tail).toBeUndefined();
+        const t = await store.query_stats([s], { tail: true });
+        (0, import_vitest3.expect)(t.get(s)?.tail?.name).toBe("Incremented");
+        (0, import_vitest3.expect)((t.get(s)?.tail?.data).amount).toBe(1);
+        (0, import_vitest3.expect)(t.get(s)?.count).toBeUndefined();
+        (0, import_vitest3.expect)(t.get(s)?.names).toBeUndefined();
+      });
+    });
     (0, import_vitest3.describe)("query_streams anchor contract", () => {
       (0, import_vitest3.it)("plain regex without anchors is a substring match", async () => {
         const tag = uid();