@rotorsoft/act-tck 1.26.8 → 1.26.10

package/dist/index.js

@@ -394,20 +394,28 @@ var mulberry322 = (seed) => {
   };
 };
 var normalize_event = (e) => ({
+  stream: e.stream,
+  version: e.version,
+  name: e.name,
+  data: e.data,
+  pii: e.pii != null
+});
+var normalize_identity = (e) => ({
   stream: e.stream,
   version: e.version,
   name: e.name,
   data: e.data
 });
-var build_plan = (seed, stream_count) => {
+var build_plan = (seed, stream_count, pii_isolation) => {
   const rng = mulberry322(seed);
   const tag = uid();
-  const event_prefix = `diff-${tag}-evt-`;
-  const sub_prefix = `diff-${tag}-sub-`;
+  const event_prefix = `Diff-${tag}-Evt-`;
+  const sub_prefix = `Diff-${tag}-Sub-`;
   const event_streams = Array.from(
     { length: stream_count },
-    (_, i) => `${event_prefix}${i}`
+    (_, i) => `${event_prefix}S${i}`
   );
+  const correlation = `corr-${tag}`;
   let type_cursor = 0;
   const next_msg = () => {
     const kind = type_cursor++ % 3;
@@ -416,65 +424,246 @@ var build_plan = (seed, stream_count) => {
   };
   const batch = () => Array.from({ length: 1 + Math.floor(rng() * 3) }, next_msg);
   const pick_stream = () => event_streams[Math.floor(rng() * event_streams.length)];
-  const ops = [];
-  for (const stream of event_streams)
-    ops.push({ t: "commit", stream, msgs: batch() });
-  const middle = 8 + Math.floor(rng() * 16);
-  for (let i = 0; i < middle; i++) {
-    const stream = pick_stream();
-    const kind = Math.floor(rng() * 3);
-    if (kind === 0) ops.push({ t: "commit", stream, msgs: batch() });
-    else if (kind === 1)
-      ops.push({ t: "snapshot", stream, count: Math.floor(rng() * 1e3) });
-    else ops.push({ t: "truncate", stream, count: Math.floor(rng() * 1e3) });
-  }
-  for (const stream of event_streams)
-    ops.push({ t: "commit", stream, msgs: batch() });
   const lanes = ["default", "slow", "fast"];
-  const subs = event_streams.map((source, i) => ({
-    stream: `${sub_prefix}${i}`,
+  const lease_prefix = `Diff-${tag}-Src-`;
+  const lease_sources = event_streams.map((_, i) => `${lease_prefix}S${i}`);
+  const subs = lease_sources.map((source, i) => ({
+    stream: `${sub_prefix}S${i}`,
     source,
     lane: lanes[i % lanes.length],
     priority: i % 4
   }));
-  return { event_prefix, event_streams, sub_prefix, ops, subs };
+  const pick_sub = () => Math.floor(rng() * subs.length);
+  const ops = [];
+  const pii_stream = event_streams[0];
+  event_streams.forEach((stream, i) => {
+    ops.push({
+      t: "commit",
+      stream,
+      msgs: batch(),
+      pii: pii_isolation && i === 0 ? { email: `u-${tag}@example.com`, name: "Ursula" } : void 0
+    });
+  });
+  for (const src of lease_sources)
+    ops.push({ t: "commit", stream: src, msgs: [inc(1)] });
+  const middle = 12 + Math.floor(rng() * 20);
+  for (let i = 0; i < middle; i++) {
+    const kind = Math.floor(rng() * 10);
+    if (kind === 0) {
+      ops.push({ t: "commit", stream: pick_stream(), msgs: batch() });
+    } else if (kind === 1) {
+      ops.push({
+        t: "snapshot",
+        stream: pick_stream(),
+        count: Math.floor(rng() * 1e3)
+      });
+    } else if (kind === 2) {
+      ops.push({
+        t: "truncate",
+        stream: pick_stream(),
+        count: Math.floor(rng() * 1e3)
+      });
+    } else if (kind === 3) {
+      ops.push({
+        t: "truncate_windowed",
+        stream: pick_stream(),
+        max_id: rng() < 0.5
+      });
+    } else if (kind === 4) {
+      ops.push({ t: "claim", millis: 1e5 });
+    } else if (kind === 5) {
+      ops.push({ t: "ack", sub: pick_sub() });
+    } else if (kind === 6) {
+      ops.push({
+        t: "defer",
+        sub: pick_sub(),
+        due: 41024448e5 + Math.floor(rng() * 1e3)
+      });
+    } else if (kind === 7) {
+      ops.push({
+        t: "block",
+        sub: pick_sub(),
+        error: `boom-${Math.floor(rng() * 100)}`
+      });
+    } else if (kind === 8) {
+      ops.push({ t: "unblock", sub: pick_sub() });
+    } else {
+      if (rng() < 0.5) ops.push({ t: "reset_sub", sub: pick_sub() });
+      else
+        ops.push({
+          t: "prioritize",
+          sub: pick_sub(),
+          priority: Math.floor(rng() * 10)
+        });
+    }
+  }
+  const filter_name = "Incremented";
+  for (const stream of event_streams)
+    ops.push({ t: "commit", stream, msgs: [inc(1)] });
+  const query_cases = [
+    {
+      label: "names filter (single event name)",
+      query: { stream: `^${event_prefix}`, names: [filter_name] }
+    },
+    {
+      label: "correlation filter",
+      query: { stream: `^${event_prefix}`, correlation }
+    },
+    {
+      label: "limit bound",
+      query: { stream: `^${event_prefix}`, limit: 3 }
+    },
+    {
+      label: "backward + limit",
+      query: { stream: `^${event_prefix}`, backward: true, limit: 4 }
+    },
+    // Absolute `id` bounds (`after`/`before` with positive ids) are
+    // deliberately absent: event ids are the canonical "legitimately
+    // differs between adapters" field (see `normalize_event`), and full
+    // truncates renumber them differently per store, so a positive id
+    // bound selects a different absolute window on each adapter. The
+    // gated falsy-zero cases below compare only the *guard* behavior
+    // (filter applied → subset, vs filter dropped → all), which stays a
+    // well-defined divergence regardless of the concrete id values.
+    // #1199 edge inputs — opposite semantics across adapters today.
+    {
+      label: "empty names filter",
+      query: { stream: `^${event_prefix}`, names: [] },
+      gated: "queryEdgeInputs"
+    },
+    {
+      label: "before: 0 (falsy-zero guard)",
+      query: { stream: `^${event_prefix}`, before: 0 },
+      gated: "queryEdgeInputs"
+    },
+    {
+      label: "backward + after: 0 (falsy-zero guard)",
+      query: { stream: `^${event_prefix}`, backward: true, after: 0 },
+      gated: "queryEdgeInputs"
+    }
+  ];
+  return {
+    event_prefix,
+    event_streams,
+    sub_prefix,
+    ops,
+    subs,
+    correlation,
+    pii_stream,
+    query_cases,
+    filter_name
+  };
 };
-var apply_plan = async (store, plan) => {
+var apply_plan = async (store, plan, pii_isolation) => {
+  await store.subscribe(
+    plan.subs.map((s) => ({
+      stream: s.stream,
+      source: s.source,
+      lane: s.lane,
+      priority: s.priority
+    }))
+  );
+  const held = /* @__PURE__ */ new Map();
+  const owned = new Set(plan.subs.map((s) => s.stream));
   for (const op of plan.ops) {
     if (op.t === "commit") {
+      const msgs = op.pii && pii_isolation ? op.msgs.map((m, i) => i === 0 ? { ...m, pii: op.pii } : m) : op.msgs;
       await store.commit(
         op.stream,
-        op.msgs,
-        make_meta({ stream: op.stream })
+        msgs,
+        make_meta({ stream: op.stream, correlation: plan.correlation })
       );
     } else if (op.t === "snapshot") {
       await store.commit(
         op.stream,
         [{ name: SNAP_EVENT, data: { count: op.count } }],
-        make_meta({ stream: op.stream })
+        make_meta({ stream: op.stream, correlation: plan.correlation })
       );
-    } else {
+    } else if (op.t === "truncate") {
       await store.truncate([
         { stream: op.stream, snapshot: { count: op.count } }
       ]);
+    } else if (op.t === "truncate_windowed") {
+      await store.commit(
+        op.stream,
+        [{ name: SNAP_EVENT, data: { count: 1 } }],
+        make_meta({ stream: op.stream, correlation: plan.correlation })
+      );
+      await store.truncate([
+        {
+          stream: op.stream,
+          before: new Date(Date.now() + 6e4),
+          // A wide cap that still fits a 32-bit event-id column, so it
+          // never excludes the boundary snapshot on any adapter.
+          ...op.max_id ? { max_id: 2147483647 } : {}
+        }
+      ]);
+    } else if (op.t === "claim") {
+      const by = uid();
+      const leased = await store.claim(1e5, 1e5, by, op.millis);
+      for (const l of leased) if (owned.has(l.stream)) held.set(l.stream, by);
+    } else if (op.t === "ack") {
+      const stream = plan.subs[op.sub].stream;
+      const by = held.get(stream);
+      if (by) {
+        await store.ack([{ stream, at: 0, by, retry: 0, lagging: true }]);
+        held.delete(stream);
+      }
+    } else if (op.t === "defer") {
+      const stream = plan.subs[op.sub].stream;
+      const by = held.get(stream);
+      if (by) {
+        const lease = {
+          stream,
+          at: 0,
+          by,
+          retry: 0,
+          lagging: true,
+          due: op.due
+        };
+        await store.ack([lease]);
+        held.delete(stream);
+      }
+    } else if (op.t === "block") {
+      const stream = plan.subs[op.sub].stream;
+      const by = held.get(stream);
+      if (by) {
+        const lease = {
+          stream,
+          at: 0,
+          by,
+          retry: 0,
+          lagging: true,
+          error: op.error
+        };
+        await store.block([lease]);
+        held.delete(stream);
+      }
+    } else if (op.t === "unblock") {
+      const stream = plan.subs[op.sub].stream;
+      await store.unblock([stream]);
+      held.delete(stream);
+    } else if (op.t === "reset_sub") {
+      const stream = plan.subs[op.sub].stream;
+      await store.reset([stream]);
+      held.delete(stream);
+    } else {
+      await store.prioritize(
+        { stream: plan.subs[op.sub].stream, stream_exact: true },
+        op.priority
+      );
     }
   }
-  await store.subscribe(
-    plan.subs.map((s) => ({
-      stream: s.stream,
-      source: s.source,
-      lane: s.lane,
-      priority: s.priority
-    }))
-  );
 };
 var runStoreDifferentialTck = (options) => {
   describe6(`TCK / Store differential / ${options.name}`, () => {
     const base_seed = options.seed ?? 2759;
     const stream_count = options.streams ?? 4;
+    const pii_isolation = options.piiIsolation ?? true;
+    const skip = { ...options.skip };
     const plans = Array.from(
       { length: options.runs ?? 8 },
-      (_, r) => build_plan(base_seed + r, stream_count)
+      (_, r) => build_plan(base_seed + r, stream_count, pii_isolation)
     );
     const live = [];
     beforeAll2(async () => {
@@ -482,7 +671,7 @@ var runStoreDifferentialTck = (options) => {
         const store = await spec.factory();
         await store.drop();
         await store.seed();
-        for (const plan of plans) await apply_plan(store, plan);
+        for (const plan of plans) await apply_plan(store, plan, pii_isolation);
         live.push({ name: spec.name, store });
       }
     });
@@ -546,6 +735,21 @@ var runStoreDifferentialTck = (options) => {
             return by_stream;
           });
         });
+        plan.query_cases.forEach((qc) => {
+          const gated = qc.gated && skip[qc.gated];
+          it6.skipIf(gated)(
+            `yields identical events under ${qc.label}`,
+            async () => {
+              await assert_identical(`query / ${qc.label}`, async (store) => {
+                const out = [];
+                await store.query((e) => {
+                  out.push(normalize_event(e));
+                }, qc.query);
+                return out;
+              });
+            }
+          );
+        });
         it6("yields identical query_stats output (head/tail/count/names)", async () => {
           await assert_identical("query_stats", async (store) => {
             const stats = await store.query_stats(
@@ -556,8 +760,8 @@ var runStoreDifferentialTck = (options) => {
             const content = {};
             for (const [stream, s] of stats) {
               content[stream] = {
-                head: normalize_event(s.head),
-                tail: normalize_event(
+                head: normalize_identity(s.head),
+                tail: normalize_identity(
                   s.tail
                 ),
                 count: s.count,
@@ -567,7 +771,7 @@ var runStoreDifferentialTck = (options) => {
             return { keys, content };
           });
         });
-        it6("yields identical query_streams output", async () => {
+        it6("yields identical query_streams output (incl. lease-lifecycle state)", async () => {
           await assert_identical("query_streams", async (store) => {
             const rows = [];
             const { count } = await store.query_streams(
@@ -578,7 +782,10 @@ var runStoreDifferentialTck = (options) => {
                   at: p.at,
                   blocked: p.blocked,
                   priority: p.priority,
-                  lane: p.lane
+                  lane: p.lane,
+                  retry: p.retry,
+                  error: p.error,
+                  leased: p.leased_by != null
                 });
               },
               { stream: `^${plan.sub_prefix}`, limit: 1e3 }
@@ -587,6 +794,60 @@ var runStoreDifferentialTck = (options) => {
             return { count, rows };
           });
         });
+        it6.skipIf(skip.caseInsensitivePatterns)(
+          "matches case-sensitively under a lower-cased pattern filter",
+          async () => {
+            await assert_identical(
+              "query_streams lower-cased pattern",
+              async (store) => {
+                const collect_streams = async (pattern) => {
+                  const streams = [];
+                  await store.query_streams(
+                    (p) => {
+                      streams.push(p.stream);
+                    },
+                    { stream: pattern, limit: 1e3 }
+                  );
+                  streams.sort((a, b) => a.localeCompare(b));
+                  return streams;
+                };
+                const matched = await collect_streams(`^${plan.sub_prefix}S`);
+                const lowered = await collect_streams(
+                  `^${plan.sub_prefix.toLowerCase()}s`
+                );
+                return { matched, lowered };
+              }
+            );
+          }
+        );
+        it6("yields identical events under an exact mixed-case stream lookup", async () => {
+          await assert_identical("query exact mixed-case", async (store) => {
+            const out = [];
+            await store.query(
+              (e) => {
+                out.push(normalize_event(e));
+              },
+              { stream: plan.event_streams[0], stream_exact: true }
+            );
+            return out;
+          });
+        });
+        it6.skipIf(!pii_isolation)(
+          "erases pii identically via forget_pii",
+          async () => {
+            await assert_identical("forget_pii erase", async (store) => {
+              const erased = await store.forget_pii(plan.pii_stream);
+              const after = [];
+              await store.query(
+                (e) => {
+                  after.push(normalize_event(e));
+                },
+                { stream: plan.pii_stream, stream_exact: true }
+              );
+              return { erased, after };
+            });
+          }
+        );
       });
     });
   });
@@ -1007,6 +1268,54 @@ var runStoreTck = (options) => {
           committed.slice(0, -1).map((c) => c.id)
         );
       });
+      it7("names:[] matches no events", async () => {
+        const s = `q-names-empty-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1), dec(1)],
+          make_meta({ stream: s })
+        );
+        const none = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          names: []
+        });
+        expect8(none).toHaveLength(0);
+        const all = await collect(store, { stream: s, stream_exact: true });
+        expect8(all).toHaveLength(2);
+      });
+      it7("after:0 and before:0 are honored as id bounds", async () => {
+        const s = `q-zero-bound-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1), inc(2), inc(3)],
+          make_meta({ stream: s })
+        );
+        expect8(
+          await collect(store, { stream: s, stream_exact: true, before: 0 })
+        ).toHaveLength(0);
+        expect8(
+          await collect(store, {
+            stream: s,
+            stream_exact: true,
+            before: 0,
+            backward: true
+          })
+        ).toHaveLength(0);
+        const forward = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          after: 0
+        });
+        expect8(forward.every((e) => e.id > 0)).toBe(true);
+        const backward = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          after: 0,
+          backward: true
+        });
+        expect8(backward.every((e) => e.id > 0)).toBe(true);
+      });
       it7("created_after/created_before filter by timestamp", async () => {
         const s = `q-ts-${uid()}`;
         const committed = await store.commit(
@@ -1245,6 +1554,34 @@ var runStoreTck = (options) => {
         if (error !== void 0) expect8(error).toBeInstanceOf(ValidationError);
         else expect8(count).toBe(1);
       });
+      it7("stream filters match case-sensitively (query)", async () => {
+        const tag = uid();
+        const lower = `order-${tag}`;
+        const upper = `Order-${tag}`;
+        await seed_streams([lower, upper]);
+        expect8(await streams_matching(`^order-${tag}`)).toEqual([lower]);
+        expect8(await streams_matching(`^Order-${tag}$`)).toEqual([upper]);
+        expect8(await streams_matching(`order-${tag}`)).toEqual([lower]);
+      });
+      it7("stream filters match case-sensitively (position filters)", async () => {
+        const tag = uid();
+        const lower = `csp-order-${tag}`;
+        const upper = `csp-Order-${tag}`;
+        await store.subscribe([{ stream: lower }, { stream: upper }]);
+        const got = [];
+        await store.query_streams((p) => got.push(p.stream), {
+          stream: `^csp-order-${tag}`
+        });
+        expect8(got).toEqual([lower]);
+      });
+      it7("bulk stream ops match case-sensitively", async () => {
+        const tag = uid();
+        const lower = `bcs-order-${tag}`;
+        const upper = `bcs-Order-${tag}`;
+        await store.subscribe([{ stream: lower }, { stream: upper }]);
+        const count = await store.reset({ stream: `^bcs-order-${tag}` });
+        expect8(count).toBe(1);
+      });
     });
     describe8("subscribe + claim + ack", () => {
       it7("subscribes new streams and is idempotent on repeat", async () => {
@@ -1827,6 +2164,28 @@ 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 () => {
+        const deferred = `defer-qs-${uid()}`;
+        const plain = `defer-qs-plain-${uid()}`;
+        await store.subscribe([{ stream: deferred }, { stream: plain }]);
+        for (const s of [deferred, plain])
+          await store.commit(
+            s,
+            [inc(1)],
+            make_meta({ stream: s })
+          );
+        const due = Date.now() + 36e5;
+        await store.defer([deferred], due);
+        const seen = /* @__PURE__ */ new Map();
+        await store.query_streams((p) => {
+          if (p.stream === deferred || p.stream === plain)
+            seen.set(p.stream, p.deferred_at);
+        });
+        const got = seen.get(deferred);
+        expect8(got).toBeDefined();
+        expect8(Math.abs(got - due)).toBeLessThan(2e3);
+        expect8(seen.get(plain)).toBeUndefined();
+      });
       it7("defers streams matching a filter and counts matches", async () => {
         const tag = uid();
         const a = `deferfilter-${tag}-a`;