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

package/src/OutboundTranslation_GWT.res.mjs

@@ -1,9 +1,15 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
 import * as JestBind$ReventlessGwt from "./JestBind.res.mjs";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as Capabilities_Fake$ReventlessGwt from "./Capabilities_Fake.res.mjs";
 
 function Make(Spec) {
   let test = (name, timeout, body) => JestBind$ReventlessGwt.testPromise(Spec.name, name, timeout, body);
@@ -181,7 +187,257 @@ function Make(Spec) {
   };
 }
 
+function FromSlice(Spec) {
+  return Translation => {
+    let test = (name, timeout, body) => JestBind$ReventlessGwt.testPromise(Spec.name, name, timeout, body);
+    let testSync = (name, body) => JestBind$ReventlessGwt.test(Spec.name, name, body);
+    let encItems = arr => arr.map(param => [
+      param[0],
+      Message$ReventlessCore.encode(param[1], Spec.outboundItemSchema)
+    ]);
+    let commandPairJson = (id, cmd) => {
+      let d = {};
+      d["id"] = id;
+      d["command"] = Message$ReventlessCore.encode(cmd, Spec.inboundCommandSchema);
+      return d;
+    };
+    let errorOf = exn => {
+      if (exn.RE_EXN_ID === S.Exn) {
+        return exn._1.message;
+      } else if (exn.RE_EXN_ID === "JsExn") {
+        return Stdlib_Option.getOr(Stdlib_JsExn.message(exn._1), "unknown error");
+      } else {
+        return "unknown error";
+      }
+    };
+    let givenEvent = e => e;
+    let whenCollect = (e, sourceIdOpt) => {
+      let sourceId = sourceIdOpt !== undefined ? sourceIdOpt : "";
+      return Translation.collect(e, sourceId);
+    };
+    let thenTodos = (actual, expected) => {
+      if (Primitive_object.equal(actual, expected)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "TodoMismatch",
+          expected: encItems(expected),
+          actual: encItems(actual)
+        });
+      }
+    };
+    let givenTodo = (id, item) => ({
+      id: id,
+      item: item,
+      fakes: Capabilities_Fake$ReventlessGwt.make(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined)
+    });
+    let givenCapabilities = (todo, fakes) => ({
+      id: todo.id,
+      item: todo.item,
+      fakes: fakes
+    });
+    let attemptWith = async (todo, run) => {
+      let result;
+      try {
+        result = await run(todo.id, todo.item);
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        result = {
+          TAG: "Error",
+          _0: errorOf(exn)
+        };
+      }
+      if (result.TAG !== "Ok") {
+        return result;
+      }
+      let match = result._0;
+      if (match === undefined) {
+        return result;
+      }
+      try {
+        Message$ReventlessCore.encode(match[1], Spec.inboundCommandSchema);
+        return result;
+      } catch (raw_exn$1) {
+        let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
+        return {
+          TAG: "Error",
+          _0: `failed to encode inbound command: ` + errorOf(exn$1)
+        };
+      }
+    };
+    let attempts = async (todo, limit, maxRetries, run) => {
+      let result = await attemptWith(todo, run);
+      let failures = Stdlib_Result.isError(result) ? 1 : 0;
+      while (Stdlib_Result.isError(result) && failures < limit) {
+        result = await attemptWith(todo, run);
+        if (Stdlib_Result.isError(result)) {
+          failures = failures + 1 | 0;
+        }
+      };
+      let match = result;
+      let tmp;
+      tmp = match.TAG === "Ok" ? "Completed" : (
+          failures >= maxRetries ? "Abandoned" : "Failed"
+        );
+      return {
+        id: todo.id,
+        item: todo.item,
+        result: result,
+        retries: failures,
+        status: tmp,
+        sent: todo.fakes.calls()
+      };
+    };
+    let whenTranslated = todo => attempts(todo, 1, Spec.maxRetries, (id, item) => Translation.translate(id, item, todo.fakes.capabilities));
+    let whenTranslateMocked = (todo, mock) => attempts(todo, 1, Spec.maxRetries, mock);
+    let whenTranslateRetrying = (todo, maxRetriesOpt, mock) => {
+      let maxRetries = maxRetriesOpt !== undefined ? maxRetriesOpt : Spec.maxRetries;
+      return attempts(todo, maxRetries, maxRetries, mock);
+    };
+    let whenExhausted = async (todo, lastError) => ({
+      id: todo.id,
+      item: todo.item,
+      result: {
+        TAG: "Ok",
+        _0: Translation.onExhausted(todo.id, todo.item, lastError)
+      },
+      retries: Spec.maxRetries,
+      status: "Abandoned",
+      sent: []
+    });
+    let thenCommand = async (pending, expectedId, expectedCmd) => {
+      let match = await pending;
+      let result = match.result;
+      if (result.TAG !== "Ok") {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "TranslateError",
+          expected: "(command)",
+          actual: result._0
+        });
+      }
+      let actual = result._0;
+      if (actual !== undefined && actual[0] === expectedId && Primitive_object.equal(actual[1], expectedCmd)) {
+        return Outcome$ReventlessGwt.pass;
+      }
+      return Outcome$ReventlessGwt.fail({
+        TAG: "EventsMismatch",
+        expected: [commandPairJson(expectedId, expectedCmd)],
+        actual: Stdlib_Option.mapOr(actual, [], param => [commandPairJson(param[0], param[1])])
+      });
+    };
+    let thenNoCommand = async pending => {
+      let match = await pending;
+      let result = match.result;
+      if (result.TAG !== "Ok") {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "TranslateError",
+          expected: "(no command)",
+          actual: result._0
+        });
+      }
+      let match$1 = result._0;
+      if (match$1 !== undefined) {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "NoEventExpected",
+          actual: [commandPairJson(match$1[0], match$1[1])]
+        });
+      } else {
+        return Outcome$ReventlessGwt.pass;
+      }
+    };
+    let thenSent = async (pending, expected) => {
+      let match = await pending;
+      let sent = match.sent;
+      if (Primitive_object.equal(sent, expected)) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "EventsMismatch",
+          expected: expected.map(Capabilities_Fake$ReventlessGwt.toJson),
+          actual: sent.map(Capabilities_Fake$ReventlessGwt.toJson)
+        });
+      }
+    };
+    let thenNothingSent = pending => thenSent(pending, []);
+    let thenRetryRecorded = async (pending, expectedRetries) => {
+      let match = await pending;
+      let retries = match.retries;
+      if (retries === expectedRetries) {
+        return Outcome$ReventlessGwt.pass;
+      } else {
+        return Outcome$ReventlessGwt.fail({
+          TAG: "StateMismatch",
+          key: "retries",
+          expected: expectedRetries,
+          actual: retries
+        });
+      }
+    };
+    let statusName = s => {
+      if (s === "Failed" || s === "Pending") {
+        return "#Failed";
+      } else if (s === "Abandoned") {
+        return "#Abandoned";
+      } else {
+        return "#Completed";
+      }
+    };
+    let thenTodoStatus = async (pending, expectedId, expectedStatus) => {
+      let match = await pending;
+      let status = match.status;
+      let id = match.id;
+      if (id === expectedId && statusName(status) === statusName(expectedStatus)) {
+        return Outcome$ReventlessGwt.pass;
+      }
+      let encOne = (rid, s) => Object.fromEntries([
+        [
+          "id",
+          rid
+        ],
+        [
+          "status",
+          statusName(s)
+        ]
+      ]);
+      return Outcome$ReventlessGwt.fail({
+        TAG: "StateMismatch",
+        key: id,
+        expected: encOne(expectedId, expectedStatus),
+        actual: encOne(id, status)
+      });
+    };
+    return {
+      describe: JestBind$ReventlessGwt.describe,
+      test: test,
+      testSync: testSync,
+      encItems: encItems,
+      commandPairJson: commandPairJson,
+      errorOf: errorOf,
+      givenEvent: givenEvent,
+      whenCollect: whenCollect,
+      thenTodos: thenTodos,
+      givenTodo: givenTodo,
+      fakes: Capabilities_Fake$ReventlessGwt.make,
+      givenCapabilities: givenCapabilities,
+      attemptWith: attemptWith,
+      attempts: attempts,
+      whenTranslated: whenTranslated,
+      whenTranslateMocked: whenTranslateMocked,
+      whenTranslateRetrying: whenTranslateRetrying,
+      whenExhausted: whenExhausted,
+      thenCommand: thenCommand,
+      thenNoCommand: thenNoCommand,
+      thenSent: thenSent,
+      thenNothingSent: thenNothingSent,
+      thenRetryRecorded: thenRetryRecorded,
+      statusName: statusName,
+      thenTodoStatus: thenTodoStatus
+    };
+  };
+}
+
 export {
   Make,
+  FromSlice,
 }
-/* Message-ReventlessCore Not a pure module */
+/* S Not a pure module */

package/tests/AutomationFromSliceGwtTest.res

@@ -0,0 +1,145 @@
+// Automation_GWT.FromSlice over a two-source slice written as the framework
+// takes it: a Spec, and a body with per-source mappings, `process` and
+// `onExhausted`. The second source's events do not name the order, so its
+// mapping keys the to-do by `~sourceId`.
+
+module ShipPaid = {
+  let name = "ShipPaid"
+  let moduleUrl = ""
+
+  @schema
+  type todoItem = {orderId: string}
+
+  @schema
+  type command =
+    | Ship({orderId: string})
+    | GiveUp({orderId: string})
+
+  let maxRetries = 3
+  let heartbeatInterval = 60
+  let targetName = "Order"
+}
+
+module ShipPaid_Automation = {
+  module M = Reventless.AutomationSlice.Mappings.Make(ShipPaid)
+  module type Mapping = M.Mapping
+  let moduleUrl = ""
+
+  module Orders = {
+    module Id = Reventless.Id.String
+    let name = "Orders"
+    @schema
+    type event =
+      | OrderPlaced({orderId: string})
+      | OrderCancelled({orderId: string})
+  }
+
+  module Payments = {
+    module Id = Reventless.Id.String
+    let name = "Payments"
+    @schema
+    type event =
+      | Captured({amount: int})
+      | Refunded({amount: int})
+  }
+
+  module FromOrders = Reventless.AutomationSlice.Mapping.Make(
+    Orders,
+    ShipPaid,
+    {
+      let collect = (event, ~sourceId as _, _ctx) =>
+        switch event {
+        | Orders.OrderPlaced({orderId}) => [(orderId, ({orderId: orderId}: ShipPaid.todoItem))]
+        | OrderCancelled(_) => []
+        }
+      let resolve = event =>
+        switch event {
+        | Orders.OrderCancelled({orderId}) => Some(orderId)
+        | OrderPlaced(_) => None
+        }
+    },
+  )
+
+  module FromPayments = Reventless.AutomationSlice.Mapping.Make(
+    Payments,
+    ShipPaid,
+    {
+      let collect = (event, ~sourceId, _ctx) =>
+        switch event {
+        | Payments.Captured(_) => [(sourceId, ({orderId: sourceId}: ShipPaid.todoItem))]
+        | Refunded(_) => []
+        }
+      let resolve = event =>
+        switch event {
+        | Payments.Refunded(_) => None
+        | Captured(_) => None
+        }
+    },
+  )
+
+  let mappings: array<module(Mapping)> = [module(FromOrders), module(FromPayments)]
+
+  let process = (id, _item: ShipPaid.todoItem) => Some((id, ShipPaid.Ship({orderId: id})))
+  let onExhausted = (id, _item: ShipPaid.todoItem) => Some((id, ShipPaid.GiveUp({orderId: id})))
+}
+
+open ShipPaid
+open ShipPaid_Automation
+include Automation_GWT.FromSlice(ShipPaid, ShipPaid_Automation)
+module O = Mapping(FromOrders)
+module P = Mapping(FromPayments)
+
+describe("Automation_GWT.FromSlice", () => {
+  test("collect through one mapping", () =>
+    O.givenEvent(OrderPlaced({orderId: "o1"}))
+    ->O.whenCollect
+    ->thenTodos([("o1", {orderId: "o1"})])
+  )
+
+  test("collect keys by the source id where the event does not name it", () =>
+    P.givenEvent(Captured({amount: 5}))
+    ->P.whenCollect(~sourceId="o2")
+    ->thenTodos([("o2", {orderId: "o2"})])
+  )
+
+  test("resolve through one mapping", () =>
+    O.givenEvent(OrderCancelled({orderId: "o1"}))
+    ->O.whenResolve
+    ->thenResolved(Some("o1"))
+  )
+
+  test("process", () =>
+    givenTodo("o1", {orderId: "o1"})->whenProcess->thenCommand("o1", Ship({orderId: "o1"}))
+  )
+
+  test("exhausted: onExhausted is what the domain hears", () =>
+    givenTodo("o1", {orderId: "o1"})->whenExhausted->thenCommand("o1", GiveUp({orderId: "o1"}))
+  )
+
+  test("sweep: both sources route by name, in event order", () =>
+    givenEvents([
+      P.event(Captured({amount: 5}), ~sourceId="o2"),
+      O.event(OrderPlaced({orderId: "o1"})),
+    ])
+    ->whenSweep
+    ->thenCommands([("o2", Ship({orderId: "o2"})), ("o1", Ship({orderId: "o1"}))])
+  )
+
+  test("sweep: a resolve completes only a row that exists", () =>
+    givenEvents([
+      O.event(OrderCancelled({orderId: "o1"})),
+      O.event(OrderPlaced({orderId: "o1"})),
+      O.event(OrderPlaced({orderId: "o3"})),
+      O.event(OrderCancelled({orderId: "o3"})),
+    ])
+    ->whenSweep
+    ->thenScenarioTodos([("o1", {orderId: "o1"})])
+  )
+
+  test("andThenEvents drains what later events resolve", () =>
+    givenEvents([O.event(OrderPlaced({orderId: "o1"}))])
+    ->whenSweep
+    ->andThenEvents([O.event(OrderCancelled({orderId: "o1"}))])
+    ->thenScenarioTodos([])
+  )
+})