@rotorsoft/act-tck 1.40.0 → 1.41.1

package/dist/@types/store-tck.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAQV,KAAK,EAIN,MAAM,sBAAsB,CAAC;AAe9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,gCAAgC,CAAC,EAAE,OAAO,CAAC;IACpD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACxD;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,YAAa,eAAe,KAAG,IAmiLtD,CAAC"}
+{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAUV,KAAK,EAIN,MAAM,sBAAsB,CAAC;AAe9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC;;;;;;;;OAQG;IACH,QAAQ,CAAC,gCAAgC,CAAC,EAAE,OAAO,CAAC;IACpD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACxD;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW,YAAa,eAAe,KAAG,IAiwLtD,CAAC"}

package/dist/index.cjs

@@ -4591,6 +4591,191 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(positions).toEqual([s]);
       });
     });
+    (0, import_vitest9.describe)("schema-driven dates on read", () => {
+      const actor2 = { id: "reader", name: "Reader" };
+      const reader = (shape) => {
+        const Happened = import_zod2.z.object(shape);
+        return (0, import_act2.state)({ Reader: import_zod2.z.object({ n: import_zod2.z.number() }) }).init(() => ({ n: 0 })).emits({ Happened }).patch({ Happened: (_, s) => ({ n: s.n + 1 }) }).on({ Do: Happened }).emit((p) => ["Happened", p]).build();
+      };
+      const over = async (S) => {
+        const fresh = await options.factory();
+        await fresh.seed();
+        const cache = new import_act2.InMemoryCache();
+        const app = (0, import_act2.act)().withState(S).build({ scoped: { store: fresh, cache } });
+        const stream = `dt-${uid()}`;
+        const read = async () => (await app.query_array({ stream, stream_exact: true }))[0].data;
+        const done = async () => {
+          await app.shutdown();
+          await cache.dispose();
+          await fresh.dispose();
+        };
+        return { app, fresh, cache, stream, read, done };
+      };
+      const raw = { correlation: "c", causation: {} };
+      (0, import_vitest9.it)("types z.date() and leaves an ISO-shaped z.string() alone, warm and cold", async () => {
+        const at = /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+        const label = "2026-06-06T00:00:00.000Z";
+        const S = reader({ at: import_zod2.z.date(), label: import_zod2.z.string() });
+        const t = await over(S);
+        try {
+          await t.app.do("Do", { stream: t.stream, actor: actor2 }, { at, label });
+          const warm = await t.read();
+          await t.cache.clear();
+          const cold = await t.read();
+          for (const d of [warm, cold]) {
+            (0, import_vitest9.expect)(d.at).toBeInstanceOf(Date);
+            (0, import_vitest9.expect)(d.at.getTime()).toBe(at.getTime());
+            (0, import_vitest9.expect)(d.label).toBe(label);
+          }
+        } finally {
+          await t.done();
+        }
+      });
+      (0, import_vitest9.it)("revives a date through every wrapper the rebuild knows", async () => {
+        const S = reader({
+          a: import_zod2.z.date(),
+          b: import_zod2.z.date().default(/* @__PURE__ */ new Date(0)),
+          t: import_zod2.z.tuple([import_zod2.z.date(), import_zod2.z.string()]),
+          td: import_zod2.z.tuple([import_zod2.z.string(), import_zod2.z.string()]),
+          r: import_zod2.z.date().readonly(),
+          c: import_zod2.z.date().catch(/* @__PURE__ */ new Date(0)),
+          n: import_zod2.z.date().optional().nonoptional(),
+          p: import_zod2.z.date().prefault(/* @__PURE__ */ new Date(0)),
+          u: import_zod2.z.union([import_zod2.z.date(), import_zod2.z.string()]),
+          l: import_zod2.z.array(import_zod2.z.date()),
+          m: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.date()),
+          o: import_zod2.z.object({ deep: import_zod2.z.date() }),
+          x: import_zod2.z.date().nullable()
+        });
+        const t = await over(S);
+        try {
+          const when = /* @__PURE__ */ new Date("2022-01-01");
+          await t.app.do(
+            "Do",
+            { stream: t.stream, actor: actor2 },
+            {
+              a: /* @__PURE__ */ new Date("2020-01-01"),
+              b: /* @__PURE__ */ new Date("2021-01-01"),
+              t: [when, "x"],
+              td: ["no", "dates"],
+              r: when,
+              c: when,
+              n: when,
+              p: when,
+              u: when,
+              l: [when],
+              m: { k: when },
+              o: { deep: when },
+              x: null
+            }
+          );
+          const d = await t.read();
+          for (const key of ["a", "b", "r", "c", "n", "p", "u"])
+            (0, import_vitest9.expect)(d[key], key).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.t[0]).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.t[1]).toBe("x");
+          (0, import_vitest9.expect)(d.td).toEqual(["no", "dates"]);
+          (0, import_vitest9.expect)(d.l[0]).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.m.k).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.o.deep).toBeInstanceOf(Date);
+          (0, import_vitest9.expect)(d.x).toBeNull();
+        } finally {
+          await t.done();
+        }
+      });
+      (0, import_vitest9.it)("revives dates in a payload that predates the declaration", async () => {
+        const S = reader({ at: import_zod2.z.date(), label: import_zod2.z.string() });
+        const t = await over(S);
+        try {
+          await t.fresh.commit(
+            t.stream,
+            [{ name: "Happened", data: { at: /* @__PURE__ */ new Date("2020-01-01") } }],
+            raw,
+            -1
+          );
+          const d = await t.read();
+          (0, import_vitest9.expect)(d.label).toBeUndefined();
+          (0, import_vitest9.expect)(d.at).toBeInstanceOf(Date);
+        } finally {
+          await t.done();
+        }
+      });
+      (0, import_vitest9.it)("hands back what is stored when a date field holds something else", async () => {
+        const S = reader({ at: import_zod2.z.date() });
+        const t = await over(S);
+        try {
+          await t.fresh.commit(
+            t.stream,
+            [{ name: "Happened", data: { at: "not a date" } }],
+            raw,
+            -1
+          );
+          (0, import_vitest9.expect)((await t.read()).at).toBe("not a date");
+        } finally {
+          await t.done();
+        }
+      });
+      import_vitest9.describe.skipIf(!caps.pii_isolation)("with sensitive fields", () => {
+        (0, import_vitest9.it)("reads a redacted payload whose required sensitive field lives in pii", async () => {
+          const S = reader({ at: import_zod2.z.date(), email: (0, import_act2.sensitive)(import_zod2.z.string()) });
+          const t = await over(S);
+          try {
+            const target = { stream: t.stream, actor: actor2 };
+            await t.app.do("Do", target, { at: /* @__PURE__ */ new Date(0), email: "u@x.io" });
+            const d = await t.read();
+            (0, import_vitest9.expect)(d.at).toBeInstanceOf(Date);
+            (0, import_vitest9.expect)(d.email).toBe("[REDACTED]");
+            (0, import_vitest9.expect)((await t.app.load(S, t.stream)).state.n).toBe(1);
+            await t.app.do("Do", target, { at: /* @__PURE__ */ new Date(1), email: "v@x.io" });
+          } finally {
+            await t.done();
+          }
+        });
+        (0, import_vitest9.it)("keeps a redacted sensitive date's sentinel", async () => {
+          const S = reader({ at: import_zod2.z.date(), born: (0, import_act2.sensitive)(import_zod2.z.date()) });
+          const t = await over(S);
+          try {
+            await t.app.do(
+              "Do",
+              { stream: t.stream, actor: actor2 },
+              { at: /* @__PURE__ */ new Date(0), born: /* @__PURE__ */ new Date(1) }
+            );
+            const d = await t.read();
+            (0, import_vitest9.expect)(d.at).toBeInstanceOf(Date);
+            (0, import_vitest9.expect)(d.born).toBe("[REDACTED]");
+          } finally {
+            await t.done();
+          }
+        });
+        (0, import_vitest9.it)("hands a disclosed sensitive date to the reducer as a Date", async () => {
+          const seen = {};
+          const Happened = import_zod2.z.object({
+            at: import_zod2.z.date(),
+            born: (0, import_act2.sensitive)(import_zod2.z.date())
+          });
+          const S = (0, import_act2.state)({ Disclosed: import_zod2.z.object({ n: import_zod2.z.number() }) }).init(() => ({ n: 0 })).emits({ Happened }).patch({
+            Happened: ({ data }, s) => {
+              seen.at = data.at instanceof Date;
+              seen.born = data.born instanceof Date;
+              return { n: s.n + 1 };
+            }
+          }).on({ Do: Happened }).emit((p) => ["Happened", p]).discloses(() => true).build();
+          const t = await over(S);
+          try {
+            await t.app.do(
+              "Do",
+              { stream: t.stream, actor: actor2 },
+              { at: /* @__PURE__ */ new Date(0), born: /* @__PURE__ */ new Date(1) }
+            );
+            await t.cache.clear();
+            await t.app.load(S, { stream: t.stream, actor: actor2 });
+            (0, import_vitest9.expect)(seen).toEqual({ at: true, born: true });
+          } finally {
+            await t.done();
+          }
+        });
+      });
+    });
     (0, import_vitest9.describe)("autoclose end-to-end", () => {
       const Ticket = (0, import_act2.state)({ TckTicket: import_zod2.z.object({ open: import_zod2.z.boolean() }) }).init(() => ({ open: false })).emits({
         TckTicketOpened: import_zod2.z.object({ title: import_zod2.z.string() }),