@reventlessdev/reventless-gwt 1.0.0-alpha.238 → 1.0.0-alpha.239

package/tests/AutomationFromSliceGwtTest.res.mjs

@@ -0,0 +1,353 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as AutomationSlice$Reventless from "@reventlessdev/reventless-spec/src/components/AutomationSlice.res.mjs";
+import * as Automation_GWT$ReventlessGwt from "../src/Automation_GWT.res.mjs";
+
+let todoItemSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string)
+}));
+
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Ship",
+    orderId: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "GiveUp",
+    orderId: s.m(Sury.string)
+  }))
+]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let ShipPaid = {
+  name: "ShipPaid",
+  moduleUrl: "",
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 3,
+  heartbeatInterval: 60,
+  targetName: "Order",
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+let M = AutomationSlice$Reventless.Mappings.Make(ShipPaid);
+
+let moduleUrl = "";
+
+let name = "Orders";
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "OrderCancelled",
+    orderId: s.m(Sury.string)
+  }))
+]);
+
+let Orders = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+let name$1 = "Payments";
+
+let eventSchema$1 = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "Captured",
+    amount: s.m(Sury.int32)
+  })),
+  Sury.$schema(s => ({
+    TAG: "Refunded",
+    amount: s.m(Sury.int32)
+  }))
+]);
+
+let Payments = {
+  Id: undefined,
+  name: name$1,
+  eventSchema: eventSchema$1
+};
+
+function collect(event, param, _ctx) {
+  if (event.TAG !== "OrderPlaced") {
+    return [];
+  }
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId
+      }
+    ]];
+}
+
+function resolve(event) {
+  if (event.TAG === "OrderPlaced") {
+    return;
+  } else {
+    return event.orderId;
+  }
+}
+
+let FromOrders = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(ShipPaid)({
+  collect: collect,
+  resolve: resolve
+});
+
+function collect$1(event, sourceId, _ctx) {
+  if (event.TAG === "Captured") {
+    return [[
+        sourceId,
+        {
+          orderId: sourceId
+        }
+      ]];
+  } else {
+    return [];
+  }
+}
+
+function resolve$1(event) {
+  
+}
+
+let FromPayments = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name$1,
+  eventSchema: eventSchema$1
+})(ShipPaid)({
+  collect: collect$1,
+  resolve: resolve$1
+});
+
+let mappings = [
+  FromOrders,
+  FromPayments
+];
+
+function process(id, _item) {
+  return [
+    id,
+    {
+      TAG: "Ship",
+      orderId: id
+    }
+  ];
+}
+
+function onExhausted(id, _item) {
+  return [
+    id,
+    {
+      TAG: "GiveUp",
+      orderId: id
+    }
+  ];
+}
+
+let ShipPaid_Automation = {
+  M: M,
+  moduleUrl: moduleUrl,
+  Orders: Orders,
+  Payments: Payments,
+  FromOrders: FromOrders,
+  FromPayments: FromPayments,
+  mappings: mappings,
+  process: process,
+  onExhausted: onExhausted
+};
+
+let include = Automation_GWT$ReventlessGwt.FromSlice(ShipPaid)({
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl,
+  mappings: mappings
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let thenTodos = include.thenTodos;
+
+let thenResolved = include.thenResolved;
+
+let Mapping = include.Mapping;
+
+let givenTodo = include.givenTodo;
+
+let whenProcess = include.whenProcess;
+
+let whenExhausted = include.whenExhausted;
+
+let thenCommand = include.thenCommand;
+
+let givenEvents = include.givenEvents;
+
+let whenSweep = include.whenSweep;
+
+let thenCommands = include.thenCommands;
+
+let andThenEvents = include.andThenEvents;
+
+let thenScenarioTodos = include.thenScenarioTodos;
+
+let O = Mapping(FromOrders);
+
+let P = Mapping(FromPayments);
+
+describe("Automation_GWT.FromSlice", () => {
+  test("collect through one mapping", () => thenTodos(O.whenCollect(O.givenEvent({
+    TAG: "OrderPlaced",
+    orderId: "o1"
+  }), undefined, undefined), [[
+      "o1",
+      {
+        orderId: "o1"
+      }
+    ]]));
+  test("collect keys by the source id where the event does not name it", () => thenTodos(P.whenCollect(P.givenEvent({
+    TAG: "Captured",
+    amount: 5
+  }), "o2", undefined), [[
+      "o2",
+      {
+        orderId: "o2"
+      }
+    ]]));
+  test("resolve through one mapping", () => thenResolved(O.whenResolve(O.givenEvent({
+    TAG: "OrderCancelled",
+    orderId: "o1"
+  })), "o1"));
+  test("process", () => thenCommand(whenProcess(givenTodo("o1", {
+    orderId: "o1"
+  })), "o1", {
+    TAG: "Ship",
+    orderId: "o1"
+  }));
+  test("exhausted: onExhausted is what the domain hears", () => thenCommand(whenExhausted(givenTodo("o1", {
+    orderId: "o1"
+  })), "o1", {
+    TAG: "GiveUp",
+    orderId: "o1"
+  }));
+  test("sweep: both sources route by name, in event order", () => thenCommands(whenSweep(givenEvents([
+    P.event({
+      TAG: "Captured",
+      amount: 5
+    }, "o2"),
+    O.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined)
+  ]), undefined), [
+    [
+      "o2",
+      {
+        TAG: "Ship",
+        orderId: "o2"
+      }
+    ],
+    [
+      "o1",
+      {
+        TAG: "Ship",
+        orderId: "o1"
+      }
+    ]
+  ]));
+  test("sweep: a resolve completes only a row that exists", () => thenScenarioTodos(whenSweep(givenEvents([
+    O.event({
+      TAG: "OrderCancelled",
+      orderId: "o1"
+    }, undefined),
+    O.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined),
+    O.event({
+      TAG: "OrderPlaced",
+      orderId: "o3"
+    }, undefined),
+    O.event({
+      TAG: "OrderCancelled",
+      orderId: "o3"
+    }, undefined)
+  ]), undefined), [[
+      "o1",
+      {
+        orderId: "o1"
+      }
+    ]]));
+  test("andThenEvents drains what later events resolve", () => thenScenarioTodos(andThenEvents(whenSweep(givenEvents([O.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined)]), undefined), [O.event({
+      TAG: "OrderCancelled",
+      orderId: "o1"
+    }, undefined)], undefined), []));
+});
+
+let Route = include.Route;
+
+let testContext = include.testContext;
+
+let encTodos = include.encTodos;
+
+let encPair = include.encPair;
+
+let thenNoCommand = include.thenNoCommand;
+
+let routeAll = include.routeAll;
+
+let sweep = include.sweep;
+
+export {
+  ShipPaid,
+  ShipPaid_Automation,
+  Route,
+  describe,
+  test,
+  testContext,
+  encTodos,
+  encPair,
+  thenTodos,
+  thenResolved,
+  Mapping,
+  givenTodo,
+  whenProcess,
+  whenExhausted,
+  thenCommand,
+  thenNoCommand,
+  givenEvents,
+  routeAll,
+  sweep,
+  whenSweep,
+  thenCommands,
+  andThenEvents,
+  thenScenarioTodos,
+  O,
+  P,
+}
+/* todoItemSchema Not a pure module */

package/tests/InboundFromSliceGwtTest.res

@@ -0,0 +1,63 @@
+// InboundTranslation_GWT.FromSlice: input decoded as it arrives, translated by
+// the slice's own `translate`, and commands checked against their schema.
+
+module PaymentHook = {
+  let name = "PaymentHook"
+  let moduleUrl = ""
+
+  @schema
+  type externalInput = {orderId: string, status: string}
+
+  @schema
+  type command = ConfirmPayment({orderId: string})
+
+  let targetName = "Order"
+  let externalSystem = Some("Payments")
+  type role = Reventless.Role.name
+  let commandAuthorization = _ => Reventless.Authorization.AllowAuthenticated
+}
+
+module PaymentHook_Translation = {
+  let moduleUrl = ""
+  let translate = (input: PaymentHook.externalInput) =>
+    switch input.status {
+    | "paid" => Ok([(input.orderId, PaymentHook.ConfirmPayment({orderId: input.orderId}))])
+    | "pending" => Ok([])
+    | other => Error(`Unknown status: ${other}`)
+    }
+}
+
+open PaymentHook
+include InboundTranslation_GWT.FromSlice(PaymentHook, PaymentHook_Translation)
+
+let json = (pairs: array<(string, string)>) =>
+  pairs->Array.map(((k, v)) => (k, JSON.Encode.string(v)))->Dict.fromArray->JSON.Encode.object
+
+describe("InboundTranslation_GWT.FromSlice", () => {
+  test("input translates to a command", () =>
+    whenInput({orderId: "o1", status: "paid"})->thenCommand("o1", ConfirmPayment({orderId: "o1"}))
+  )
+
+  test("received JSON decodes before it translates", () =>
+    whenReceived(json([("orderId", "o1"), ("status", "paid")]))->thenCommand(
+      "o1",
+      ConfirmPayment({orderId: "o1"}),
+    )
+  )
+
+  test("input that does not decode is refused before translate", () =>
+    whenReceived(json([("status", "paid")]))->thenRefusedInput("orderId")
+  )
+
+  test("input translate declines is not understood", () =>
+    whenInput({orderId: "o1", status: "lost"})->thenNotUnderstood("Unknown status: lost")
+  )
+
+  test("thenTranslateError is the older name", () =>
+    whenInput({orderId: "o1", status: "lost"})->thenTranslateError("Unknown status: lost")
+  )
+
+  test("no commands is an answer", () =>
+    whenInput({orderId: "o1", status: "pending"})->thenNoCommand
+  )
+})

package/tests/InboundFromSliceGwtTest.res.mjs

@@ -0,0 +1,164 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as InboundTranslation_GWT$ReventlessGwt from "../src/InboundTranslation_GWT.res.mjs";
+
+let externalInputSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
+  status: s.m(Sury.string)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "ConfirmPayment",
+  orderId: s.m(Sury.string)
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let traits = [];
+
+let PaymentHook_externalSystem = "Payments";
+
+let PaymentHook = {
+  name: "PaymentHook",
+  moduleUrl: "",
+  externalInputSchema: externalInputSchema,
+  commandSchema: commandSchema,
+  targetName: "Order",
+  externalSystem: PaymentHook_externalSystem,
+  commandAuthorization: commandAuthorization,
+  traits: traits
+};
+
+let moduleUrl = "";
+
+function translate(input) {
+  let other = input.status;
+  switch (other) {
+    case "paid" :
+      return {
+        TAG: "Ok",
+        _0: [[
+            input.orderId,
+            {
+              TAG: "ConfirmPayment",
+              orderId: input.orderId
+            }
+          ]]
+      };
+    case "pending" :
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    default:
+      return {
+        TAG: "Error",
+        _0: `Unknown status: ` + other
+      };
+  }
+}
+
+let PaymentHook_Translation = {
+  moduleUrl: moduleUrl,
+  translate: translate
+};
+
+let include = InboundTranslation_GWT$ReventlessGwt.FromSlice(PaymentHook)({
+  translate: translate,
+  moduleUrl: moduleUrl
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let whenInput = include.whenInput;
+
+let whenReceived = include.whenReceived;
+
+let thenCommand = include.thenCommand;
+
+let thenNoCommand = include.thenNoCommand;
+
+let thenNotUnderstood = include.thenNotUnderstood;
+
+let thenTranslateError = include.thenTranslateError;
+
+let thenRefusedInput = include.thenRefusedInput;
+
+function json(pairs) {
+  return Object.fromEntries(pairs.map(param => [
+    param[0],
+    param[1]
+  ]));
+}
+
+describe("InboundTranslation_GWT.FromSlice", () => {
+  test("input translates to a command", () => thenCommand(whenInput({
+    orderId: "o1",
+    status: "paid"
+  }), "o1", {
+    TAG: "ConfirmPayment",
+    orderId: "o1"
+  }));
+  test("received JSON decodes before it translates", () => thenCommand(whenReceived(json([
+    [
+      "orderId",
+      "o1"
+    ],
+    [
+      "status",
+      "paid"
+    ]
+  ])), "o1", {
+    TAG: "ConfirmPayment",
+    orderId: "o1"
+  }));
+  test("input that does not decode is refused before translate", () => thenRefusedInput(whenReceived(json([[
+      "status",
+      "paid"
+    ]])), "orderId"));
+  test("input translate declines is not understood", () => thenNotUnderstood(whenInput({
+    orderId: "o1",
+    status: "lost"
+  }), "Unknown status: lost"));
+  test("thenTranslateError is the older name", () => thenTranslateError(whenInput({
+    orderId: "o1",
+    status: "lost"
+  }), "Unknown status: lost"));
+  test("no commands is an answer", () => thenNoCommand(whenInput({
+    orderId: "o1",
+    status: "pending"
+  })));
+});
+
+let encPairs = include.encPairs;
+
+let describeOther = include.describeOther;
+
+let roundTrips = include.roundTrips;
+
+let thenCommands = include.thenCommands;
+
+export {
+  PaymentHook,
+  PaymentHook_Translation,
+  describe,
+  test,
+  encPairs,
+  whenInput,
+  whenReceived,
+  describeOther,
+  roundTrips,
+  thenCommands,
+  thenCommand,
+  thenNoCommand,
+  thenNotUnderstood,
+  thenTranslateError,
+  thenRefusedInput,
+  json,
+}
+/* externalInputSchema Not a pure module */

package/tests/InboundTranslationGwtTest.res.mjs

@@ -41,10 +41,6 @@ function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
-function commandTransition(param) {
-  return "Undeclared";
-}
-
 let traits = [];
 
 let PaymentWebhookSlice = {
@@ -53,7 +49,6 @@ let PaymentWebhookSlice = {
   commandSchema: commandSchema,
   translate: translate,
   commandAuthorization: commandAuthorization,
-  commandTransition: commandTransition,
   traits: traits,
   externalSystem: undefined
 };

package/tests/OutboundFromSliceGwtTest.res

@@ -0,0 +1,124 @@
+// OutboundTranslation_GWT.FromSlice: the slice's real `translate`, run against
+// recording capability fakes, and statuses counted as the runtime counts them.
+
+module Welcome = {
+  let name = "Welcome"
+  let moduleUrl = ""
+
+  @schema
+  type consumedEvent = Registered({customerId: string, email: string})
+
+  @schema
+  type outboundItem = {email: string}
+
+  @schema
+  type inboundCommand = MarkWelcomed({customerId: string}) | MarkUnreachable({customerId: string})
+
+  let maxRetries = 2
+  let heartbeatInterval = 60
+  let targetName = Some("Customer")
+  let sourceNames = []
+  let externalSystem = None
+  let capabilityNeeds = []
+  let traits = []
+}
+
+module Welcome_Translation = {
+  let moduleUrl = ""
+
+  let collect = (event, ~sourceId) =>
+    switch event {
+    | Welcome.Registered({email, _}) => [(sourceId, ({email: email}: Welcome.outboundItem))]
+    }
+
+  let translate = async (
+    id,
+    item: Welcome.outboundItem,
+    ~capabilities: Reventless.Capabilities.t,
+  ) =>
+    switch await capabilities.messaging.send(
+      ~recipient=ToEmail(item.email),
+      ~message={subject: "Welcome", body: "Hello"},
+    ) {
+    | Ok(_) => Ok(Some((id, Welcome.MarkWelcomed({customerId: id}))))
+    | Error(failure) => Error(failure->Reventless.Messaging.failureReason)
+    }
+
+  let onExhausted = (id, _item, ~lastError as _) => Some((
+    id,
+    Welcome.MarkUnreachable({customerId: id}),
+  ))
+}
+
+open Welcome
+include OutboundTranslation_GWT.FromSlice(Welcome, Welcome_Translation)
+
+let down = Capabilities_Fake.make(
+  ~send=async (~recipient as _, ~message as _) => Error(Unavailable("smtp down")),
+  (),
+)
+
+let welcome: Capabilities_Fake.call = Sent({
+  recipient: ToEmail("a@b.c"),
+  message: {subject: "Welcome", body: "Hello"},
+})
+
+describe("OutboundTranslation_GWT.FromSlice", () => {
+  testSync("collect keys by the source id", () =>
+    givenEvent(Registered({customerId: "c1", email: "a@b.c"}))
+    ->whenCollect(~sourceId="c1")
+    ->thenTodos([("c1", {email: "a@b.c"})])
+  )
+
+  test("translate sends through the messaging capability", () =>
+    givenTodo("c1", {email: "a@b.c"})->whenTranslated->thenSent([welcome])
+  )
+
+  test("translate answers with a command", () =>
+    givenTodo("c1", {email: "a@b.c"})
+    ->whenTranslated
+    ->thenCommand("c1", MarkWelcomed({customerId: "c1"}))
+  )
+
+  test("a failed attempt leaves the row Failed", () =>
+    givenTodo("c1", {email: "a@b.c"})
+    ->givenCapabilities(down)
+    ->whenTranslated
+    ->thenTodoStatus("c1", #Failed)
+  )
+
+  test("#Pending still reads as #Failed", () =>
+    givenTodo("c1", {email: "a@b.c"})
+    ->givenCapabilities(down)
+    ->whenTranslated
+    ->thenTodoStatus("c1", #Pending)
+  )
+
+  test("maxRetries failed attempts abandon the row", () =>
+    givenTodo("c1", {email: "a@b.c"})
+    ->whenTranslateRetrying(async (_, _) => Error("down"))
+    ->thenTodoStatus("c1", #Abandoned)
+  )
+
+  test("maxRetries attempts in all, as the runtime makes them", () =>
+    givenTodo("c1", {email: "a@b.c"})
+    ->whenTranslateRetrying(async (_, _) => Error("down"))
+    ->thenRetryRecorded(2)
+  )
+
+  test("a throw is a failed attempt", () =>
+    givenTodo("c1", {email: "a@b.c"})
+    ->whenTranslateMocked(async (_, _) => JsError.throwWithMessage("boom"))
+    ->thenTodoStatus("c1", #Failed)
+  )
+
+  test("exhausted: onExhausted is what the domain hears", () =>
+    givenTodo("c1", {email: "a@b.c"})
+    ->whenExhausted(~lastError="smtp down")
+    ->thenCommand("c1", MarkUnreachable({customerId: "c1"}))
+  )
+
+  test("nothing sent when the slice is never translated", () =>
+    givenTodo("c1", {email: "a@b.c"})->whenExhausted->thenNothingSent
+  )
+})