@reventlessdev/reventless-local 3.0.0-alpha.311 → 3.0.0-alpha.313

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePiiTest.res

@@ -0,0 +1,160 @@
+// An outbound work item that carries personal data is stored as an event is: its
+// marked fields sealed, its row keyed by a fingerprint of the key `collect`
+// chose, opened before it is translated, and completed without a call once its
+// subject is erased.
+
+open JestGlobals
+
+let sent: ref<array<string>> = ref([])
+
+module VerifySpec = {
+  let name = "VerifyAddress"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type consumedEvent = AddressGiven({customerId: string, email: string})
+
+  @schema
+  type outboundItem = {
+    customerId: string,
+    email: @s.matches(Reventless.Pii.mark(~subject="customerId", S.string)) string,
+  }
+
+  @schema
+  type inboundCommand = unit
+
+  // Keyed by the address, as the shop's translations are: a change is new work.
+  let collect = (event, ~sourceId as _) =>
+    switch event {
+    | AddressGiven({customerId, email}) => [(`${customerId}:${email}`, {customerId, email})]
+    }
+
+  let translate = async (_id, item: outboundItem, ~capabilities as _) => {
+    sent := sent.contents->Array.concat([item.email])
+    Ok(None)
+  }
+  let onExhausted = (_id, _item, ~lastError as _) => None
+
+  let maxRetries = 3
+  let targetName = None
+  let sourceNames: array<string> = []
+  let externalSystem = None
+  let capabilityNeeds: array<Reventless.CapabilityNeed.t> = []
+  let traits: array<Reventless.Trait.t> = []
+}
+module VerifyTranslation = {
+  let collect = VerifySpec.collect
+  let translate = VerifySpec.translate
+  let onExhausted = VerifySpec.onExhausted
+  let moduleUrl = VerifySpec.moduleUrl
+}
+module Callback = ReventlessCore.OutboundTranslationSlice_Callback.Make(
+  VerifySpec,
+  VerifyTranslation,
+)
+
+let toBase64 = (s: string) =>
+  NodeCrypto.bufferFromString(s, "utf8")->NodeCrypto.bufferToString("base64")
+let fromBase64 = (s: string) =>
+  NodeCrypto.bufferFromString(s, "base64")->NodeCrypto.bufferToString("utf8")
+
+/** "Encrypts" by base64; `erased` makes every key gone, as an erasure does. */
+let erased = ref(false)
+let provider: Reventless.Pii.provider = {
+  name: "fake",
+  encrypts: true,
+  seal: async (~subject, ~field as _, ~forgettable as _, json) => Ok(
+    Reventless.Pii.wrap(`enc:v1:${subject}:fake:${json->JSON.stringify->toBase64}`),
+  ),
+  prefetch: async _ => Ok(),
+  openNow: (~field, json) =>
+    switch json->Reventless.Pii.unwrap->Option.flatMap(Reventless.Pii.parseStored) {
+    | Some(Cipher(_)) if erased.contents => Ok(Reventless.Pii.wrap(Reventless.Pii.erasedMarker))
+    | Some(Cipher({bytes})) => Ok(bytes->fromBase64->JSON.parseOrThrow)
+    | _ => Error(Reventless.Pii.UnknownForm({field: field}))
+    },
+  release: async (~subject as _, ~ref as _) => Ok(),
+}
+
+let keyed: Reventless.Capabilities.t = {
+  ...Reventless.Capabilities.none,
+  secrets: Reventless.Secrets.fixed(
+    ~token="t",
+    ~hash=s => s,
+    ~fingerprint=(~purpose, input) =>
+      `fp(${purpose})#${input->toBase64->String.length->Int.toString}`,
+  ),
+}
+
+let given = VerifySpec.AddressGiven({customerId: "c-1", email: "ada@example.org"})
+let rows = () => Callback.todoItems->Dict.toArray
+let publish: ReventlessInfra.CommandTopic.publishJsons = async _ => ()
+
+@val external env: dict<string> = "process.env"
+
+describe("an outbound work item with personal data", () => {
+  beforeEach(() => {
+    Callback.todoItems->Dict.keysToArray->Array.forEach(k => Callback.todoItems->Dict.delete(k))
+    sent := []
+    erased := false
+    Reventless.Pii.Provider.install(provider)
+  })
+  afterEach(() => {
+    Reventless.Pii.Provider.install(Reventless.Pii.plain)
+    env->Dict.delete("REVENTLESS_PII_REQUIRE_ENCRYPTION")
+  })
+
+  testPromise("is stored sealed, under a key that holds no address", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    let stored = rows()->JSON.stringifyAny->Option.getOr("")
+    expect(stored->String.includes("ada@example.org"))->toBe(false)
+    switch rows() {
+    | [(id, row)] =>
+      expect(id->String.startsWith("fp(outboundWorkItem:VerifyAddress)"))->toBe(true)
+      // A sealed string stays a string, so the work list still serves it as one.
+      let email = row.item->JSON.Decode.object->Option.flatMap(d => d->Dict.get("email"))
+      expect(
+        email
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.mapOr(false, s => s->String.startsWith("enc:v1:c-1:")),
+      )->toBe(true)
+    | _ => fail("expected one row")
+    }
+  })
+
+  testPromise("is collected once, however often its event arrives", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    expect(rows()->Array.length)->toBe(1)
+  })
+
+  testPromise("is opened before it is translated", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    await Callback.phase2(publish, ~capabilities=keyed)
+    expect(sent.contents)->toEqual(["ada@example.org"])
+  })
+
+  testPromise("is completed without a call once its subject is erased", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=keyed)
+    erased := true
+    await Callback.phase2(publish, ~capabilities=keyed)
+    expect(sent.contents)->toEqual([])
+    expect(rows()->Array.map(((_, row)) => row.status))->toEqual([
+      ReventlessCore.OutboundTranslationSlice_Callback.Completed,
+    ])
+  })
+
+  testPromise("keeps the key it was given where nothing can fingerprint it", async () => {
+    await Callback.phase1([("c-1", given)], ~capabilities=Reventless.Capabilities.none)
+    expect(rows()->Array.map(Pair.first))->toEqual(["c-1:ada@example.org"])
+  })
+
+  testPromise(
+    "is not stored at all where encryption is required and nothing can fingerprint it",
+    async () => {
+      env->Dict.set("REVENTLESS_PII_REQUIRE_ENCRYPTION", "true")
+      await Callback.phase1([("c-1", given)], ~capabilities=Reventless.Capabilities.none)
+      expect(rows())->toEqual([])
+    },
+  )
+})

package/tests/components/outboundtranslationslice/OutboundTranslationSlicePiiTest.res.mjs

@@ -0,0 +1,300 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Nodebuffer from "node:buffer";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pii$Reventless from "@reventlessdev/reventless-spec/src/components/Pii.res.mjs";
+import * as Secrets$Reventless from "@reventlessdev/reventless-spec/src/semantic/Secrets.res.mjs";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
+import * as OutboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
+
+let sent = {
+  contents: []
+};
+
+let name = "VerifyAddress";
+
+let moduleUrl = import.meta.url;
+
+let consumedEventSchema = Sury.$schema(s => ({
+  TAG: "AddressGiven",
+  customerId: s.m(Sury.string),
+  email: s.m(Sury.string)
+}));
+
+let outboundItemSchema = Sury.$schema(s => ({
+  customerId: s.m(Sury.string),
+  email: s.m(Pii$Reventless.mark("customerId", undefined, Sury.string))
+}));
+
+let inboundCommandSchema = Sury.$unit;
+
+function collect(event, param) {
+  let email = event.email;
+  let customerId = event.customerId;
+  return [[
+      customerId + `:` + email,
+      {
+        customerId: customerId,
+        email: email
+      }
+    ]];
+}
+
+async function translate(_id, item, param) {
+  sent.contents = sent.contents.concat([item.email]);
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+function onExhausted(_id, _item, param) {
+  
+}
+
+let sourceNames = [];
+
+let capabilityNeeds = [];
+
+let traits = [];
+
+let VerifySpec = {
+  name: name,
+  moduleUrl: moduleUrl,
+  consumedEventSchema: consumedEventSchema,
+  outboundItemSchema: outboundItemSchema,
+  inboundCommandSchema: inboundCommandSchema,
+  collect: collect,
+  translate: translate,
+  onExhausted: onExhausted,
+  maxRetries: 3,
+  targetName: undefined,
+  sourceNames: sourceNames,
+  externalSystem: undefined,
+  capabilityNeeds: capabilityNeeds,
+  traits: traits
+};
+
+let VerifyTranslation = {
+  collect: collect,
+  translate: translate,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl
+};
+
+let Callback = OutboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  consumedEventSchema: consumedEventSchema,
+  outboundItemSchema: outboundItemSchema,
+  inboundCommandSchema: inboundCommandSchema,
+  maxRetries: 3,
+  targetName: undefined,
+  sourceNames: sourceNames,
+  externalSystem: undefined,
+  capabilityNeeds: capabilityNeeds,
+  traits: traits
+})(VerifyTranslation);
+
+function toBase64(s) {
+  return Nodebuffer.Buffer.from(s, "utf8").toString("base64");
+}
+
+function fromBase64(s) {
+  return Nodebuffer.Buffer.from(s, "base64").toString("utf8");
+}
+
+let erased = {
+  contents: false
+};
+
+async function provider_seal(subject, param, param$1, json) {
+  return {
+    TAG: "Ok",
+    _0: Pii$Reventless.wrap(`enc:v1:` + subject + `:fake:` + toBase64(JSON.stringify(json)))
+  };
+}
+
+async function provider_prefetch(param) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+function provider_openNow(field, json) {
+  let match = Stdlib_Option.flatMap(Pii$Reventless.unwrap(json), Pii$Reventless.parseStored);
+  if (match === undefined) {
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "UnknownForm",
+        field: field
+      }
+    };
+  }
+  switch (match.TAG) {
+    case "Cipher" :
+      if (erased.contents) {
+        return {
+          TAG: "Ok",
+          _0: Pii$Reventless.wrap(Pii$Reventless.erasedMarker)
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: JSON.parse(fromBase64(match.bytes))
+        };
+      }
+    case "ErasedForm" :
+    case "ForgottenForm" :
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnknownForm",
+          field: field
+        }
+      };
+  }
+}
+
+async function provider_release(param, param$1) {
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+let provider = {
+  name: "fake",
+  encrypts: true,
+  seal: provider_seal,
+  prefetch: provider_prefetch,
+  openNow: provider_openNow,
+  release: provider_release
+};
+
+let keyed_geocode = Capabilities$Reventless.none.geocode;
+
+let keyed_messaging = Capabilities$Reventless.none.messaging;
+
+let keyed_identityProvider = Capabilities$Reventless.none.identityProvider;
+
+let keyed_secrets = Secrets$Reventless.fixed("t", s => s, (purpose, input) => `fp(` + purpose + `)#` + toBase64(input).length.toString());
+
+let keyed_stash = Capabilities$Reventless.none.stash;
+
+let keyed = {
+  geocode: keyed_geocode,
+  messaging: keyed_messaging,
+  identityProvider: keyed_identityProvider,
+  secrets: keyed_secrets,
+  stash: keyed_stash
+};
+
+let given = {
+  TAG: "AddressGiven",
+  customerId: "c-1",
+  email: "ada@example.org"
+};
+
+function rows() {
+  return Object.entries(Callback.todoItems);
+}
+
+async function publish(param) {
+  
+}
+
+globalThis.describe("an outbound work item with personal data", () => {
+  globalThis.beforeEach(() => {
+    Object.keys(Callback.todoItems).forEach(k => Stdlib_Dict.$$delete(Callback.todoItems, k));
+    sent.contents = [];
+    erased.contents = false;
+    Pii$Reventless.Provider.install(provider);
+  });
+  globalThis.afterEach(() => {
+    Pii$Reventless.Provider.install(Pii$Reventless.plain);
+    Stdlib_Dict.$$delete(process.env, "REVENTLESS_PII_REQUIRE_ENCRYPTION");
+  });
+  globalThis.test("is stored sealed, under a key that holds no address", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    let stored = Stdlib_Option.getOr(JSON.stringify(Object.entries(Callback.todoItems)), "");
+    globalThis.expect(stored.includes("ada@example.org")).toBe(false);
+    let match = Object.entries(Callback.todoItems);
+    if (match.length !== 1) {
+      return JestGlobals.fail("expected one row");
+    }
+    let match$1 = match[0];
+    globalThis.expect(match$1[0].startsWith("fp(outboundWorkItem:VerifyAddress)")).toBe(true);
+    let email = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(match$1[1].item), d => d["email"]);
+    globalThis.expect(Stdlib_Option.mapOr(Stdlib_Option.flatMap(email, Stdlib_JSON.Decode.string), false, s => s.startsWith("enc:v1:c-1:"))).toBe(true);
+  });
+  globalThis.test("is collected once, however often its event arrives", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    globalThis.expect(Object.entries(Callback.todoItems).length).toBe(1);
+  });
+  globalThis.test("is opened before it is translated", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    await Callback.phase2(publish, keyed);
+    globalThis.expect(sent.contents).toEqual(["ada@example.org"]);
+  });
+  globalThis.test("is completed without a call once its subject is erased", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], keyed);
+    erased.contents = true;
+    await Callback.phase2(publish, keyed);
+    globalThis.expect(sent.contents).toEqual([]);
+    globalThis.expect(Object.entries(Callback.todoItems).map(param => param[1].status)).toEqual(["Completed"]);
+  });
+  globalThis.test("keeps the key it was given where nothing can fingerprint it", async () => {
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], Capabilities$Reventless.none);
+    globalThis.expect(Object.entries(Callback.todoItems).map(prim => prim[0])).toEqual(["c-1:ada@example.org"]);
+  });
+  globalThis.test("is not stored at all where encryption is required and nothing can fingerprint it", async () => {
+    process.env["REVENTLESS_PII_REQUIRE_ENCRYPTION"] = "true";
+    await Callback.phase1([[
+        "c-1",
+        given
+      ]], Capabilities$Reventless.none);
+    globalThis.expect(Object.entries(Callback.todoItems)).toEqual([]);
+  });
+});
+
+export {
+  sent,
+  VerifySpec,
+  VerifyTranslation,
+  Callback,
+  toBase64,
+  fromBase64,
+  erased,
+  provider,
+  keyed,
+  given,
+  rows,
+  publish,
+}
+/* moduleUrl Not a pure module */