@rotorsoft/act-tck 1.38.20 → 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;
@@ -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 () => {
@@ -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()}`;