@rotorsoft/act-tck 1.38.19 → 1.38.21

package/dist/index.js

@@ -135,9 +135,9 @@ var runCacheDifferentialTck = (options) => {
 
 // src/cache-tck.ts
 import { afterEach, beforeEach as beforeEach2, describe as describe2, expect as expect2, it as it2 } from "vitest";
-var entry = (event_id, state = {}, stream = `s-${event_id}`) => ({
+var entry = (event_id, state2 = {}, stream = `s-${event_id}`) => ({
   stream,
-  state,
+  state: state2,
   version: event_id,
   event_id,
   patches: 1,
@@ -363,7 +363,7 @@ async function load_surface(entry2) {
     if (visited.has(abs)) return;
     const content = await fs.readFile(abs, "utf8");
     visited.set(abs, content);
-    const re_export = /^\s*(?:import|export)\b[^"';]*\bfrom\s+["'](\.[^"']+)["']/gm;
+    const re_export = /^\s*export\b[^"';]*\bfrom\s+["'](\.[^"']+)["']/gm;
     for (const m of content.matchAll(re_export)) {
       const rel = m[1].replace(/\.js$/, ".ts");
       const target = path.resolve(path.dirname(abs), rel);
@@ -1113,10 +1113,12 @@ import {
   InMemoryCache,
   SNAP_EVENT as SNAP_EVENT2,
   sleep,
+  state,
   TOMBSTONE_EVENT,
   ValidationError
 } from "@rotorsoft/act";
 import { afterAll as afterAll4, beforeAll as beforeAll4, describe as describe8, expect as expect8, it as it7, vi } from "vitest";
+import { z as z2 } from "zod";
 var runStoreTck = (options) => {
   describe8(`TCK / Store / ${options.name}`, () => {
     let store;
@@ -2150,7 +2152,7 @@ var runStoreTck = (options) => {
         const second = await store.claim(0, 100, `w-${uid()}`, 1);
         expect8(second.find((l) => l.stream === s)).toBeDefined();
       });
-      it7("does not starve a default-priority lagging stream under sustained high-priority load (ACT-1223)", async () => {
+      it7("does not starve a default-priority lagging stream under sustained high-priority load", async () => {
         const fresh = await options.factory();
         try {
           await fresh.drop();
@@ -2552,7 +2554,7 @@ var runStoreTck = (options) => {
         const again = await store.claim(100, 100, `w2-${uid()}`, 1e5);
         expect8(again.find((l) => l.stream === s)).toBeUndefined();
       });
-      it7("returns the post-block row, not the caller's lease (#1382)", async () => {
+      it7("returns the post-block row, not the caller's lease", async () => {
         const s = `block-returns-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2597,7 +2599,7 @@ var runStoreTck = (options) => {
         ]);
         expect8(blocked).toHaveLength(0);
       });
-      it7("re-blocking an already-blocked stream is a no-op (#1263)", async () => {
+      it7("re-blocking an already-blocked stream is a no-op", async () => {
         const s = `block-twice-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2715,7 +2717,7 @@ var runStoreTck = (options) => {
         const leased = await store.claim(100, 100, `w-${uid()}`, 1e5);
         expect8(leased.find((l) => l.stream === s)).toBeDefined();
       });
-      it7("exposes a future deferred_at via query_streams (#1221)", async () => {
+      it7("exposes a future deferred_at via query_streams", async () => {
         const deferred = `defer-qs-${uid()}`;
         const plain = `defer-qs-plain-${uid()}`;
         await store.subscribe([{ stream: deferred }, { stream: plain }]);
@@ -2770,7 +2772,7 @@ var runStoreTck = (options) => {
         expect8(await store.defer([`missing-${uid()}`], Date.now())).toBe(0);
         expect8(await store.defer([], Date.now())).toBe(0);
       });
-      it7("counts a duplicated stream name once (#1360)", async () => {
+      it7("counts a duplicated stream name once", async () => {
         const s = `defer-dup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2836,7 +2838,7 @@ var runStoreTck = (options) => {
         expect8(re.retry).toBe(0);
         await store.ack([{ ...re, at: 1e6 }]);
       });
-      it7("persists the lease's retry on a backoff-style due lease (#1262)", async () => {
+      it7("persists the lease's retry on a backoff-style due lease", async () => {
         const s = `ackdefer-retry-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -2856,7 +2858,7 @@ var runStoreTck = (options) => {
         expect8(re.retry).toBe(4);
         await store.ack([{ ...re, at: 1e6 }]);
       });
-      it7("advances the watermark to `at` while persisting the schedule on a partial-progress due lease (#1278)", async () => {
+      it7("advances the watermark to `at` while persisting the schedule on a partial-progress due lease", async () => {
         const s = `ackadvance-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const [e1] = await store.commit(
@@ -2946,7 +2948,7 @@ var runStoreTck = (options) => {
         expect8(await store.reset([`missing-${uid()}`])).toBe(0);
         expect8(await store.reset([])).toBe(0);
       });
-      it7("counts a duplicated stream name once (#1360)", async () => {
+      it7("counts a duplicated stream name once", async () => {
         const s = `reset-dup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
@@ -3218,6 +3220,106 @@ var runStoreTck = (options) => {
         expect8(got1.priority).toBe(3);
         expect8(got2.priority).toBe(5);
       });
+      it7("matches a stream pattern", async () => {
+        const tag = uid();
+        await store.subscribe([
+          { stream: `pri-${tag}-proj-a` },
+          { stream: `pri-${tag}-proj-b` },
+          { stream: `pri-${tag}-audit-x` }
+        ]);
+        expect8(
+          await store.prioritize({ stream: `^pri-${tag}-proj-.*$` }, 3)
+        ).toBe(2);
+      });
+      it7("matches by source, skipping rows that have none", async () => {
+        const tag = uid();
+        await store.subscribe([
+          { stream: `pri-${tag}-t1`, source: `pri-src-${tag}-users` },
+          { stream: `pri-${tag}-t2`, source: `pri-src-${tag}-audit` },
+          { stream: `pri-${tag}-t3` }
+        ]);
+        expect8(
+          await store.prioritize(
+            { source: `pri-src-${tag}-users`, source_exact: true },
+            4
+          )
+        ).toBe(1);
+        expect8(
+          await store.prioritize({ source: `^pri-src-${tag}-.*$` }, 6)
+        ).toBe(2);
+      });
+      it7("matches by blocked state, both ways", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const tag = uid();
+          const src = `pri-src-${tag}`;
+          const ok = `pri-${tag}-ok`;
+          const bad = `pri-${tag}-bad`;
+          await fresh.commit(
+            src,
+            [inc(1)],
+            make_meta({ stream: src })
+          );
+          await fresh.subscribe([
+            { stream: ok, source: src },
+            { stream: bad, source: src }
+          ]);
+          await correlate(fresh);
+          const leases = await fresh.claim(2, 0, `w-${uid()}`, 5e3);
+          const lease = leases.find((l) => l.stream === bad);
+          await fresh.block([{ ...lease, error: "boom" }]);
+          const scope = `^pri-${tag}-.*$`;
+          expect8(
+            await fresh.prioritize({ stream: scope, blocked: true }, 9)
+          ).toBe(1);
+          expect8(
+            await fresh.prioritize({ stream: scope, blocked: false }, 9)
+          ).toBe(1);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+      it7("an empty filter updates every row, and skips rows already at the value", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const tag = uid();
+          await fresh.subscribe([
+            { stream: `pri-${tag}-a` },
+            { stream: `pri-${tag}-b`, priority: 5 }
+          ]);
+          expect8(await fresh.prioritize({}, 5)).toBe(1);
+          expect8(await fresh.prioritize({}, 5)).toBe(0);
+        } finally {
+          await fresh.dispose();
+        }
+      });
+      it7("claim returns higher-priority streams first under tied watermarks", async () => {
+        const fresh = await options.factory();
+        try {
+          await fresh.drop();
+          await fresh.seed();
+          const tag = uid();
+          const src = `pri-src-${tag}`;
+          await fresh.commit(
+            src,
+            [inc(1), inc(2)],
+            make_meta({ stream: src })
+          );
+          await fresh.subscribe([
+            { stream: `pri-${tag}-low`, source: src, priority: 0 },
+            { stream: `pri-${tag}-high`, source: src, priority: 5 }
+          ]);
+          await correlate(fresh);
+          const leases = await fresh.claim(1, 0, `w-${uid()}`, 5e3);
+          expect8(leases.map((l) => l.stream)).toEqual([`pri-${tag}-high`]);
+        } finally {
+          await fresh.dispose();
+        }
+      });
     });
     describe8("lanes", () => {
       it7("subscribe defaults lane to 'default' when omitted", async () => {
@@ -3431,7 +3533,7 @@ var runStoreTck = (options) => {
       });
     });
     describe8("long identifiers", () => {
-      it7("accepts a stream name well past 100 characters (#1420)", async () => {
+      it7("accepts a stream name well past 100 characters", async () => {
         const tag = uid();
         const long = `${tag}-${"x".repeat(140)}`;
         await store.commit(
@@ -3454,7 +3556,7 @@ var runStoreTck = (options) => {
       });
     });
     describe8("truncate", () => {
-      it7("leaves subscriptions untouched for restart and retire alike (#1527)", async () => {
+      it7("leaves subscriptions untouched for restart and retire alike", async () => {
         const tag = uid();
         const restarted = `trunc-restart-${tag}`;
         const retired = `trunc-retire-${tag}`;
@@ -3482,7 +3584,7 @@ var runStoreTck = (options) => {
         expect8(rows).toContain(restarted);
         expect8(rows).toContain(retired);
       });
-      it7("leaves a retired stream's surviving subscription unclaimable (#1527)", async () => {
+      it7("leaves a retired stream's surviving subscription unclaimable", async () => {
         const lane = `inert-lane-${uid()}`;
         const s = `trunc-inert-${uid()}`;
         const [e] = await store.commit(
@@ -3544,7 +3646,7 @@ var runStoreTck = (options) => {
         );
         expect8(remaining[0].data).toEqual({ count: 7 });
       });
-      it7("leaves exactly one seed when a stream is listed twice (#1677)", async () => {
+      it7("leaves exactly one seed when a stream is listed twice", async () => {
         const s = `trunc-dup-${uid()}`;
         await store.commit(
           s,
@@ -3566,7 +3668,7 @@ var runStoreTck = (options) => {
         expect8(remaining[0].data).toEqual({ count: 2 });
         expect8(result.get(s)?.deleted).toBe(1);
       });
-      it7("applies windowed targets before full ones (#1677)", async () => {
+      it7("applies windowed targets before full ones", async () => {
         const s = `trunc-mix-${uid()}`;
         await store.commit(
           s,
@@ -3770,7 +3872,7 @@ var runStoreTck = (options) => {
       });
     });
     describe8("query_streams", () => {
-      it7("keyset pagination visits every stream regardless of name case (#1375)", async () => {
+      it7("keyset pagination visits every stream regardless of name case", async () => {
         const tag = uid();
         const names = [
           `${tag}-Bravo`,
@@ -3965,7 +4067,7 @@ var runStoreTck = (options) => {
         });
         expect8(stats.size).toBe(0);
       });
-      it7("keyset pagination visits every stream regardless of name case (#1357)", async () => {
+      it7("keyset pagination visits every stream regardless of name case", async () => {
         const tag = uid();
         const names = [
           `${tag}-Bravo`,
@@ -4258,6 +4360,43 @@ var runStoreTck = (options) => {
         });
         expect8([...all.keys()].sort()).toEqual([...streams].sort());
       });
+      it7("pages the count and tail paths by limit + after too", async () => {
+        const tag = uid();
+        for (const s of [`qsc-${tag}-c`, `qsc-${tag}-a`, `qsc-${tag}-b`])
+          await store.commit(
+            s,
+            [inc(1), inc(2)],
+            make_meta({ stream: s })
+          );
+        const pattern = { stream: `qsc-${tag}-.*` };
+        const counted = await store.query_stats(pattern, {
+          count: true,
+          names: true,
+          limit: 2
+        });
+        expect8([...counted.keys()]).toEqual([`qsc-${tag}-a`, `qsc-${tag}-b`]);
+        expect8(counted.get(`qsc-${tag}-a`)?.count).toBe(2);
+        expect8(counted.get(`qsc-${tag}-a`)?.names).toEqual({ Incremented: 2 });
+        const counted2 = await store.query_stats(pattern, {
+          count: true,
+          limit: 2,
+          after: `qsc-${tag}-b`
+        });
+        expect8([...counted2.keys()]).toEqual([`qsc-${tag}-c`]);
+        const tailed = await store.query_stats(pattern, {
+          tail: true,
+          limit: 2
+        });
+        expect8([...tailed.keys()]).toEqual([`qsc-${tag}-a`, `qsc-${tag}-b`]);
+        expect8(tailed.get(`qsc-${tag}-a`)?.head.version).toBe(1);
+        expect8(tailed.get(`qsc-${tag}-a`)?.tail?.version).toBe(0);
+        const tailed2 = await store.query_stats(pattern, {
+          tail: true,
+          limit: 2,
+          after: `qsc-${tag}-b`
+        });
+        expect8([...tailed2.keys()]).toEqual([`qsc-${tag}-c`]);
+      });
     });
     describe8.skipIf(!caps.source_matches)(
       "query_streams source_matches (capability)",
@@ -4388,6 +4527,52 @@ var runStoreTck = (options) => {
         expect8(positions).toEqual([s]);
       });
     });
+    describe8("autoclose end-to-end", () => {
+      const Ticket = state({ TckTicket: z2.object({ open: z2.boolean() }) }).init(() => ({ open: false })).emits({
+        TckTicketOpened: z2.object({ title: z2.string() }),
+        TckTicketResolved: z2.object({})
+      }).patch({
+        TckTicketOpened: () => ({ open: true }),
+        TckTicketResolved: () => ({ open: false })
+      }).on({ OpenTckTicket: z2.object({ title: z2.string() }) }).emit((a) => ["TckTicketOpened", { title: a.title }]).on({ ResolveTckTicket: z2.object({}) }).emit(() => ["TckTicketResolved", {}]).autocloses({ is: "TckTicketResolved" }).build();
+      const actor2 = { id: "tck", name: "tck" };
+      const run = async (resolve) => {
+        const fresh = await options.factory();
+        await fresh.drop();
+        await fresh.seed();
+        const cache = new InMemoryCache();
+        const app = act().withState(Ticket).build({ scoped: { store: fresh, cache } });
+        const truncated = [];
+        app.on("closed", (r) => truncated.push(...r.truncated.keys()));
+        const stream = `ac-${uid()}`;
+        try {
+          await app.do("OpenTckTicket", { stream, actor: actor2 }, { title: "a" });
+          if (resolve) await app.do("ResolveTckTicket", { stream, actor: actor2 }, {});
+          await app.correlate();
+          await app.drain();
+          const surviving = [];
+          await fresh.query((e) => surviving.push(String(e.name)), {
+            stream,
+            stream_exact: true
+          });
+          return { stream, truncated, surviving };
+        } finally {
+          await app.shutdown();
+          await cache.dispose();
+          await fresh.dispose();
+        }
+      };
+      it7("closes a stream whose head is the terminal event, leaving a tombstone", async () => {
+        const { stream, truncated, surviving } = await run(true);
+        expect8(truncated).toContain(stream);
+        expect8(surviving).toEqual([TOMBSTONE_EVENT]);
+      });
+      it7("leaves a stream whose head is not the terminal event", async () => {
+        const { stream, truncated, surviving } = await run(false);
+        expect8(truncated).not.toContain(stream);
+        expect8(surviving).toEqual(["TckTicketOpened"]);
+      });
+    });
     describe8("seed_stream helper coverage", () => {
       it7("commits N events with monotonically increasing ids", async () => {
         const s = `seed-${uid()}`;
@@ -5026,7 +5211,7 @@ var runStoreTck = (options) => {
         expect8(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
         expect8(seen[0].data).toEqual({ amount: 1 });
       });
-      describe8("with_pii (#1675)", () => {
+      describe8("with_pii", () => {
         const seed_pii = async (s) => await store.commit(
           s,
           [
@@ -5090,7 +5275,7 @@ var runStoreTck = (options) => {
           for (const e of seen) expect8(e.pii ?? null).toBeNull();
         });
       });
-      it7("round-trips a Date losslessly in pii, like data/meta (#1365/#1370/#1556)", async () => {
+      it7("round-trips a Date losslessly in pii, like data/meta", async () => {
         const s = `pii-date-${uid()}`;
         const when = /* @__PURE__ */ new Date("2024-03-01T10:20:30.000Z");
         await store.commit(
@@ -5119,7 +5304,7 @@ var runStoreTck = (options) => {
         expect8(recovered(born)).toBe(when.getTime());
         expect8(typeof at).toBe(typeof born);
       });
-      it7("query_stats head/tail never carry pii \u2014 introspection surface is pii-safe (#1294)", async () => {
+      it7("query_stats head/tail never carry pii \u2014 introspection surface is pii-safe", async () => {
         const s = `pii-stats-${uid()}`;
         await store.commit(
           s,