@rotorsoft/act-tck 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -235,7 +235,7 @@ var import_vitest3 = require("vitest");
 var runStoreTck = (options) => {
   (0, import_vitest3.describe)(`TCK / Store / ${options.name}`, () => {
     let store;
-    const caps = options.capabilities ?? {};
+    const caps = { ...options.capabilities };
     (0, import_vitest3.beforeAll)(async () => {
       store = await options.factory();
       await store.drop();
@@ -1545,6 +1545,373 @@ var runStoreTck = (options) => {
         }
       });
     });
+    import_vitest3.describe.skipIf(!caps.restore)("restore (capability)", () => {
+      beforeEach(async () => {
+        await store.drop();
+        await store.seed();
+      });
+      const asSource = (events) => (async function* () {
+        for (const e of events) yield e;
+      })();
+      const event = (originalId, stream, version, name, created, data = {}) => ({
+        id: originalId,
+        name,
+        data,
+        stream,
+        version,
+        created,
+        meta: { correlation: "restore-tck", causation: {} }
+      });
+      const restore = async (source, opts = {}) => {
+        const cache = new import_act.InMemoryCache();
+        const app = (0, import_act.act)().build({ scoped: { store, cache } });
+        try {
+          return await app.restore(source, opts);
+        } finally {
+          await cache.dispose();
+        }
+      };
+      (0, import_vitest3.it)("returns kept=0 on an empty source", async () => {
+        const result = await restore(asSource([]));
+        (0, import_vitest3.expect)(result.kept).toBe(0);
+        (0, import_vitest3.expect)(result.duration_ms).toBeGreaterThanOrEqual(0);
+        (0, import_vitest3.expect)(result.dropped).toEqual({
+          closed_streams: 0,
+          snapshots: 0,
+          empty_streams: 0
+        });
+        const events = await collect(store, { limit: 10 });
+        (0, import_vitest3.expect)(events).toHaveLength(0);
+      });
+      (0, import_vitest3.it)("rebuilds a single stream and preserves `created` verbatim", async () => {
+        const s = `restore-single-${uid()}`;
+        const t0 = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
+        const t1 = /* @__PURE__ */ new Date("2020-01-02T00:00:00.000Z");
+        const t2 = /* @__PURE__ */ new Date("2020-01-03T00:00:00.000Z");
+        const events = [
+          event(1, s, 0, "Incremented", t0, { amount: 1 }),
+          event(2, s, 1, "Incremented", t1, { amount: 2 }),
+          event(3, s, 2, "Decremented", t2, { amount: 1 })
+        ];
+        const result = await restore(asSource(events));
+        (0, import_vitest3.expect)(result.kept).toBe(3);
+        const back = [];
+        await store.query(
+          (e) => {
+            back.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(back).toHaveLength(3);
+        (0, import_vitest3.expect)(
+          back.map((e) => ({
+            stream: e.stream,
+            version: e.version,
+            name: e.name,
+            created: e.created.toISOString(),
+            data: e.data
+          }))
+        ).toEqual([
+          {
+            stream: s,
+            version: 0,
+            name: "Incremented",
+            created: t0.toISOString(),
+            data: { amount: 1 }
+          },
+          {
+            stream: s,
+            version: 1,
+            name: "Incremented",
+            created: t1.toISOString(),
+            data: { amount: 2 }
+          },
+          {
+            stream: s,
+            version: 2,
+            name: "Decremented",
+            created: t2.toISOString(),
+            data: { amount: 1 }
+          }
+        ]);
+      });
+      (0, import_vitest3.it)("rebuilds multiple streams interleaved", async () => {
+        const a = `restore-multi-a-${uid()}`;
+        const b = `restore-multi-b-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2020-06-01T00:00:00.000Z");
+        const events = [
+          event(1, a, 0, "Incremented", t, { amount: 10 }),
+          event(2, b, 0, "Incremented", t, { amount: 20 }),
+          event(3, a, 1, "Decremented", t, { amount: 5 }),
+          event(4, b, 1, "Incremented", t, { amount: 30 })
+        ];
+        const result = await restore(asSource(events));
+        (0, import_vitest3.expect)(result.kept).toBe(4);
+        const aBack = [];
+        const bBack = [];
+        await store.query(
+          (e) => {
+            aBack.push(e);
+          },
+          { stream: a, stream_exact: true }
+        );
+        await store.query(
+          (e) => {
+            bBack.push(e);
+          },
+          { stream: b, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(aBack.map((e) => e.version)).toEqual([0, 1]);
+        (0, import_vitest3.expect)(bBack.map((e) => e.version)).toEqual([0, 1]);
+      });
+      (0, import_vitest3.it)("preserves Date `created` verbatim", async () => {
+        const s = `restore-isoc-${uid()}`;
+        const iso = "2021-07-15T12:34:56.789Z";
+        await restore(
+          asSource([
+            {
+              id: 1,
+              stream: s,
+              version: 0,
+              name: "Incremented",
+              data: { amount: 1 },
+              created: new Date(iso),
+              meta: { correlation: "restore-tck", causation: {} }
+            }
+          ])
+        );
+        const back = [];
+        await store.query(
+          (e) => {
+            back.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(back).toHaveLength(1);
+        (0, import_vitest3.expect)(back[0].created.toISOString()).toBe(iso);
+      });
+      (0, import_vitest3.it)("wipes pre-existing events before inserting", async () => {
+        const old = `restore-old-${uid()}`;
+        await store.commit(
+          old,
+          [inc(1), inc(2)],
+          makeMeta({ stream: old })
+        );
+        const fresh = `restore-fresh-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z");
+        await restore(
+          asSource([event(1, fresh, 0, "Incremented", t, { amount: 99 })])
+        );
+        const oldBack = await collect(store, {
+          stream: old,
+          stream_exact: true
+        });
+        (0, import_vitest3.expect)(oldBack).toHaveLength(0);
+        const freshBack = await collect(store, {
+          stream: fresh,
+          stream_exact: true
+        });
+        (0, import_vitest3.expect)(freshBack).toHaveLength(1);
+      });
+      (0, import_vitest3.it)("clears subscription/stream-position metadata", async () => {
+        const sub = `restore-sub-${uid()}`;
+        await store.subscribe([{ stream: sub, source: "anything" }]);
+        const collectStreams = async () => {
+          const out = [];
+          await store.query_streams((p) => {
+            out.push(p.stream);
+          });
+          return out;
+        };
+        const before = await collectStreams();
+        (0, import_vitest3.expect)(before.includes(sub)).toBe(true);
+        await restore(asSource([]));
+        const after = await collectStreams();
+        (0, import_vitest3.expect)(after.includes(sub)).toBe(false);
+      });
+      (0, import_vitest3.it)("preserves snapshot events through restore", async () => {
+        const s = `restore-snap-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2020-04-01T00:00:00.000Z");
+        await restore(
+          asSource([
+            {
+              id: 1,
+              stream: s,
+              version: 0,
+              name: import_act.SNAP_EVENT,
+              data: { count: 42 },
+              created: t,
+              meta: { correlation: "snap", causation: {} }
+            }
+          ])
+        );
+        const back = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true
+        });
+        (0, import_vitest3.expect)(back).toHaveLength(1);
+        (0, import_vitest3.expect)(back[0].name).toBe(import_act.SNAP_EVENT);
+      });
+      (0, import_vitest3.it)("rewrites causation refs through the old\u2192new id map", async () => {
+        const s = `restore-caus-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2020-08-01T00:00:00.000Z");
+        const events = [
+          {
+            id: 5,
+            stream: s,
+            version: 0,
+            name: "Incremented",
+            data: { amount: 1 },
+            created: t,
+            meta: { correlation: "c", causation: {} }
+          },
+          {
+            id: 7,
+            stream: s,
+            version: 1,
+            name: "Incremented",
+            data: { amount: 2 },
+            created: t,
+            meta: {
+              correlation: "c",
+              causation: {
+                event: { id: 5, name: "Incremented", stream: s }
+              }
+            }
+          },
+          {
+            id: 9,
+            stream: s,
+            version: 2,
+            name: "Decremented",
+            data: { amount: 1 },
+            created: t,
+            meta: {
+              correlation: "c",
+              causation: {
+                event: { id: 7, name: "Incremented", stream: s }
+              }
+            }
+          }
+        ];
+        await restore(asSource(events));
+        const back = [];
+        await store.query(
+          (e) => {
+            back.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(back).toHaveLength(3);
+        (0, import_vitest3.expect)(back[0].meta.causation.event).toBeUndefined();
+        (0, import_vitest3.expect)(back[1].meta.causation.event?.id).toBe(back[0].id);
+        (0, import_vitest3.expect)(back[2].meta.causation.event?.id).toBe(back[1].id);
+      });
+      (0, import_vitest3.it)("leaves causation refs unmapped when the target isn't in the source", async () => {
+        const s = `restore-orphan-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2020-09-01T00:00:00.000Z");
+        await restore(
+          asSource([
+            {
+              id: 1,
+              stream: s,
+              version: 0,
+              name: "Incremented",
+              data: { amount: 1 },
+              created: t,
+              meta: {
+                correlation: "c",
+                causation: {
+                  event: { id: 999, name: "Phantom", stream: "ghost" }
+                }
+              }
+            }
+          ])
+        );
+        const back = [];
+        await store.query(
+          (e) => {
+            back.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(back[0].meta.causation.event?.id).toBe(999);
+      });
+      (0, import_vitest3.it)("rolls back atomically when the source throws mid-iteration", async () => {
+        const original = `restore-pre-${uid()}`;
+        const committed = await store.commit(
+          original,
+          [inc(1), inc(2), inc(3)],
+          makeMeta({ stream: original })
+        );
+        const explosive = (async function* () {
+          yield event(
+            1,
+            `restore-explode-${uid()}`,
+            0,
+            "Incremented",
+            /* @__PURE__ */ new Date(),
+            { amount: 1 }
+          );
+          throw new Error("boom");
+        })();
+        await (0, import_vitest3.expect)(restore(explosive)).rejects.toThrow("boom");
+        const back = [];
+        await store.query(
+          (e) => {
+            back.push(e);
+          },
+          { stream: original, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(back).toHaveLength(3);
+        (0, import_vitest3.expect)(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+      });
+      (0, import_vitest3.it)("drop_snapshots: skips SNAP_EVENT rows and counts them", async () => {
+        const s = `restore-drop-snap-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2020-10-01T00:00:00.000Z");
+        const result = await restore(
+          asSource([
+            event(1, s, 0, "Incremented", t, { amount: 1 }),
+            {
+              id: 2,
+              stream: s,
+              version: 1,
+              name: import_act.SNAP_EVENT,
+              data: { count: 1 },
+              created: t,
+              meta: { correlation: "snap", causation: {} }
+            },
+            event(3, s, 2, "Incremented", t, { amount: 2 })
+          ]),
+          { drop_snapshots: true }
+        );
+        (0, import_vitest3.expect)(result.kept).toBe(2);
+        (0, import_vitest3.expect)(result.dropped.snapshots).toBe(1);
+        const back = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true
+        });
+        (0, import_vitest3.expect)(back).toHaveLength(2);
+        (0, import_vitest3.expect)(
+          back.every((e) => e.name !== import_act.SNAP_EVENT)
+        ).toBe(true);
+      });
+      (0, import_vitest3.it)("on_progress fires once per event (caller throttles)", async () => {
+        const calls = [];
+        const s = `restore-progress-${uid()}`;
+        const t = /* @__PURE__ */ new Date("2021-02-01T00:00:00.000Z");
+        await restore(
+          asSource([
+            event(1, s, 0, "Incremented", t, { amount: 1 }),
+            event(2, s, 1, "Incremented", t, { amount: 2 })
+          ]),
+          { on_progress: (p) => calls.push(p.processed) }
+        );
+        (0, import_vitest3.expect)(calls).toEqual([1, 2]);
+      });
+    });
     if (caps.notify) {
       (0, import_vitest3.describe)("notify (capability)", () => {
         (0, import_vitest3.it)("delivers a notification when a different instance commits", async () => {