@rotorsoft/act-tck 1.3.0 → 1.5.0

package/dist/index.cjs

@@ -1588,8 +1588,7 @@ var runStoreTck = (options) => {
         (0, import_vitest3.expect)(result.duration_ms).toBeGreaterThanOrEqual(0);
         (0, import_vitest3.expect)(result.dropped).toEqual({
           closed_streams: 0,
-          snapshots: 0,
-          empty_streams: 0
+          snapshots: 0
         });
         const events = await collect(store, { limit: 10 });
         (0, import_vitest3.expect)(events).toHaveLength(0);
@@ -1931,6 +1930,153 @@ var runStoreTck = (options) => {
         (0, import_vitest3.expect)(calls).toEqual([1, 2]);
       });
     });
+    import_vitest3.describe.skipIf(!caps.pii_isolation)("pii_isolation (capability)", () => {
+      (0, import_vitest3.it)("commits and loads pii alongside data", async () => {
+        const s = `pii-roundtrip-${uid()}`;
+        const committed = await store.commit(
+          s,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "u@example.com", name: "Ursula" }
+            }
+          ],
+          makeMeta({ stream: s })
+        );
+        (0, import_vitest3.expect)(committed).toHaveLength(1);
+        (0, import_vitest3.expect)(committed[0].pii).toEqual({
+          email: "u@example.com",
+          name: "Ursula"
+        });
+        const seen = [];
+        await store.query(
+          (e) => {
+            seen.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(seen).toHaveLength(1);
+        (0, import_vitest3.expect)(seen[0].pii).toEqual({ email: "u@example.com", name: "Ursula" });
+        (0, import_vitest3.expect)(seen[0].data).toEqual({ amount: 1 });
+      });
+      (0, import_vitest3.it)("passes through events without pii (pii is null or undefined on load)", async () => {
+        const s = `pii-none-${uid()}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const seen = [];
+        await store.query(
+          (e) => {
+            seen.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(seen).toHaveLength(1);
+        (0, import_vitest3.expect)(seen[0].pii == null).toBe(true);
+      });
+      (0, import_vitest3.it)("wipes pii for every event on the stream via forget_pii", async () => {
+        const s = `pii-forget-${uid()}`;
+        await store.commit(
+          s,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "a@example.com" }
+            },
+            {
+              name: "Incremented",
+              data: { amount: 2 },
+              pii: { email: "b@example.com" }
+            }
+          ],
+          makeMeta({ stream: s })
+        );
+        const forget = store.forget_pii;
+        (0, import_vitest3.expect)(forget).toBeDefined();
+        const wiped = await forget.call(store, s);
+        (0, import_vitest3.expect)(wiped).toBe(2);
+        const seen = [];
+        await store.query(
+          (e) => {
+            seen.push(e);
+          },
+          { stream: s, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(seen).toHaveLength(2);
+        for (const e of seen) {
+          (0, import_vitest3.expect)(e.pii == null).toBe(true);
+          (0, import_vitest3.expect)(e.data).toBeDefined();
+        }
+      });
+      (0, import_vitest3.it)("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
+        const s = `pii-forget-idem-${uid()}`;
+        await store.commit(
+          s,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "u@example.com" }
+            }
+          ],
+          makeMeta({ stream: s })
+        );
+        const forget = store.forget_pii;
+        const first = await forget.call(store, s);
+        (0, import_vitest3.expect)(first).toBe(1);
+        const second = await forget.call(store, s);
+        (0, import_vitest3.expect)(second).toBe(0);
+      });
+      (0, import_vitest3.it)("only wipes the targeted stream \u2014 siblings untouched", async () => {
+        const sA = `pii-iso-a-${uid()}`;
+        const sB = `pii-iso-b-${uid()}`;
+        await store.commit(
+          sA,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "alice@example.com" }
+            }
+          ],
+          makeMeta({ stream: sA })
+        );
+        await store.commit(
+          sB,
+          [
+            {
+              name: "Incremented",
+              data: { amount: 1 },
+              pii: { email: "bob@example.com" }
+            }
+          ],
+          makeMeta({ stream: sB })
+        );
+        await store.forget_pii.call(store, sA);
+        const a = [];
+        await store.query(
+          (e) => {
+            a.push(e);
+          },
+          { stream: sA, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(a[0].pii == null).toBe(true);
+        const b = [];
+        await store.query(
+          (e) => {
+            b.push(e);
+          },
+          { stream: sB, stream_exact: true }
+        );
+        (0, import_vitest3.expect)(b[0].pii).toEqual({ email: "bob@example.com" });
+      });
+      (0, import_vitest3.it)("forget_pii on a stream with no pii events returns 0", async () => {
+        const s = `pii-forget-empty-${uid()}`;
+        await store.commit(s, [inc(1)], makeMeta({ stream: s }));
+        const wiped = await store.forget_pii.call(store, s);
+        (0, import_vitest3.expect)(wiped).toBe(0);
+      });
+    });
     if (caps.notify) {
       (0, import_vitest3.describe)("notify (capability)", () => {
         (0, import_vitest3.it)("delivers a notification when a different instance commits", async () => {