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

package/tests/components/automationslice/AutomationSlicePiiTest.res

@@ -0,0 +1,178 @@
+// An automation's 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 the mapping
+// chose, that key sealed inside the item for `process` and `resolve`, and an item
+// whose subject was erased completed without processing.
+
+open JestGlobals
+
+module Source = {
+  module Id = Reventless.Id.String
+  let name = "GreetDcbEventLog"
+  @schema
+  type event =
+    | MemberJoined({memberId: @s.matches(Reventless.DcbTag.string) string, email: string})
+    | MemberGreeted({memberId: @s.matches(Reventless.DcbTag.string) string, email: string})
+}
+
+module Spec = {
+  let name = "GreetMember"
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type todoItem = {
+    memberId: string,
+    email: @s.matches(Reventless.Pii.mark(~subject="memberId", S.string)) string,
+  }
+
+  @schema
+  type command = SendGreeting({memberId: @s.matches(Reventless.DcbTag.string) string, key: string})
+
+  let maxRetries = 3
+  let targetName = "SendGreeting"
+  let schedule = None
+}
+
+// Keyed by the address, as a translation keyed by contact would be.
+module Mapping = Reventless.AutomationSlice.Mapping.Make(
+  Source,
+  Spec,
+  {
+    let collect = (event: Source.event, ~sourceId as _, _ctx) =>
+      switch event {
+      | MemberJoined({memberId, email}) => [
+          (`${memberId}:${email}`, ({memberId, email}: Spec.todoItem)),
+        ]
+      | MemberGreeted(_) => []
+      }
+    let resolve = (event: Source.event) =>
+      switch event {
+      | MemberGreeted({memberId, email}) => Some(`${memberId}:${email}`)
+      | MemberJoined(_) => None
+      }
+    let reschedule = _ => []
+  },
+)
+
+let processed: ref<array<(string, string)>> = ref([])
+
+module Automation: Reventless.AutomationSlice.Automation with module Spec := Spec = {
+  let process = (key, item: Spec.todoItem, ~now as _) => {
+    processed := processed.contents->Array.concat([(key, item.email)])
+    Some((item.memberId, Spec.SendGreeting({memberId: item.memberId, key})))
+  }
+  let onExhausted = (_id, _item: Spec.todoItem) => None
+  let moduleUrl: string = %raw(`import.meta.url`)
+  module M = Reventless.AutomationSlice.Mappings.Make(Spec)
+  module type Mapping = M.Mapping
+  let mappings: array<module(Mapping)> = [module(Mapping)]
+}
+
+module Callback = ReventlessCore.AutomationSlice_Callback.Make(Spec, Automation)
+
+let context: Reventless.AutomationSlice.context = {
+  environment: "test",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: "GreetMember",
+}
+
+let envelope = (event: Source.event) =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      ("id", JSON.Encode.string("m-1")),
+      (
+        "meta",
+        ReventlessCore.Message.generateMeta(~service=Source.name)->Reventless.Util_Sury.toJson(
+          Reventless.Message.metaSchema,
+        ),
+      ),
+      ("event", event->Reventless.Util_Sury.toJson(Source.eventSchema)),
+    ]),
+  )
+
+let toBase64 = (s: string) =>
+  NodeCrypto.bufferFromString(s, "utf8")->NodeCrypto.bufferToString("base64")
+let fromBase64 = (s: string) =>
+  NodeCrypto.bufferFromString(s, "base64")->NodeCrypto.bufferToString("utf8")
+
+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 joined = Source.MemberJoined({memberId: "m-1", email: "ada@example.org"})
+let greeted = Source.MemberGreeted({memberId: "m-1", email: "ada@example.org"})
+let rows = () => Callback.todoItems->Dict.toArray
+let published: ref<array<Reventless.Message.commandJson>> = ref([])
+let publish: ReventlessInfra.CommandTopic.publishJsons = async msgs => {
+  published := published.contents->Array.concat(msgs)
+}
+
+describe("an automation's work item with personal data", () => {
+  beforeEach(() => {
+    Callback.todoItems->Dict.keysToArray->Array.forEach(k => Callback.todoItems->Dict.delete(k))
+    processed := []
+    published := []
+    erased := false
+    Reventless.Pii.Provider.install(provider)
+  })
+  afterEach(() => Reventless.Pii.Provider.install(Reventless.Pii.plain))
+
+  testPromise("is stored sealed, under a key that holds no address", async () => {
+    await Callback.phase1([envelope(joined)], context, ~capabilities=keyed)
+    expect(rows()->JSON.stringifyAny->Option.getOr("")->String.includes("ada@example.org"))->toBe(
+      false,
+    )
+    expect(
+      rows()->Array.every(((id, _)) => id->String.startsWith("fp(automationWorkItem:GreetMember)")),
+    )->toBe(true)
+    expect(rows()->Array.length)->toBe(1)
+  })
+
+  testPromise("is processed with the key and the value it was collected with", async () => {
+    await Callback.phase1([envelope(joined)], context, ~capabilities=keyed)
+    await Callback.phase2(publish)
+    expect(processed.contents)->toEqual([("m-1:ada@example.org", "ada@example.org")])
+    expect(published.contents->Array.length)->toBe(1)
+  })
+
+  testPromise("is resolved by the key the mapping chose", async () => {
+    await Callback.phase1([envelope(joined)], context, ~capabilities=keyed)
+    await Callback.phase1([envelope(greeted)], context, ~capabilities=keyed)
+    expect(rows()->Array.map(((_, row)) => row.status))->toEqual([
+      ReventlessCore.AutomationSlice_Callback.Completed,
+    ])
+  })
+
+  testPromise("is completed without processing once its subject is erased", async () => {
+    await Callback.phase1([envelope(joined)], context, ~capabilities=keyed)
+    erased := true
+    await Callback.phase2(publish)
+    expect(processed.contents)->toEqual([])
+    expect(rows()->Array.map(((_, row)) => row.status))->toEqual([
+      ReventlessCore.AutomationSlice_Callback.Completed,
+    ])
+  })
+})

package/tests/components/automationslice/AutomationSlicePiiTest.res.mjs

@@ -0,0 +1,352 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Nodebuffer from "node:buffer";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+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 DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Secrets$Reventless from "@reventlessdev/reventless-spec/src/semantic/Secrets.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Capabilities$Reventless from "@reventlessdev/reventless-spec/src/semantic/Capabilities.res.mjs";
+import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
+import * as AutomationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
+
+let name = "GreetDcbEventLog";
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "MemberJoined",
+    memberId: s.m(DcbTag$Reventless.string),
+    email: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "MemberGreeted",
+    memberId: s.m(DcbTag$Reventless.string),
+    email: s.m(Sury.string)
+  }))
+]);
+
+let Source = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let moduleUrl = import.meta.url;
+
+let todoItemSchema = Sury.$schema(s => ({
+  memberId: s.m(Sury.string),
+  email: s.m(Pii$Reventless.mark("memberId", undefined, Sury.string))
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "SendGreeting",
+  memberId: s.m(DcbTag$Reventless.string),
+  key: s.m(Sury.string)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let Spec = {
+  name: "GreetMember",
+  moduleUrl: moduleUrl,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 3,
+  targetName: "SendGreeting",
+  schedule: undefined,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+function collect(event, param, _ctx) {
+  if (event.TAG !== "MemberJoined") {
+    return [];
+  }
+  let email = event.email;
+  let memberId = event.memberId;
+  return [[
+      memberId + `:` + email,
+      {
+        memberId: memberId,
+        email: email
+      }
+    ]];
+}
+
+function resolve(event) {
+  if (event.TAG === "MemberJoined") {
+    return;
+  } else {
+    return event.memberId + `:` + event.email;
+  }
+}
+
+function reschedule(param) {
+  return [];
+}
+
+let Mapping = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(Spec)({
+  collect: collect,
+  resolve: resolve,
+  reschedule: reschedule
+});
+
+let processed = {
+  contents: []
+};
+
+function process(key, item, param) {
+  processed.contents = processed.contents.concat([[
+      key,
+      item.email
+    ]]);
+  return [
+    item.memberId,
+    {
+      TAG: "SendGreeting",
+      memberId: item.memberId,
+      key: key
+    }
+  ];
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let moduleUrl$1 = import.meta.url;
+
+AutomationSlice$Reventless.Mappings.Make(Spec);
+
+let mappings = [Mapping];
+
+let Automation = {
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings
+};
+
+let Callback = AutomationSlice_Callback$ReventlessCore.Make(Spec)(Automation);
+
+let context = {
+  environment: "test",
+  platformName: "local",
+  pluginName: "TestPlugin",
+  sliceName: "GreetMember"
+};
+
+function envelope(event) {
+  return Object.fromEntries([
+    [
+      "id",
+      "m-1"
+    ],
+    [
+      "meta",
+      Util_Sury$Reventless.toJson(Message$ReventlessCore.generateMeta(name, undefined, undefined, undefined, undefined, undefined, undefined), Message$Reventless.metaSchema)
+    ],
+    [
+      "event",
+      Util_Sury$Reventless.toJson(event, eventSchema)
+    ]
+  ]);
+}
+
+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 joined = {
+  TAG: "MemberJoined",
+  memberId: "m-1",
+  email: "ada@example.org"
+};
+
+let greeted = {
+  TAG: "MemberGreeted",
+  memberId: "m-1",
+  email: "ada@example.org"
+};
+
+function rows() {
+  return Object.entries(Callback.todoItems);
+}
+
+let published = {
+  contents: []
+};
+
+async function publish(msgs) {
+  published.contents = published.contents.concat(msgs);
+}
+
+globalThis.describe("an automation's work item with personal data", () => {
+  globalThis.beforeEach(() => {
+    Object.keys(Callback.todoItems).forEach(k => Stdlib_Dict.$$delete(Callback.todoItems, k));
+    processed.contents = [];
+    published.contents = [];
+    erased.contents = false;
+    Pii$Reventless.Provider.install(provider);
+  });
+  globalThis.afterEach(() => Pii$Reventless.Provider.install(Pii$Reventless.plain));
+  globalThis.test("is stored sealed, under a key that holds no address", async () => {
+    await Callback.phase1([envelope(joined)], context, keyed);
+    globalThis.expect(Stdlib_Option.getOr(JSON.stringify(Object.entries(Callback.todoItems)), "").includes("ada@example.org")).toBe(false);
+    globalThis.expect(Object.entries(Callback.todoItems).every(param => param[0].startsWith("fp(automationWorkItem:GreetMember)"))).toBe(true);
+    globalThis.expect(Object.entries(Callback.todoItems).length).toBe(1);
+  });
+  globalThis.test("is processed with the key and the value it was collected with", async () => {
+    await Callback.phase1([envelope(joined)], context, keyed);
+    await Callback.phase2(publish);
+    globalThis.expect(processed.contents).toEqual([[
+        "m-1:ada@example.org",
+        "ada@example.org"
+      ]]);
+    globalThis.expect(published.contents.length).toBe(1);
+  });
+  globalThis.test("is resolved by the key the mapping chose", async () => {
+    await Callback.phase1([envelope(joined)], context, keyed);
+    await Callback.phase1([envelope(greeted)], context, keyed);
+    globalThis.expect(Object.entries(Callback.todoItems).map(param => param[1].status)).toEqual(["Completed"]);
+  });
+  globalThis.test("is completed without processing once its subject is erased", async () => {
+    await Callback.phase1([envelope(joined)], context, keyed);
+    erased.contents = true;
+    await Callback.phase2(publish);
+    globalThis.expect(processed.contents).toEqual([]);
+    globalThis.expect(Object.entries(Callback.todoItems).map(param => param[1].status)).toEqual(["Completed"]);
+  });
+});
+
+export {
+  Source,
+  Spec,
+  Mapping,
+  processed,
+  Automation,
+  Callback,
+  context,
+  envelope,
+  toBase64,
+  fromBase64,
+  erased,
+  provider,
+  keyed,
+  joined,
+  greeted,
+  rows,
+  published,
+  publish,
+}
+/* eventSchema Not a pure module */