@rotorsoft/act-tck 1.40.0 → 1.41.0

package/dist/index.js

@@ -1099,6 +1099,7 @@ import {
   ConcurrencyError,
   InMemoryCache,
   SNAP_EVENT as SNAP_EVENT2,
+  sensitive,
   sleep,
   state,
   TOMBSTONE_EVENT,
@@ -4546,6 +4547,191 @@ var runStoreTck = (options) => {
         expect8(positions).toEqual([s]);
       });
     });
+    describe8("schema-driven dates on read", () => {
+      const actor2 = { id: "reader", name: "Reader" };
+      const reader = (shape) => {
+        const Happened = z2.object(shape);
+        return state({ Reader: z2.object({ n: z2.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 InMemoryCache();
+        const app = 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: {} };
+      it7("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: z2.date(), label: z2.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]) {
+            expect8(d.at).toBeInstanceOf(Date);
+            expect8(d.at.getTime()).toBe(at.getTime());
+            expect8(d.label).toBe(label);
+          }
+        } finally {
+          await t.done();
+        }
+      });
+      it7("revives a date through every wrapper the rebuild knows", async () => {
+        const S = reader({
+          a: z2.date(),
+          b: z2.date().default(/* @__PURE__ */ new Date(0)),
+          t: z2.tuple([z2.date(), z2.string()]),
+          td: z2.tuple([z2.string(), z2.string()]),
+          r: z2.date().readonly(),
+          c: z2.date().catch(/* @__PURE__ */ new Date(0)),
+          n: z2.date().optional().nonoptional(),
+          p: z2.date().prefault(/* @__PURE__ */ new Date(0)),
+          u: z2.union([z2.date(), z2.string()]),
+          l: z2.array(z2.date()),
+          m: z2.record(z2.string(), z2.date()),
+          o: z2.object({ deep: z2.date() }),
+          x: z2.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"])
+            expect8(d[key], key).toBeInstanceOf(Date);
+          expect8(d.t[0]).toBeInstanceOf(Date);
+          expect8(d.t[1]).toBe("x");
+          expect8(d.td).toEqual(["no", "dates"]);
+          expect8(d.l[0]).toBeInstanceOf(Date);
+          expect8(d.m.k).toBeInstanceOf(Date);
+          expect8(d.o.deep).toBeInstanceOf(Date);
+          expect8(d.x).toBeNull();
+        } finally {
+          await t.done();
+        }
+      });
+      it7("revives dates in a payload that predates the declaration", async () => {
+        const S = reader({ at: z2.date(), label: z2.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();
+          expect8(d.label).toBeUndefined();
+          expect8(d.at).toBeInstanceOf(Date);
+        } finally {
+          await t.done();
+        }
+      });
+      it7("hands back what is stored when a date field holds something else", async () => {
+        const S = reader({ at: z2.date() });
+        const t = await over(S);
+        try {
+          await t.fresh.commit(
+            t.stream,
+            [{ name: "Happened", data: { at: "not a date" } }],
+            raw,
+            -1
+          );
+          expect8((await t.read()).at).toBe("not a date");
+        } finally {
+          await t.done();
+        }
+      });
+      describe8.skipIf(!caps.pii_isolation)("with sensitive fields", () => {
+        it7("reads a redacted payload whose required sensitive field lives in pii", async () => {
+          const S = reader({ at: z2.date(), email: sensitive(z2.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();
+            expect8(d.at).toBeInstanceOf(Date);
+            expect8(d.email).toBe("[REDACTED]");
+            expect8((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();
+          }
+        });
+        it7("keeps a redacted sensitive date's sentinel", async () => {
+          const S = reader({ at: z2.date(), born: sensitive(z2.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();
+            expect8(d.at).toBeInstanceOf(Date);
+            expect8(d.born).toBe("[REDACTED]");
+          } finally {
+            await t.done();
+          }
+        });
+        it7("hands a disclosed sensitive date to the reducer as a Date", async () => {
+          const seen = {};
+          const Happened = z2.object({
+            at: z2.date(),
+            born: sensitive(z2.date())
+          });
+          const S = state({ Disclosed: z2.object({ n: z2.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 });
+            expect8(seen).toEqual({ at: true, born: true });
+          } finally {
+            await t.done();
+          }
+        });
+      });
+    });
     describe8("autoclose end-to-end", () => {
       const Ticket = state({ TckTicket: z2.object({ open: z2.boolean() }) }).init(() => ({ open: false })).emits({
         TckTicketOpened: z2.object({ title: z2.string() }),