@rotorsoft/act-tck 1.15.1 → 1.17.0

package/dist/index.js

@@ -546,6 +546,52 @@ var runStoreTck = (options) => {
         });
         expect5(limited).toHaveLength(2);
       });
+      it4("with_snaps resumes from the latest snapshot per stream", async () => {
+        const s = `q-snap-${uid()}`;
+        await store.commit(
+          s,
+          [inc(1), inc(1)],
+          make_meta({ stream: s })
+        );
+        const [snap] = await store.commit(
+          s,
+          [{ name: SNAP_EVENT, data: { count: 2 } }],
+          make_meta({ stream: s })
+        );
+        await store.commit(
+          s,
+          [inc(1), inc(1), inc(1)],
+          make_meta({ stream: s })
+        );
+        const from_snap = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true
+        });
+        expect5(from_snap).toHaveLength(4);
+        expect5(from_snap[0].name).toBe(SNAP_EVENT);
+        const domain = await collect(store, { stream: s, stream_exact: true });
+        expect5(domain).toHaveLength(5);
+        const after_snap = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true,
+          after: snap.id
+        });
+        expect5(after_snap).toHaveLength(3);
+        const s2 = `q-nosnap-${uid()}`;
+        await store.commit(
+          s2,
+          [inc(1), inc(1)],
+          make_meta({ stream: s2 })
+        );
+        const full = await collect(store, {
+          stream: s2,
+          stream_exact: true,
+          with_snaps: true
+        });
+        expect5(full).toHaveLength(2);
+      });
       it4("supports backward traversal", async () => {
         const s = `q-back-${uid()}`;
         const committed = await store.commit(
@@ -598,13 +644,14 @@ var runStoreTck = (options) => {
       });
       it4("created_after/created_before filter by timestamp", async () => {
         const s = `q-ts-${uid()}`;
-        const before = new Date(Date.now() - 6e4);
-        const future = new Date(Date.now() + 6e4);
-        await store.commit(
+        const committed = await store.commit(
           s,
           [inc(1)],
           make_meta({ stream: s })
         );
+        const ts = committed[0].created.getTime();
+        const before = new Date(ts - 6e4);
+        const future = new Date(ts + 6e4);
         const in_window = await collect(store, {
           stream: s,
           stream_exact: true,
@@ -655,8 +702,12 @@ var runStoreTck = (options) => {
       });
       it4("backward traversal honors created_before by skipping newer events", async () => {
         const s = `q-back-ts-${uid()}`;
-        await store.commit(s, [inc(1)], make_meta());
-        const past = new Date(Date.now() - 6e4);
+        const committed = await store.commit(
+          s,
+          [inc(1)],
+          make_meta()
+        );
+        const past = new Date(committed[0].created.getTime() - 6e4);
         const got = await collect(store, {
           stream: s,
           stream_exact: true,
@@ -1857,7 +1908,88 @@ var runStoreTck = (options) => {
         expect5(t.get(s)?.count).toBeUndefined();
         expect5(t.get(s)?.names).toBeUndefined();
       });
+      it4("paginates with limit + after (keyset), ordered by stream name", async () => {
+        const tag = uid();
+        const streams = [
+          `qsp-${tag}-a`,
+          `qsp-${tag}-b`,
+          `qsp-${tag}-c`,
+          `qsp-${tag}-d`
+        ];
+        for (const s of streams) {
+          await store.commit(
+            s,
+            [inc(1)],
+            make_meta({ stream: s })
+          );
+        }
+        const page1 = await store.query_stats(
+          { stream: `qsp-${tag}-.*` },
+          { limit: 2 }
+        );
+        const k1 = [...page1.keys()];
+        expect5(k1).toEqual([`qsp-${tag}-a`, `qsp-${tag}-b`]);
+        const page2 = await store.query_stats(
+          { stream: `qsp-${tag}-.*` },
+          { limit: 2, after: k1.at(-1) }
+        );
+        const k2 = [...page2.keys()];
+        expect5(k2).toEqual([`qsp-${tag}-c`, `qsp-${tag}-d`]);
+        const page3 = await store.query_stats(
+          { stream: `qsp-${tag}-.*` },
+          { limit: 2, after: k2.at(-1) }
+        );
+        expect5(page3.size).toBe(0);
+        const all = await store.query_stats({
+          stream: `qsp-${tag}-.*`
+        });
+        expect5([...all.keys()].sort()).toEqual([...streams].sort());
+      });
     });
+    describe5.skipIf(!caps.source_matches)(
+      "query_streams source_matches (capability)",
+      () => {
+        it4("returns only subscriptions whose source pattern matches a name", async () => {
+          const tag = uid();
+          const subConcreteA = `sm-${tag}-sub-a`;
+          const subConcreteB = `sm-${tag}-sub-b`;
+          const subRegex = `sm-${tag}-sub-regex`;
+          const subNoSource = `sm-${tag}-sub-nosource`;
+          const srcA = `sm-${tag}-order-1`;
+          const srcB = `sm-${tag}-order-2`;
+          const srcRegex = `^sm-${tag}-order-`;
+          await store.subscribe([
+            { stream: subConcreteA, source: srcA },
+            { stream: subConcreteB, source: srcB },
+            { stream: subRegex, source: srcRegex },
+            // No source = no source constraint = matches every name.
+            { stream: subNoSource }
+          ]);
+          const matched = [];
+          await store.query_streams((p) => matched.push(p.stream), {
+            stream: `sm-${tag}-sub-.*`,
+            source_matches: [srcA]
+          });
+          expect5(matched.sort()).toEqual(
+            [subConcreteA, subRegex, subNoSource].sort()
+          );
+          const none = [];
+          await store.query_streams((p) => none.push(p.stream), {
+            stream: `sm-${tag}-sub-.*`,
+            source_matches: [`sm-${tag}-unrelated`]
+          });
+          expect5(none).toEqual([subNoSource]);
+          const both = [];
+          await store.query_streams((p) => both.push(p.stream), {
+            stream: `sm-${tag}-sub-.*`,
+            source_matches: [srcA, srcB]
+          });
+          expect5(both.sort()).toEqual(
+            [subConcreteA, subConcreteB, subRegex, subNoSource].sort()
+          );
+        });
+      }
+    );
     describe5("query_streams anchor contract", () => {
       it4("plain regex without anchors is a substring match", async () => {
         const tag = uid();