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

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
+  )
+})

package/tests/OutboundFromSliceGwtTest.res.mjs

@@ -0,0 +1,268 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Messaging$Reventless from "@reventlessdev/reventless-spec/src/semantic/Messaging.res.mjs";
+import * as Capabilities_Fake$ReventlessGwt from "../src/Capabilities_Fake.res.mjs";
+import * as OutboundTranslation_GWT$ReventlessGwt from "../src/OutboundTranslation_GWT.res.mjs";
+
+let consumedEventSchema = Sury.$schema(s => ({
+  TAG: "Registered",
+  customerId: s.m(Sury.string),
+  email: s.m(Sury.string)
+}));
+
+let outboundItemSchema = Sury.$schema(s => ({
+  email: s.m(Sury.string)
+}));
+
+let inboundCommandSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "MarkWelcomed",
+    customerId: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "MarkUnreachable",
+    customerId: s.m(Sury.string)
+  }))
+]);
+
+let sourceNames = [];
+
+let capabilityNeeds = [];
+
+let traits = [];
+
+let Welcome_targetName = "Customer";
+
+let Welcome = {
+  name: "Welcome",
+  moduleUrl: "",
+  consumedEventSchema: consumedEventSchema,
+  outboundItemSchema: outboundItemSchema,
+  inboundCommandSchema: inboundCommandSchema,
+  maxRetries: 2,
+  heartbeatInterval: 60,
+  targetName: Welcome_targetName,
+  sourceNames: sourceNames,
+  externalSystem: undefined,
+  capabilityNeeds: capabilityNeeds,
+  traits: traits
+};
+
+let moduleUrl = "";
+
+function collect(event, sourceId) {
+  return [[
+      sourceId,
+      {
+        email: event.email
+      }
+    ]];
+}
+
+async function translate(id, item, capabilities) {
+  let failure = await capabilities.messaging.send({
+    TAG: "ToEmail",
+    _0: item.email
+  }, {
+    subject: "Welcome",
+    body: "Hello"
+  });
+  if (failure.TAG === "Ok") {
+    return {
+      TAG: "Ok",
+      _0: [
+        id,
+        {
+          TAG: "MarkWelcomed",
+          customerId: id
+        }
+      ]
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: Messaging$Reventless.failureReason(failure._0)
+    };
+  }
+}
+
+function onExhausted(id, _item, param) {
+  return [
+    id,
+    {
+      TAG: "MarkUnreachable",
+      customerId: id
+    }
+  ];
+}
+
+let Welcome_Translation = {
+  moduleUrl: moduleUrl,
+  collect: collect,
+  translate: translate,
+  onExhausted: onExhausted
+};
+
+let include = OutboundTranslation_GWT$ReventlessGwt.FromSlice(Welcome)({
+  collect: collect,
+  translate: translate,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let testSync = include.testSync;
+
+let givenEvent = include.givenEvent;
+
+let whenCollect = include.whenCollect;
+
+let thenTodos = include.thenTodos;
+
+let givenTodo = include.givenTodo;
+
+let givenCapabilities = include.givenCapabilities;
+
+let whenTranslated = include.whenTranslated;
+
+let whenTranslateMocked = include.whenTranslateMocked;
+
+let whenTranslateRetrying = include.whenTranslateRetrying;
+
+let whenExhausted = include.whenExhausted;
+
+let thenCommand = include.thenCommand;
+
+let thenSent = include.thenSent;
+
+let thenNothingSent = include.thenNothingSent;
+
+let thenRetryRecorded = include.thenRetryRecorded;
+
+let thenTodoStatus = include.thenTodoStatus;
+
+let down = Capabilities_Fake$ReventlessGwt.make(undefined, async (param, param$1) => ({
+  TAG: "Error",
+  _0: {
+    TAG: "Unavailable",
+    _0: "smtp down"
+  }
+}), undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+
+let welcome = {
+  TAG: "Sent",
+  recipient: {
+    TAG: "ToEmail",
+    _0: "a@b.c"
+  },
+  message: {
+    subject: "Welcome",
+    body: "Hello"
+  }
+};
+
+describe("OutboundTranslation_GWT.FromSlice", () => {
+  testSync("collect keys by the source id", () => thenTodos(whenCollect(givenEvent({
+    TAG: "Registered",
+    customerId: "c1",
+    email: "a@b.c"
+  }), "c1"), [[
+      "c1",
+      {
+        email: "a@b.c"
+      }
+    ]]));
+  test("translate sends through the messaging capability", undefined, () => thenSent(whenTranslated(givenTodo("c1", {
+    email: "a@b.c"
+  })), [welcome]));
+  test("translate answers with a command", undefined, () => thenCommand(whenTranslated(givenTodo("c1", {
+    email: "a@b.c"
+  })), "c1", {
+    TAG: "MarkWelcomed",
+    customerId: "c1"
+  }));
+  test("a failed attempt leaves the row Failed", undefined, () => thenTodoStatus(whenTranslated(givenCapabilities(givenTodo("c1", {
+    email: "a@b.c"
+  }), down)), "c1", "Failed"));
+  test("#Pending still reads as #Failed", undefined, () => thenTodoStatus(whenTranslated(givenCapabilities(givenTodo("c1", {
+    email: "a@b.c"
+  }), down)), "c1", "Pending"));
+  test("maxRetries failed attempts abandon the row", undefined, () => thenTodoStatus(whenTranslateRetrying(givenTodo("c1", {
+    email: "a@b.c"
+  }), undefined, async (param, param$1) => ({
+    TAG: "Error",
+    _0: "down"
+  })), "c1", "Abandoned"));
+  test("maxRetries attempts in all, as the runtime makes them", undefined, () => thenRetryRecorded(whenTranslateRetrying(givenTodo("c1", {
+    email: "a@b.c"
+  }), undefined, async (param, param$1) => ({
+    TAG: "Error",
+    _0: "down"
+  })), 2));
+  test("a throw is a failed attempt", undefined, () => thenTodoStatus(whenTranslateMocked(givenTodo("c1", {
+    email: "a@b.c"
+  }), async (param, param$1) => Stdlib_JsError.throwWithMessage("boom")), "c1", "Failed"));
+  test("exhausted: onExhausted is what the domain hears", undefined, () => thenCommand(whenExhausted(givenTodo("c1", {
+    email: "a@b.c"
+  }), "smtp down"), "c1", {
+    TAG: "MarkUnreachable",
+    customerId: "c1"
+  }));
+  test("nothing sent when the slice is never translated", undefined, () => thenNothingSent(whenExhausted(givenTodo("c1", {
+    email: "a@b.c"
+  }), undefined)));
+});
+
+let encItems = include.encItems;
+
+let commandPairJson = include.commandPairJson;
+
+let errorOf = include.errorOf;
+
+let fakes = include.fakes;
+
+let attemptWith = include.attemptWith;
+
+let attempts = include.attempts;
+
+let thenNoCommand = include.thenNoCommand;
+
+let statusName = include.statusName;
+
+export {
+  Welcome,
+  Welcome_Translation,
+  describe,
+  test,
+  testSync,
+  encItems,
+  commandPairJson,
+  errorOf,
+  givenEvent,
+  whenCollect,
+  thenTodos,
+  givenTodo,
+  fakes,
+  givenCapabilities,
+  attemptWith,
+  attempts,
+  whenTranslated,
+  whenTranslateMocked,
+  whenTranslateRetrying,
+  whenExhausted,
+  thenCommand,
+  thenNoCommand,
+  thenSent,
+  thenNothingSent,
+  thenRetryRecorded,
+  statusName,
+  thenTodoStatus,
+  down,
+  welcome,
+}
+/* consumedEventSchema Not a pure module */

package/tests/StateChangeSliceAuthorizeGwtTest.res.mjs

@@ -40,8 +40,12 @@ let eventSchema = Sury.$schema(s => ({
   shelfId: s.m(DcbTag$Reventless.string)
 }));
 
-function commandAuthorization(command) {
-  switch (command.TAG) {
+function authorizationOf(name) {
+  switch (name) {
+    case "Peek" :
+      return "AllowAnonymous";
+    case "Purge" :
+      return "DenyAll";
     case "Shelve" :
       return {
         TAG: "AllowRoles",
@@ -50,12 +54,8 @@ function commandAuthorization(command) {
           "Merchandiser"
         ]
       };
-    case "Browse" :
+    default:
       return "AllowAuthenticated";
-    case "Peek" :
-      return "AllowAnonymous";
-    case "Purge" :
-      return "DenyAll";
   }
 }
 
@@ -72,7 +72,7 @@ let ShelveSlice = {
   commandSchema: commandSchema,
   errorSchema: errorSchema,
   eventSchema: eventSchema,
-  commandAuthorization: commandAuthorization,
+  authorizationOf: authorizationOf,
   commandTransition: commandTransition,
   traits: traits,
   readConsistency: "EscalateOnRetry"
@@ -105,7 +105,7 @@ let include = Behavior_GWT$ReventlessGwt.Make({
   commandSchema: commandSchema,
   errorSchema: errorSchema,
   eventSchema: eventSchema,
-  commandAuthorization: commandAuthorization
+  authorizationOf: authorizationOf
 })({
   initialState: undefined,
   evolve: evolve,
@@ -203,11 +203,15 @@ let eventSchema$1 = Sury.$schema(s => ({
   shelfId: s.m(DcbTag$Reventless.string)
 }));
 
-function commandAuthorization$1(command) {
-  return {
-    TAG: "AllowRoles",
-    _0: ["Merchandiser"]
-  };
+function authorizationOf$1(name) {
+  if (name === "Shelve") {
+    return {
+      TAG: "AllowRoles",
+      _0: ["Merchandiser"]
+    };
+  } else {
+    return "AllowAuthenticated";
+  }
 }
 
 function commandTransition$1(param) {
@@ -223,7 +227,7 @@ let ClaimSlice = {
   commandSchema: commandSchema$1,
   errorSchema: errorSchema$1,
   eventSchema: eventSchema$1,
-  commandAuthorization: commandAuthorization$1,
+  authorizationOf: authorizationOf$1,
   commandTransition: commandTransition$1,
   traits: traits$1,
   readConsistency: "EscalateOnRetry"
@@ -249,7 +253,7 @@ let Claim = Behavior_GWT$ReventlessGwt.Make({
   commandSchema: commandSchema$1,
   errorSchema: errorSchema$1,
   eventSchema: eventSchema$1,
-  commandAuthorization: commandAuthorization$1
+  authorizationOf: authorizationOf$1
 })({
   initialState: undefined,
   evolve: evolve$1,

package/tests/StateChangeSliceGwtTest.res.mjs

@@ -24,7 +24,7 @@ let eventSchema = Sury.$schema(s => ({
   name: s.m(Sury.string)
 }));
 
-function commandAuthorization(param) {
+function authorizationOf(param) {
   return "AllowAuthenticated";
 }
 
@@ -40,7 +40,7 @@ let AddCategorySlice = {
   commandSchema: commandSchema,
   errorSchema: errorSchema,
   eventSchema: eventSchema,
-  commandAuthorization: commandAuthorization,
+  authorizationOf: authorizationOf,
   commandTransition: commandTransition,
   traits: traits,
   readConsistency: "EscalateOnRetry"
@@ -173,7 +173,7 @@ let eventSchema$1 = Sury.$schema(s => ({
   id: s.m(Sury.string)
 }));
 
-function commandAuthorization$1(param) {
+function authorizationOf$1(param) {
   return "AllowAuthenticated";
 }
 
@@ -189,7 +189,7 @@ let MissingTagSlice = {
   commandSchema: commandSchema$1,
   errorSchema: errorSchema$1,
   eventSchema: eventSchema$1,
-  commandAuthorization: commandAuthorization$1,
+  authorizationOf: authorizationOf$1,
   commandTransition: commandTransition$1,
   traits: traits$1,
   readConsistency: "EscalateOnRetry"
@@ -288,7 +288,7 @@ let eventSchema$2 = Sury.$schema(s => ({
   carrierId: s.m(DcbTag$Reventless.string)
 }));
 
-function commandAuthorization$2(param) {
+function authorizationOf$2(param) {
   return "AllowAuthenticated";
 }
 
@@ -304,7 +304,7 @@ let ShipOrderSlice = {
   commandSchema: commandSchema$2,
   errorSchema: errorSchema$2,
   eventSchema: eventSchema$2,
-  commandAuthorization: commandAuthorization$2,
+  authorizationOf: authorizationOf$2,
   commandTransition: commandTransition$2,
   traits: traits$2,
   readConsistency: "EscalateOnRetry"