@rotorsoft/act-tck 1.25.0 → 1.26.0

package/dist/index.js

@@ -2185,6 +2185,165 @@ var runStoreTck = (options) => {
         const result = await store.truncate([{ stream: s }]);
         expect8(result.get(s)?.deleted).toBe(0);
       });
+      describe8("windowed (before boundary)", () => {
+        async function seed_windowed(s) {
+          await store.commit(
+            s,
+            [inc(1), inc(1)],
+            make_meta({ stream: s })
+          );
+          const [snap_a] = await store.commit(
+            s,
+            [{ name: SNAP_EVENT2, data: { count: 2 } }],
+            make_meta({ stream: s })
+          );
+          await store.commit(
+            s,
+            [inc(1)],
+            make_meta({ stream: s })
+          );
+          const [snap_b] = await store.commit(
+            s,
+            [{ name: SNAP_EVENT2, data: { count: 3 } }],
+            make_meta({ stream: s })
+          );
+          await store.commit(
+            s,
+            [inc(1)],
+            make_meta({ stream: s })
+          );
+          return { snap_a, snap_b };
+        }
+        it7("deletes the prefix below the closest safe snapshot and keeps the snapshot + tail", async () => {
+          const s = `trunc-win-${uid()}`;
+          const { snap_b } = await seed_windowed(s);
+          const before = new Date(Date.now() + 6e4);
+          const result = await store.truncate([{ stream: s, before }]);
+          const entry2 = result.get(s);
+          expect8(entry2?.deleted).toBe(4);
+          expect8(entry2?.committed.id).toBe(snap_b.id);
+          expect8(entry2?.committed.name).toBe(SNAP_EVENT2);
+          expect8(entry2?.committed.data).toEqual({ count: 3 });
+          expect8(entry2?.before).toEqual(before);
+          const remaining = await collect(store, {
+            stream: s,
+            stream_exact: true,
+            with_snaps: true,
+            after: -1
+          });
+          expect8(remaining.map((e) => e.name)).toEqual([
+            SNAP_EVENT2,
+            "Incremented"
+          ]);
+          expect8(remaining[0].id).toBe(snap_b.id);
+        });
+        it7("honors the max_id cap \u2014 boundary never rises past a lagging consumer", async () => {
+          const s = `trunc-win-cap-${uid()}`;
+          const { snap_a, snap_b } = await seed_windowed(s);
+          const before = new Date(Date.now() + 6e4);
+          const result = await store.truncate([
+            { stream: s, before, max_id: snap_a.id }
+          ]);
+          const entry2 = result.get(s);
+          expect8(entry2?.committed.id).toBe(snap_a.id);
+          expect8(entry2?.deleted).toBe(2);
+          const remaining = await collect(store, {
+            stream: s,
+            stream_exact: true,
+            with_snaps: true,
+            after: -1
+          });
+          expect8(remaining.map((e) => e.id)).toContain(snap_b.id);
+          expect8(remaining[0].id).toBe(snap_a.id);
+          expect8(remaining).toHaveLength(4);
+        });
+        it7("no-ops when no snapshot qualifies \u2014 stream absent from the result, events untouched", async () => {
+          const s = `trunc-win-noop-${uid()}`;
+          await store.commit(
+            s,
+            [inc(1), inc(1)],
+            make_meta({ stream: s })
+          );
+          const none = await store.truncate([
+            { stream: s, before: new Date(Date.now() + 6e4) }
+          ]);
+          expect8(none.has(s)).toBe(false);
+          await store.commit(
+            s,
+            [{ name: SNAP_EVENT2, data: { count: 2 } }],
+            make_meta({ stream: s })
+          );
+          const too_early = await store.truncate([
+            { stream: s, before: /* @__PURE__ */ new Date(0) }
+          ]);
+          expect8(too_early.has(s)).toBe(false);
+          const missing = await store.truncate([
+            { stream: `trunc-win-missing-${uid()}`, before: /* @__PURE__ */ new Date() }
+          ]);
+          expect8(missing.size).toBe(0);
+          const remaining = await collect(store, {
+            stream: s,
+            stream_exact: true,
+            with_snaps: true,
+            after: -1
+          });
+          expect8(remaining).toHaveLength(3);
+        });
+        it7("leaves subscriptions untouched, unlike a full truncate", async () => {
+          const s = `trunc-win-subs-${uid()}`;
+          await seed_windowed(s);
+          await store.subscribe([{ stream: s }]);
+          await store.truncate([
+            { stream: s, before: new Date(Date.now() + 6e4) }
+          ]);
+          const positions = [];
+          await store.query_streams((p) => positions.push(p.stream), {
+            stream: s,
+            stream_exact: true
+          });
+          expect8(positions).toEqual([s]);
+        });
+        it7("mixes full and windowed targets in one call", async () => {
+          const w = `trunc-win-mix-w-${uid()}`;
+          const f = `trunc-win-mix-f-${uid()}`;
+          const { snap_b } = await seed_windowed(w);
+          await store.commit(
+            f,
+            [inc(1)],
+            make_meta({ stream: f })
+          );
+          const result = await store.truncate([
+            { stream: w, before: new Date(Date.now() + 6e4) },
+            { stream: f }
+          ]);
+          expect8(result.get(w)?.committed.id).toBe(snap_b.id);
+          expect8(result.get(w)?.before).toBeInstanceOf(Date);
+          expect8(result.get(f)?.deleted).toBe(1);
+          expect8(result.get(f)?.committed.name).toBe("__tombstone__");
+          expect8(result.get(f)?.before).toBeUndefined();
+        });
+        it7("keeps the stream writable and readable after a prune", async () => {
+          const s = `trunc-win-cont-${uid()}`;
+          const { snap_b } = await seed_windowed(s);
+          await store.truncate([
+            { stream: s, before: new Date(Date.now() + 6e4) }
+          ]);
+          const [next] = await store.commit(
+            s,
+            [inc(1)],
+            make_meta({ stream: s })
+          );
+          expect8(next.version).toBe(6);
+          expect8(next.id).toBeGreaterThan(snap_b.id);
+          const replay = await collect(store, {
+            stream: s,
+            stream_exact: true,
+            with_snaps: true
+          });
+          expect8(replay[0].id).toBe(snap_b.id);
+          expect8(replay).toHaveLength(3);
+        });
+      });
     });
     describe8("query_streams", () => {
       it7("returns positions filtered by stream regex, exact, source, and source_exact", async () => {