@reventlessdev/reventless-gwt 1.0.0-alpha.242 → 1.0.0-alpha.244

package/tests/AutomationRescheduleGwtTest.res.mjs

@@ -0,0 +1,723 @@
+// 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 Clock$Reventless from "@reventlessdev/reventless-spec/src/components/Clock.res.mjs";
+import * as Schedule$Reventless from "@reventlessdev/reventless-spec/src/types/Schedule.res.mjs";
+import * as JestBind$ReventlessGwt from "../src/JestBind.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 => ({
+  recipientId: s.m(Sury.string)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "RequestNotification",
+  recipientId: s.m(Sury.string),
+  reference: s.m(Sury.string)
+}));
+
+function authorizationOf(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition(param) {
+  return "Undeclared";
+}
+
+let traits = [];
+
+let MarketingDigest = {
+  name: "MarketingDigest",
+  moduleUrl: "",
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema,
+  maxRetries: 3,
+  heartbeatInterval: 60,
+  targetName: "NotificationPreferences",
+  schedule: undefined,
+  authorizationOf: authorizationOf,
+  commandTransition: commandTransition,
+  traits: traits
+};
+
+let M = AutomationSlice$Reventless.Mappings.Make(MarketingDigest);
+
+let moduleUrl = "";
+
+let name = "OrderingDcbEventLog";
+
+let categorySchema = Sury.union([
+  Sury.literal("Marketing"),
+  Sury.literal("Orders")
+]);
+
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "DigestTimeChosen",
+    recipientId: s.m(Sury.string),
+    time: s.m(Schedule$Reventless.timeSchema)
+  })),
+  Sury.$schema(s => ({
+    TAG: "NotificationUnsubscribed",
+    recipientId: s.m(Sury.string),
+    category: s.m(categorySchema)
+  })),
+  Sury.$schema(s => ({
+    TAG: "NotificationRequested",
+    recipientId: s.m(Sury.string),
+    reference: s.m(Sury.string)
+  }))
+]);
+
+let OrderingDcbSource = {
+  Id: undefined,
+  name: name,
+  categorySchema: categorySchema,
+  eventSchema: eventSchema
+};
+
+function collect(param, param$1, _ctx) {
+  let key = param.key;
+  return [[
+      Clock$Reventless.itemId(key, param.at),
+      {
+        recipientId: key
+      }
+    ]];
+}
+
+function resolve(param) {
+  
+}
+
+function reschedule(param) {
+  return [];
+}
+
+let FromClock = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: Clock$Reventless.name,
+  eventSchema: Clock$Reventless.eventSchema
+})(MarketingDigest)({
+  collect: collect,
+  resolve: resolve,
+  reschedule: reschedule
+});
+
+function collect$1(param, param$1, _ctx) {
+  return [];
+}
+
+function resolve$1(event) {
+  switch (event.TAG) {
+    case "DigestTimeChosen" :
+    case "NotificationUnsubscribed" :
+      return;
+    case "NotificationRequested" :
+      return event.reference;
+  }
+}
+
+function reschedule$1(event) {
+  switch (event.TAG) {
+    case "DigestTimeChosen" :
+      return [{
+          TAG: "Set",
+          key: event.recipientId,
+          time: event.time
+        }];
+    case "NotificationUnsubscribed" :
+      if (event.category === "Marketing") {
+        return [{
+            TAG: "Clear",
+            key: event.recipientId
+          }];
+      } else {
+        return [];
+      }
+    case "NotificationRequested" :
+      return [];
+  }
+}
+
+let FromOrderingDcb = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})(MarketingDigest)({
+  collect: collect$1,
+  resolve: resolve$1,
+  reschedule: reschedule$1
+});
+
+let mappings = [
+  FromClock,
+  FromOrderingDcb
+];
+
+function process(id, item, param) {
+  return [
+    item.recipientId,
+    {
+      TAG: "RequestNotification",
+      recipientId: item.recipientId,
+      reference: id
+    }
+  ];
+}
+
+function onExhausted(_id, _item) {
+  
+}
+
+let MarketingDigest_Automation = {
+  M: M,
+  moduleUrl: moduleUrl,
+  OrderingDcbSource: OrderingDcbSource,
+  FromClock: FromClock,
+  FromOrderingDcb: FromOrderingDcb,
+  mappings: mappings,
+  process: process,
+  onExhausted: onExhausted
+};
+
+let include = Automation_GWT$ReventlessGwt.FromSlice(MarketingDigest)({
+  process: process,
+  onExhausted: onExhausted,
+  moduleUrl: moduleUrl,
+  mappings: mappings
+});
+
+let test = include.test;
+
+let Mapping = include.Mapping;
+
+let givenEvents = include.givenEvents;
+
+let whenSweep = include.whenSweep;
+
+let whenTick = include.whenTick;
+
+let thenCommands = include.thenCommands;
+
+let andThenEvents = include.andThenEvents;
+
+let thenSchedules = include.thenSchedules;
+
+let thenScenarioTodos = include.thenScenarioTodos;
+
+let OrderingLog = Mapping(FromOrderingDcb);
+
+let Digest_Route = include.Route;
+
+let Digest_describe = include.describe;
+
+let Digest_testContext = include.testContext;
+
+let Digest_withRecordedAt = include.withRecordedAt;
+
+let Digest_encTodos = include.encTodos;
+
+let Digest_encPair = include.encPair;
+
+let Digest_thenTodos = include.thenTodos;
+
+let Digest_thenResolved = include.thenResolved;
+
+let Digest_givenTodo = include.givenTodo;
+
+let Digest_whenProcess = include.whenProcess;
+
+let Digest_whenExhausted = include.whenExhausted;
+
+let Digest_thenCommand = include.thenCommand;
+
+let Digest_thenNoCommand = include.thenNoCommand;
+
+let Digest_atTime = include.atTime;
+
+let Digest_latestRecorded = include.latestRecorded;
+
+let Digest_routeEach = include.routeEach;
+
+let Digest_routeAll = include.routeAll;
+
+let Digest_foldSchedules = include.foldSchedules;
+
+let Digest_declaredRows = include.declaredRows;
+
+let Digest_sweep = include.sweep;
+
+let Digest_tick = include.tick;
+
+let Digest = {
+  Route: Digest_Route,
+  describe: Digest_describe,
+  test: test,
+  testContext: Digest_testContext,
+  withRecordedAt: Digest_withRecordedAt,
+  encTodos: Digest_encTodos,
+  encPair: Digest_encPair,
+  thenTodos: Digest_thenTodos,
+  thenResolved: Digest_thenResolved,
+  Mapping: Mapping,
+  givenTodo: Digest_givenTodo,
+  whenProcess: Digest_whenProcess,
+  whenExhausted: Digest_whenExhausted,
+  thenCommand: Digest_thenCommand,
+  thenNoCommand: Digest_thenNoCommand,
+  givenEvents: givenEvents,
+  atTime: Digest_atTime,
+  latestRecorded: Digest_latestRecorded,
+  routeEach: Digest_routeEach,
+  routeAll: Digest_routeAll,
+  foldSchedules: Digest_foldSchedules,
+  declaredRows: Digest_declaredRows,
+  sweep: Digest_sweep,
+  whenSweep: whenSweep,
+  tick: Digest_tick,
+  whenTick: whenTick,
+  thenCommands: thenCommands,
+  andThenEvents: andThenEvents,
+  thenSchedules: thenSchedules,
+  thenScenarioTodos: thenScenarioTodos,
+  OrderingLog: OrderingLog
+};
+
+function time(iso) {
+  return new Date(iso).getTime();
+}
+
+let at18 = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 18,
+    minute: 0
+  }
+};
+
+let at730Berlin = {
+  TAG: "Calendar",
+  calendar: {
+    TAG: "Daily",
+    hour: 7,
+    minute: 30
+  },
+  zone: "Europe/Berlin"
+};
+
+JestBind$ReventlessGwt.describe("a schedule per customer: the marketing digest", () => {
+  test("each recipient's choice sets their own schedule", () => thenSchedules(whenSweep(givenEvents([
+    OrderingLog.event({
+      TAG: "DigestTimeChosen",
+      recipientId: "r1",
+      time: at18
+    }, undefined, undefined),
+    OrderingLog.event({
+      TAG: "DigestTimeChosen",
+      recipientId: "r2",
+      time: at730Berlin
+    }, undefined, undefined)
+  ]), undefined, undefined), [
+    [
+      "r1",
+      at18
+    ],
+    [
+      "r2",
+      at730Berlin
+    ]
+  ]));
+  test("a recipient's tick makes their digest, with the item id as reference", () => thenCommands(whenTick(givenEvents([OrderingLog.event({
+      TAG: "DigestTimeChosen",
+      recipientId: "r1",
+      time: at18
+    }, undefined, undefined)]), "r1", new Date("2026-10-16T18:00:00Z").getTime(), undefined), [[
+      "r1",
+      {
+        TAG: "RequestNotification",
+        recipientId: "r1",
+        reference: "r1@2026-10-16T18:00Z"
+      }
+    ]]));
+  test("the request's own event completes the digest", () => thenScenarioTodos(andThenEvents(whenTick(givenEvents([OrderingLog.event({
+      TAG: "DigestTimeChosen",
+      recipientId: "r1",
+      time: at18
+    }, undefined, undefined)]), "r1", new Date("2026-10-16T18:00:00Z").getTime(), undefined), [OrderingLog.event({
+      TAG: "NotificationRequested",
+      recipientId: "r1",
+      reference: "r1@2026-10-16T18:00Z"
+    }, undefined, undefined)], undefined), []));
+  test("unsubscribing from marketing clears the recipient's schedule, and only theirs", () => thenSchedules(whenSweep(givenEvents([
+    OrderingLog.event({
+      TAG: "DigestTimeChosen",
+      recipientId: "r1",
+      time: at18
+    }, undefined, undefined),
+    OrderingLog.event({
+      TAG: "DigestTimeChosen",
+      recipientId: "r2",
+      time: at730Berlin
+    }, undefined, undefined),
+    OrderingLog.event({
+      TAG: "NotificationUnsubscribed",
+      recipientId: "r1",
+      category: "Marketing"
+    }, undefined, undefined),
+    OrderingLog.event({
+      TAG: "NotificationUnsubscribed",
+      recipientId: "r2",
+      category: "Orders"
+    }, undefined, undefined)
+  ]), undefined, undefined), [[
+      "r2",
+      at730Berlin
+    ]]));
+  test("a later choice replaces the earlier one", () => thenSchedules(whenSweep(givenEvents([
+    OrderingLog.event({
+      TAG: "DigestTimeChosen",
+      recipientId: "r1",
+      time: at18
+    }, undefined, undefined),
+    OrderingLog.event({
+      TAG: "DigestTimeChosen",
+      recipientId: "r1",
+      time: at730Berlin
+    }, undefined, undefined)
+  ]), undefined, undefined), [[
+      "r1",
+      at730Berlin
+    ]]));
+});
+
+let todoItemSchema$1 = Sury.$schema(s => ({
+  orderId: s.m(Sury.string)
+}));
+
+let commandSchema$1 = Sury.$schema(s => ({
+  TAG: "RemindOrder",
+  orderId: s.m(Sury.string)
+}));
+
+function authorizationOf$1(param) {
+  return "AllowAuthenticated";
+}
+
+function commandTransition$1(param) {
+  return "Undeclared";
+}
+
+let traits$1 = [];
+
+let Reminder = {
+  name: "OrderReminder",
+  moduleUrl: "",
+  todoItemSchema: todoItemSchema$1,
+  commandSchema: commandSchema$1,
+  maxRetries: 3,
+  heartbeatInterval: 60,
+  targetName: "Order",
+  schedule: undefined,
+  authorizationOf: authorizationOf$1,
+  commandTransition: commandTransition$1,
+  traits: traits$1
+};
+
+let M$1 = AutomationSlice$Reventless.Mappings.Make(Reminder);
+
+let moduleUrl$1 = "";
+
+let name$1 = "OrderingDcbEventLog";
+
+let eventSchema$1 = Sury.union([
+  Sury.$schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(Sury.string)
+  })),
+  Sury.$schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(Sury.string)
+  }))
+]);
+
+let OrderingDcbSource$1 = {
+  Id: undefined,
+  name: name$1,
+  eventSchema: eventSchema$1
+};
+
+function collect$2(param, param$1, _ctx) {
+  let key = param.key;
+  return [[
+      Clock$Reventless.itemId(key, param.at),
+      {
+        orderId: key
+      }
+    ]];
+}
+
+function resolve$2(param) {
+  
+}
+
+function reschedule$2(param) {
+  return [];
+}
+
+let FromClock$1 = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: Clock$Reventless.name,
+  eventSchema: Clock$Reventless.eventSchema
+})(Reminder)({
+  collect: collect$2,
+  resolve: resolve$2,
+  reschedule: reschedule$2
+});
+
+function collect$3(param, param$1, _ctx) {
+  return [];
+}
+
+function resolve$3(param) {
+  
+}
+
+function reschedule$3(event) {
+  if (event.TAG === "OrderPlaced") {
+    return [{
+        TAG: "Set",
+        key: event.orderId,
+        time: {
+          TAG: "Once",
+          moment: {
+            TAG: "After",
+            _0: {
+              TAG: "Minutes",
+              _0: 10
+            }
+          }
+        }
+      }];
+  } else {
+    return [{
+        TAG: "Clear",
+        key: event.orderId
+      }];
+  }
+}
+
+let FromOrdering = AutomationSlice$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name$1,
+  eventSchema: eventSchema$1
+})(Reminder)({
+  collect: collect$3,
+  resolve: resolve$3,
+  reschedule: reschedule$3
+});
+
+let mappings$1 = [
+  FromClock$1,
+  FromOrdering
+];
+
+function process$1(_id, item, param) {
+  return [
+    item.orderId,
+    {
+      TAG: "RemindOrder",
+      orderId: item.orderId
+    }
+  ];
+}
+
+function onExhausted$1(_id, _item) {
+  
+}
+
+let Reminder_Automation = {
+  M: M$1,
+  moduleUrl: moduleUrl$1,
+  OrderingDcbSource: OrderingDcbSource$1,
+  FromClock: FromClock$1,
+  FromOrdering: FromOrdering,
+  mappings: mappings$1,
+  process: process$1,
+  onExhausted: onExhausted$1
+};
+
+let include$1 = Automation_GWT$ReventlessGwt.FromSlice(Reminder)({
+  process: process$1,
+  onExhausted: onExhausted$1,
+  moduleUrl: moduleUrl$1,
+  mappings: mappings$1
+});
+
+let test$1 = include$1.test;
+
+let Mapping$1 = include$1.Mapping;
+
+let givenEvents$1 = include$1.givenEvents;
+
+let whenSweep$1 = include$1.whenSweep;
+
+let whenTick$1 = include$1.whenTick;
+
+let thenCommands$1 = include$1.thenCommands;
+
+let thenSchedules$1 = include$1.thenSchedules;
+
+let OrderingLog$1 = Mapping$1(FromOrdering);
+
+let ReminderGwt_Route = include$1.Route;
+
+let ReminderGwt_describe = include$1.describe;
+
+let ReminderGwt_testContext = include$1.testContext;
+
+let ReminderGwt_withRecordedAt = include$1.withRecordedAt;
+
+let ReminderGwt_encTodos = include$1.encTodos;
+
+let ReminderGwt_encPair = include$1.encPair;
+
+let ReminderGwt_thenTodos = include$1.thenTodos;
+
+let ReminderGwt_thenResolved = include$1.thenResolved;
+
+let ReminderGwt_givenTodo = include$1.givenTodo;
+
+let ReminderGwt_whenProcess = include$1.whenProcess;
+
+let ReminderGwt_whenExhausted = include$1.whenExhausted;
+
+let ReminderGwt_thenCommand = include$1.thenCommand;
+
+let ReminderGwt_thenNoCommand = include$1.thenNoCommand;
+
+let ReminderGwt_atTime = include$1.atTime;
+
+let ReminderGwt_latestRecorded = include$1.latestRecorded;
+
+let ReminderGwt_routeEach = include$1.routeEach;
+
+let ReminderGwt_routeAll = include$1.routeAll;
+
+let ReminderGwt_foldSchedules = include$1.foldSchedules;
+
+let ReminderGwt_declaredRows = include$1.declaredRows;
+
+let ReminderGwt_sweep = include$1.sweep;
+
+let ReminderGwt_tick = include$1.tick;
+
+let ReminderGwt_andThenEvents = include$1.andThenEvents;
+
+let ReminderGwt_thenScenarioTodos = include$1.thenScenarioTodos;
+
+let ReminderGwt = {
+  Route: ReminderGwt_Route,
+  describe: ReminderGwt_describe,
+  test: test$1,
+  testContext: ReminderGwt_testContext,
+  withRecordedAt: ReminderGwt_withRecordedAt,
+  encTodos: ReminderGwt_encTodos,
+  encPair: ReminderGwt_encPair,
+  thenTodos: ReminderGwt_thenTodos,
+  thenResolved: ReminderGwt_thenResolved,
+  Mapping: Mapping$1,
+  givenTodo: ReminderGwt_givenTodo,
+  whenProcess: ReminderGwt_whenProcess,
+  whenExhausted: ReminderGwt_whenExhausted,
+  thenCommand: ReminderGwt_thenCommand,
+  thenNoCommand: ReminderGwt_thenNoCommand,
+  givenEvents: givenEvents$1,
+  atTime: ReminderGwt_atTime,
+  latestRecorded: ReminderGwt_latestRecorded,
+  routeEach: ReminderGwt_routeEach,
+  routeAll: ReminderGwt_routeAll,
+  foldSchedules: ReminderGwt_foldSchedules,
+  declaredRows: ReminderGwt_declaredRows,
+  sweep: ReminderGwt_sweep,
+  whenSweep: whenSweep$1,
+  tick: ReminderGwt_tick,
+  whenTick: whenTick$1,
+  thenCommands: thenCommands$1,
+  andThenEvents: ReminderGwt_andThenEvents,
+  thenSchedules: thenSchedules$1,
+  thenScenarioTodos: ReminderGwt_thenScenarioTodos,
+  OrderingLog: OrderingLog$1
+};
+
+let placedAt = new Date("2026-10-16T09:00:00Z").getTime();
+
+let tenPast = {
+  TAG: "Once",
+  moment: {
+    TAG: "At",
+    _0: {
+      year: 2026,
+      month: 10,
+      day: 16,
+      hour: 9,
+      minute: 10
+    }
+  }
+};
+
+JestBind$ReventlessGwt.describe("a once-only time: the reminder", () => {
+  test$1("is set ten minutes after the order was recorded", () => thenSchedules$1(whenSweep$1(givenEvents$1([OrderingLog$1.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined, placedAt)]), undefined, undefined), [[
+      "o1",
+      tenPast
+    ]]));
+  test$1("is cleared when the order ships", () => thenSchedules$1(whenSweep$1(givenEvents$1([
+    OrderingLog$1.event({
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }, undefined, placedAt),
+    OrderingLog$1.event({
+      TAG: "OrderShipped",
+      orderId: "o1"
+    }, undefined, placedAt + 60000)
+  ]), undefined, undefined), []));
+  test$1("is cleared once it has fired, and its tick sends the reminder", () => {
+    let scenario = whenTick$1(givenEvents$1([OrderingLog$1.event({
+        TAG: "OrderPlaced",
+        orderId: "o1"
+      }, undefined, placedAt)]), "o1", new Date("2026-10-16T09:10:00Z").getTime(), undefined);
+    let failed = thenSchedules$1(scenario, []);
+    if (failed.TAG === "Ok") {
+      return thenCommands$1(scenario, [[
+          "o1",
+          {
+            TAG: "RemindOrder",
+            orderId: "o1"
+          }
+        ]]);
+    } else {
+      return failed;
+    }
+  });
+});
+
+export {
+  MarketingDigest,
+  MarketingDigest_Automation,
+  Digest,
+  time,
+  at18,
+  at730Berlin,
+  Reminder,
+  Reminder_Automation,
+  ReminderGwt,
+  placedAt,
+  tenPast,
+}
+/* todoItemSchema Not a pure module */