@rotorsoft/act-tck 0.1.0 → 0.3.0

package/dist/index.js

@@ -189,7 +189,7 @@ var runLoggerTck = (options) => {
 };
 
 // src/store-tck.ts
-import { ConcurrencyError } from "@rotorsoft/act";
+import { ConcurrencyError, SNAP_EVENT, TOMBSTONE_EVENT } from "@rotorsoft/act";
 import { afterAll, beforeAll, describe as describe3, expect as expect3, it as it3 } from "vitest";
 var runStoreTck = (options) => {
   describe3(`TCK / Store / ${options.name}`, () => {
@@ -311,6 +311,14 @@ var runStoreTck = (options) => {
         expect3(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
+        });
+        expect3(latest).toHaveLength(1);
+        expect3(latest[0].id).toBe(committed.at(-1).id);
       });
       it3("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
@@ -630,6 +638,216 @@ var runStoreTck = (options) => {
         expect3(await store.reset([])).toBe(0);
       });
     });
+    describe3("unblock", () => {
+      it3("clears blocked flag and preserves the watermark", async () => {
+        const s = `unblock-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        await store.commit(s, [inc(2)], makeMeta({ stream: s }));
+        const first = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const m1 = first.find((l) => l.stream === s);
+        await store.ack([{ ...m1, at: m1.at }]);
+        const beforeBlock = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const m2 = beforeBlock.find((l) => l.stream === s);
+        expect3(m2).toBeDefined();
+        const watermarkBefore = m2.at;
+        await store.block([{ ...m2, error: "permanent" }]);
+        let blockedFlag;
+        await store.query_streams(
+          (p) => {
+            blockedFlag = p.blocked;
+          },
+          { stream: s, stream_exact: true, limit: 1 }
+        );
+        expect3(blockedFlag).toBe(true);
+        expect3(await store.unblock([s])).toBe(1);
+        const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const back = after.find((l) => l.stream === s);
+        expect3(back).toBeDefined();
+        expect3(back.at).toBe(watermarkBefore);
+        expect3(back.retry).toBe(0);
+      });
+      it3("returns 0 when the stream is not blocked", async () => {
+        const s = `unblock-noop-${uid()}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        expect3(await store.unblock([s])).toBe(0);
+      });
+      it3("returns 0 for unknown streams and empty input", async () => {
+        expect3(await store.unblock([`missing-${uid()}`])).toBe(0);
+        expect3(await store.unblock([])).toBe(0);
+      });
+      it3("only counts streams that were actually blocked", async () => {
+        const s1 = `unblock-mix-a-${uid()}`;
+        const s2 = `unblock-mix-b-${uid()}`;
+        await store.subscribe([{ stream: s1 }, { stream: s2 }]);
+        await store.commit(
+          s1,
+          [inc(1)],
+          makeMeta({ stream: s1 })
+        );
+        await store.commit(
+          s2,
+          [inc(1)],
+          makeMeta({ stream: s2 })
+        );
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const m1 = leased.find((l) => l.stream === s1);
+        const others = leased.filter((l) => l.stream !== s1);
+        await store.ack(others);
+        await store.block([{ ...m1, error: "boom" }]);
+        expect3(await store.unblock([s1, s2])).toBe(1);
+      });
+      it3("filter form: unblocks by stream pattern", async () => {
+        const tag = uid();
+        const s1 = `unblock-filter-${tag}-a`;
+        const s2 = `unblock-filter-${tag}-b`;
+        const s3 = `other-${tag}`;
+        await store.subscribe([{ stream: s1 }, { stream: s2 }, { stream: s3 }]);
+        await store.commit(
+          s1,
+          [inc(1)],
+          makeMeta({ stream: s1 })
+        );
+        await store.commit(
+          s2,
+          [inc(1)],
+          makeMeta({ stream: s2 })
+        );
+        await store.commit(
+          s3,
+          [inc(1)],
+          makeMeta({ stream: s3 })
+        );
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const blockable = leased.filter((l) => l.stream === s1 || l.stream === s2 || l.stream === s3).map((l) => ({ ...l, error: "boom" }));
+        await store.ack(
+          leased.filter(
+            (l) => !(l.stream === s1 || l.stream === s2 || l.stream === s3)
+          )
+        );
+        await store.block(blockable);
+        const count = await store.unblock({
+          stream: `^unblock-filter-${tag}-`
+        });
+        expect3(count).toBe(2);
+        const after = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        expect3(after.find((l) => l.stream === s3)).toBeUndefined();
+        expect3(after.find((l) => l.stream === s1)).toBeDefined();
+        expect3(after.find((l) => l.stream === s2)).toBeDefined();
+      });
+      it3("filter form: empty filter unblocks every blocked stream", async () => {
+        const tag = uid();
+        const s1 = `unblock-empty-${tag}-a`;
+        const s2 = `unblock-empty-${tag}-b`;
+        await store.subscribe([{ stream: s1 }, { stream: s2 }]);
+        await store.commit(
+          s1,
+          [inc(1)],
+          makeMeta({ stream: s1 })
+        );
+        await store.commit(
+          s2,
+          [inc(1)],
+          makeMeta({ stream: s2 })
+        );
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const mine = leased.filter((l) => l.stream === s1 || l.stream === s2);
+        await store.ack(leased.filter((l) => !mine.includes(l)));
+        await store.block(
+          mine.map((l) => ({ ...l, error: "boom" }))
+        );
+        const count = await store.unblock({
+          stream: `^unblock-empty-${tag}-`
+        });
+        expect3(count).toBe(2);
+      });
+      it3("filter form: explicit blocked:false matches nothing", async () => {
+        const tag = uid();
+        const s = `unblock-blocked-false-${tag}`;
+        await store.subscribe([{ stream: s }]);
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        expect3(
+          await store.unblock({
+            stream: `^unblock-blocked-false-${tag}`,
+            blocked: false
+          })
+        ).toBe(0);
+      });
+    });
+    describe3("reset filter form", () => {
+      it3("resets streams matching a stream pattern", async () => {
+        const tag = uid();
+        const s1 = `reset-filter-${tag}-a`;
+        const s2 = `reset-filter-${tag}-b`;
+        const other = `other-reset-${tag}`;
+        await store.subscribe([
+          { stream: s1 },
+          { stream: s2 },
+          { stream: other }
+        ]);
+        await store.commit(
+          s1,
+          [inc(1)],
+          makeMeta({ stream: s1 })
+        );
+        await store.commit(
+          s2,
+          [inc(1)],
+          makeMeta({ stream: s2 })
+        );
+        await store.commit(
+          other,
+          [inc(1)],
+          makeMeta({ stream: other })
+        );
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const mine = leased.filter(
+          (l) => l.stream === s1 || l.stream === s2 || l.stream === other
+        );
+        await store.ack(mine.map((l) => ({ ...l, at: l.at + 100 })));
+        const count = await store.reset({ stream: `^reset-filter-${tag}-` });
+        expect3(count).toBe(2);
+        const positionFor = async (name) => {
+          let at = null;
+          await store.query_streams(
+            (p) => {
+              at = p.at;
+            },
+            { stream: name, stream_exact: true, limit: 1 }
+          );
+          return at;
+        };
+        expect3(await positionFor(s1)).toBe(-1);
+        expect3(await positionFor(s2)).toBe(-1);
+        expect3(await positionFor(other)).toBeGreaterThan(-1);
+      });
+      it3("filter form: resets only blocked streams when blocked:true", async () => {
+        const tag = uid();
+        const s1 = `reset-blocked-${tag}-blocked`;
+        const s2 = `reset-blocked-${tag}-fine`;
+        await store.subscribe([{ stream: s1 }, { stream: s2 }]);
+        await store.commit(
+          s1,
+          [inc(1)],
+          makeMeta({ stream: s1 })
+        );
+        await store.commit(
+          s2,
+          [inc(1)],
+          makeMeta({ stream: s2 })
+        );
+        const leased = await store.claim(100, 0, `w-${uid()}`, 1e5);
+        const m1 = leased.find((l) => l.stream === s1);
+        await store.ack(leased.filter((l) => l.stream !== s1));
+        await store.block([{ ...m1, error: "boom" }]);
+        const count = await store.reset({
+          stream: `^reset-blocked-${tag}-`,
+          blocked: true
+        });
+        expect3(count).toBe(1);
+      });
+    });
     describe3("prioritize", () => {
       it3("sets priority directly, overriding subscribe's max() rule", async () => {
         const tag = uid();
@@ -809,6 +1027,229 @@ var runStoreTck = (options) => {
         expect3(unblocked).toEqual([sibling]);
       });
     });
+    describe3("query_stats", () => {
+      it3("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]);
+        expect3(stats.size).toBe(2);
+        expect3(stats.get(sA)?.head.name).toBe("Incremented");
+        expect3((stats.get(sA)?.head.data).amount).toBe(2);
+        expect3(stats.get(sB)?.head.name).toBe("Decremented");
+        expect3((stats.get(sB)?.head.data).amount).toBe(5);
+        expect3(stats.has(sUnasked)).toBe(false);
+        const empty = await store.query_stats([]);
+        expect3(empty.size).toBe(0);
+        const unknown = await store.query_stats([`qst-${tag}-missing`]);
+        expect3(unknown.size).toBe(0);
+      });
+      it3("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);
+        expect3(r?.head.name).toBe("Incremented");
+        expect3((r?.head.data).amount).toBe(3);
+        expect3(r?.tail?.name).toBe("Incremented");
+        expect3((r?.tail?.data).amount).toBe(1);
+      });
+      it3("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);
+        expect3(r?.count).toBe(4);
+        expect3(r?.names?.[SNAP_EVENT]).toBe(1);
+        expect3(r?.names?.Incremented).toBe(2);
+        expect3(r?.names?.Decremented).toBe(1);
+        expect3(r?.names?.[SNAP_EVENT]).toBe(1);
+      });
+      it3("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]);
+        expect3(all.get(s)?.head.name).toBe("Incremented");
+        expect3((all.get(s)?.head.data).amount).toBe(3);
+        const excl = await store.query_stats([s], {
+          exclude: ["Incremented"]
+        });
+        expect3(excl.get(s)?.head.name).toBe("Decremented");
+        expect3((excl.get(s)?.head.data).amount).toBe(2);
+        const wipe = await store.query_stats([sAllOut], {
+          exclude: ["Incremented", "Decremented", "Reset"]
+        });
+        expect3(wipe.has(sAllOut)).toBe(false);
+        const noTomb = await store.query_stats([s], {
+          exclude: [TOMBSTONE_EVENT]
+        });
+        expect3(noTomb.get(s)?.head.name).toBe("Incremented");
+      });
+      it3("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);
+        expect3(r?.count).toBe(1);
+        expect3(r?.head.id).toBe(c1[0].id);
+        expect3(r?.tail?.id).toBe(c1[0].id);
+        const empty = await store.query_stats([s], {
+          before: 0
+        });
+        expect3(empty.has(s)).toBe(false);
+      });
+      it3("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-`
+        });
+        expect3([...orders.keys()].sort()).toEqual([sA, sB].sort());
+        const exact = await store.query_stats({
+          stream: sA,
+          stream_exact: true
+        });
+        expect3([...exact.keys()]).toEqual([sA]);
+        const all = await store.query_stats({
+          stream: `^qsf-${tag}-`
+        });
+        expect3([...all.keys()].sort()).toEqual([sA, sB, sOther].sort());
+      });
+      it3("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);
+        expect3(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
+        });
+        expect3(blockedNames).toEqual([a]);
+        const stats = await store.query_stats(blockedNames);
+        expect3(stats.get(a)?.head.name).toBe("Incremented");
+        expect3(stats.has(b)).toBe(false);
+      });
+      it3("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({});
+        expect3(all.has(a)).toBe(true);
+        expect3(all.has(b)).toBe(true);
+      });
+      it3("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
+        });
+        expect3(c.get(s)?.count).toBe(3);
+        expect3(c.get(s)?.names).toBeUndefined();
+        expect3(c.get(s)?.tail).toBeUndefined();
+        const n = await store.query_stats([s], {
+          names: true
+        });
+        expect3(n.get(s)?.names).toEqual({ Incremented: 2, Decremented: 1 });
+        expect3(n.get(s)?.count).toBeUndefined();
+        expect3(n.get(s)?.tail).toBeUndefined();
+        const t = await store.query_stats([s], { tail: true });
+        expect3(t.get(s)?.tail?.name).toBe("Incremented");
+        expect3((t.get(s)?.tail?.data).amount).toBe(1);
+        expect3(t.get(s)?.count).toBeUndefined();
+        expect3(t.get(s)?.names).toBeUndefined();
+      });
+    });
     describe3("query_streams anchor contract", () => {
       it3("plain regex without anchors is a substring match", async () => {
         const tag = uid();