@rotorsoft/act-tck 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/cache-tck.ts
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach as beforeEach2, describe, expect, it } from "vitest";
 var entry = (event_id, state = {}) => ({
   state,
   version: event_id,
@@ -10,7 +10,7 @@ var entry = (event_id, state = {}) => ({
 var runCacheTck = (options) => {
   describe(`TCK / Cache / ${options.name}`, () => {
     let cache;
-    beforeEach(() => {
+    beforeEach2(() => {
       cache = options.factory();
     });
     afterEach(async () => {
@@ -129,13 +129,13 @@ var collect = async (store, query) => {
 };
 
 // src/logger-tck.ts
-import { afterEach as afterEach2, beforeEach as beforeEach2, describe as describe2, expect as expect2, it as it2 } from "vitest";
+import { afterEach as afterEach2, beforeEach as beforeEach3, describe as describe2, expect as expect2, it as it2 } from "vitest";
 var LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
 var runLoggerTck = (options) => {
   describe2(`TCK / Logger / ${options.name}`, () => {
     let logger;
     let originalStdout;
-    beforeEach2(() => {
+    beforeEach3(() => {
       logger = options.factory();
       originalStdout = process.stdout.write.bind(process.stdout);
       process.stdout.write = (() => true);
@@ -189,12 +189,18 @@ var runLoggerTck = (options) => {
 };
 
 // src/store-tck.ts
-import { ConcurrencyError, SNAP_EVENT, TOMBSTONE_EVENT } from "@rotorsoft/act";
+import {
+  act,
+  ConcurrencyError,
+  InMemoryCache,
+  SNAP_EVENT,
+  TOMBSTONE_EVENT
+} from "@rotorsoft/act";
 import { afterAll, beforeAll, describe as describe3, expect as expect3, it as it3 } from "vitest";
 var runStoreTck = (options) => {
   describe3(`TCK / Store / ${options.name}`, () => {
     let store;
-    const caps = options.capabilities ?? {};
+    const caps = { ...options.capabilities };
     beforeAll(async () => {
       store = await options.factory();
       await store.drop();
@@ -1504,6 +1510,373 @@ var runStoreTck = (options) => {
         }
       });
     });
+    describe3.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 InMemoryCache();
+        const app = act().build({ scoped: { store, cache } });
+        try {
+          return await app.restore(source, opts);
+        } finally {
+          await cache.dispose();
+        }
+      };
+      it3("returns kept=0 on an empty source", async () => {
+        const result = await restore(asSource([]));
+        expect3(result.kept).toBe(0);
+        expect3(result.duration_ms).toBeGreaterThanOrEqual(0);
+        expect3(result.dropped).toEqual({
+          closed_streams: 0,
+          snapshots: 0,
+          empty_streams: 0
+        });
+        const events = await collect(store, { limit: 10 });
+        expect3(events).toHaveLength(0);
+      });
+      it3("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));
+        expect3(result.kept).toBe(3);
+        const back = [];
+        await store.query(
+          (e) => {
+            back.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        expect3(back).toHaveLength(3);
+        expect3(
+          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 }
+          }
+        ]);
+      });
+      it3("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));
+        expect3(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 }
+        );
+        expect3(aBack.map((e) => e.version)).toEqual([0, 1]);
+        expect3(bBack.map((e) => e.version)).toEqual([0, 1]);
+      });
+      it3("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 }
+        );
+        expect3(back).toHaveLength(1);
+        expect3(back[0].created.toISOString()).toBe(iso);
+      });
+      it3("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
+        });
+        expect3(oldBack).toHaveLength(0);
+        const freshBack = await collect(store, {
+          stream: fresh,
+          stream_exact: true
+        });
+        expect3(freshBack).toHaveLength(1);
+      });
+      it3("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();
+        expect3(before.includes(sub)).toBe(true);
+        await restore(asSource([]));
+        const after = await collectStreams();
+        expect3(after.includes(sub)).toBe(false);
+      });
+      it3("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: SNAP_EVENT,
+              data: { count: 42 },
+              created: t,
+              meta: { correlation: "snap", causation: {} }
+            }
+          ])
+        );
+        const back = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true
+        });
+        expect3(back).toHaveLength(1);
+        expect3(back[0].name).toBe(SNAP_EVENT);
+      });
+      it3("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 }
+        );
+        expect3(back).toHaveLength(3);
+        expect3(back[0].meta.causation.event).toBeUndefined();
+        expect3(back[1].meta.causation.event?.id).toBe(back[0].id);
+        expect3(back[2].meta.causation.event?.id).toBe(back[1].id);
+      });
+      it3("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 }
+        );
+        expect3(back[0].meta.causation.event?.id).toBe(999);
+      });
+      it3("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 expect3(restore(explosive)).rejects.toThrow("boom");
+        const back = [];
+        await store.query(
+          (e) => {
+            back.push(e);
+          },
+          { stream: original, stream_exact: true }
+        );
+        expect3(back).toHaveLength(3);
+        expect3(back.map((e) => e.id)).toEqual(committed.map((c) => c.id));
+      });
+      it3("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: SNAP_EVENT,
+              data: { count: 1 },
+              created: t,
+              meta: { correlation: "snap", causation: {} }
+            },
+            event(3, s, 2, "Incremented", t, { amount: 2 })
+          ]),
+          { drop_snapshots: true }
+        );
+        expect3(result.kept).toBe(2);
+        expect3(result.dropped.snapshots).toBe(1);
+        const back = await collect(store, {
+          stream: s,
+          stream_exact: true,
+          with_snaps: true
+        });
+        expect3(back).toHaveLength(2);
+        expect3(
+          back.every((e) => e.name !== SNAP_EVENT)
+        ).toBe(true);
+      });
+      it3("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) }
+        );
+        expect3(calls).toEqual([1, 2]);
+      });
+    });
     if (caps.notify) {
       describe3("notify (capability)", () => {
         it3("delivers a notification when a different instance commits", async () => {