@reventlessdev/online-shop-hybrid-ordering 1.0.0-alpha.100

package/tests/Order/OutboundTranslationSlice/SendOrderConfirmation_GWT.res.mjs

@@ -0,0 +1,102 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SendOrderConfirmation$OrderingPlugin from "../../../src/Order/OutboundTranslationSlice/SendOrderConfirmation.res.mjs";
+import * as OutboundTranslation_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/OutboundTranslation_GWT.res.mjs";
+import * as SendOrderConfirmation_Translation$OrderingPlugin from "../../../src/Order/OutboundTranslationSlice/SendOrderConfirmation_Translation.res.mjs";
+
+let SendOrderConfirmationSlice = {
+  name: SendOrderConfirmation$OrderingPlugin.name,
+  Id: SendOrderConfirmation$OrderingPlugin.Id,
+  consumedEventSchema: SendOrderConfirmation$OrderingPlugin.consumedEventSchema,
+  outboundItemSchema: SendOrderConfirmation$OrderingPlugin.outboundItemSchema,
+  inboundCommandSchema: SendOrderConfirmation$OrderingPlugin.inboundCommandSchema,
+  maxRetries: SendOrderConfirmation$OrderingPlugin.maxRetries,
+  heartbeatInterval: SendOrderConfirmation$OrderingPlugin.heartbeatInterval,
+  targetName: undefined,
+  externalSystem: SendOrderConfirmation$OrderingPlugin.externalSystem,
+  moduleUrl: SendOrderConfirmation$OrderingPlugin.moduleUrl,
+  collect: SendOrderConfirmation_Translation$OrderingPlugin.collect
+};
+
+let include = OutboundTranslation_GWT$ReventlessGwt.Make({
+  name: SendOrderConfirmation$OrderingPlugin.name,
+  consumedEventSchema: SendOrderConfirmation$OrderingPlugin.consumedEventSchema,
+  outboundItemSchema: SendOrderConfirmation$OrderingPlugin.outboundItemSchema,
+  inboundCommandSchema: SendOrderConfirmation$OrderingPlugin.inboundCommandSchema,
+  collect: SendOrderConfirmation_Translation$OrderingPlugin.collect
+});
+
+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 whenTranslateMocked = include.whenTranslateMocked;
+
+let thenTodoStatus = include.thenTodoStatus;
+
+describe("SendOrderConfirmation OutboundTranslationSlice", () => {
+  testSync("collect: OrderPlaced queues an outbound TODO", () => thenTodos(whenCollect(givenEvent({
+    TAG: "OrderPlaced",
+    orderId: "o1",
+    customerId: "c1"
+  })), [[
+      "o1",
+      {
+        orderId: "o1",
+        customerId: "c1"
+      }
+    ]]));
+  test("translate success marks the TODO Completed", undefined, () => thenTodoStatus(whenTranslateMocked(givenTodo("o1", {
+    orderId: "o1",
+    customerId: "c1"
+  }), (_id, _item) => Promise.resolve({
+    TAG: "Ok",
+    _0: undefined
+  })), "o1", "Completed"));
+  test("translate failure leaves the TODO Pending for retry", undefined, () => thenTodoStatus(whenTranslateMocked(givenTodo("o1", {
+    orderId: "o1",
+    customerId: "c1"
+  }), (_id, _item) => Promise.resolve({
+    TAG: "Error",
+    _0: "smtp down"
+  })), "o1", "Pending"));
+});
+
+let Spec = include.Spec;
+
+let whenTranslateRetrying = include.whenTranslateRetrying;
+
+let thenCommand = include.thenCommand;
+
+let thenNoCommand = include.thenNoCommand;
+
+let thenRetryRecorded = include.thenRetryRecorded;
+
+export {
+  SendOrderConfirmationSlice,
+  Spec,
+  describe,
+  test,
+  testSync,
+  givenEvent,
+  whenCollect,
+  thenTodos,
+  givenTodo,
+  whenTranslateMocked,
+  whenTranslateRetrying,
+  thenCommand,
+  thenNoCommand,
+  thenRetryRecorded,
+  thenTodoStatus,
+}
+/* include Not a pure module */

package/tests/Order/StateChangeSlice/CancelOrder_GWT.res

@@ -0,0 +1,45 @@
+@@reventless.gwt
+
+describe("CancelOrder StateChangeSlice", () => {
+  test("non-existent order returns OrderNotFound for CancelOrder", () =>
+    givenEvents([])
+    ->whenCmd(CancelOrder({orderId: "o1"}))
+    ->thenError(OrderNotFound)
+  )
+
+  test("placed order produces OrderCancelled with productIds carried over", () =>
+    givenEvents([OrderPlaced({productIds: ["p1", "p2"]})])
+    ->whenCmd(CancelOrder({orderId: "o1"}))
+    ->thenEvent(OrderCancelled({orderId: "o1", productIds: ["p1", "p2"]}))
+  )
+
+  test("already cancelled order produces no events for CancelOrder (idempotent)", () =>
+    givenEvents([OrderPlaced({productIds: ["p1"]}), OrderCancelled])
+    ->whenCmd(CancelOrder({orderId: "o1"}))
+    ->thenNoEvent
+  )
+
+  test("shipped order returns OrderAlreadyShipped for CancelOrder", () =>
+    givenEvents([OrderPlaced({productIds: ["p1"]}), OrderShipped])
+    ->whenCmd(CancelOrder({orderId: "o1"}))
+    ->thenError(OrderAlreadyShipped)
+  )
+
+  test("ReopenOrder on cancelled order produces OrderReopened", () =>
+    givenEvents([OrderPlaced({productIds: ["p1"]}), OrderCancelled])
+    ->whenCmd(ReopenOrder({orderId: "o1"}))
+    ->thenEvent(OrderReopened({orderId: "o1"}))
+  )
+
+  test("ReopenOrder on non-cancelled order produces no events (idempotent)", () =>
+    givenEvents([OrderPlaced({productIds: ["p1"]})])
+    ->whenCmd(ReopenOrder({orderId: "o1"}))
+    ->thenNoEvent
+  )
+
+  test("ReopenOrder on non-existent order returns OrderNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ReopenOrder({orderId: "o1"}))
+    ->thenError(OrderNotFound)
+  )
+})

package/tests/Order/StateChangeSlice/CancelOrder_GWT.res.mjs

@@ -0,0 +1,131 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Behavior_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Behavior_GWT.res.mjs";
+import * as CancelOrder$OrderingPlugin from "../../../src/Order/StateChangeSlice/CancelOrder.res.mjs";
+import * as CancelOrder_Behavior$OrderingPlugin from "../../../src/Order/StateChangeSlice/CancelOrder_Behavior.res.mjs";
+
+let include = Behavior_GWT$ReventlessGwt.Make({
+  name: CancelOrder$OrderingPlugin.name,
+  consumedEventSchema: CancelOrder$OrderingPlugin.consumedEventSchema,
+  commandSchema: CancelOrder$OrderingPlugin.commandSchema,
+  errorSchema: CancelOrder$OrderingPlugin.errorSchema,
+  eventSchema: CancelOrder$OrderingPlugin.eventSchema
+})({
+  initialState: CancelOrder_Behavior$OrderingPlugin.initialState,
+  evolve: CancelOrder_Behavior$OrderingPlugin.evolve,
+  decide: CancelOrder_Behavior$OrderingPlugin.decide
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenCmd = include.whenCmd;
+
+let thenEvent = include.thenEvent;
+
+let thenNoEvent = include.thenNoEvent;
+
+let thenError = include.thenError;
+
+describe("CancelOrder StateChangeSlice", () => {
+  test("non-existent order returns OrderNotFound for CancelOrder", () => thenError(whenCmd(givenEvents([]), {
+    TAG: "CancelOrder",
+    orderId: "o1"
+  }), "OrderNotFound"));
+  test("placed order produces OrderCancelled with productIds carried over", () => thenEvent(whenCmd(givenEvents([{
+      TAG: "OrderPlaced",
+      productIds: [
+        "p1",
+        "p2"
+      ]
+    }]), {
+    TAG: "CancelOrder",
+    orderId: "o1"
+  }), {
+    TAG: "OrderCancelled",
+    orderId: "o1",
+    productIds: [
+      "p1",
+      "p2"
+    ]
+  }));
+  test("already cancelled order produces no events for CancelOrder (idempotent)", () => thenNoEvent(whenCmd(givenEvents([
+    {
+      TAG: "OrderPlaced",
+      productIds: ["p1"]
+    },
+    "OrderCancelled"
+  ]), {
+    TAG: "CancelOrder",
+    orderId: "o1"
+  })));
+  test("shipped order returns OrderAlreadyShipped for CancelOrder", () => thenError(whenCmd(givenEvents([
+    {
+      TAG: "OrderPlaced",
+      productIds: ["p1"]
+    },
+    "OrderShipped"
+  ]), {
+    TAG: "CancelOrder",
+    orderId: "o1"
+  }), "OrderAlreadyShipped"));
+  test("ReopenOrder on cancelled order produces OrderReopened", () => thenEvent(whenCmd(givenEvents([
+    {
+      TAG: "OrderPlaced",
+      productIds: ["p1"]
+    },
+    "OrderCancelled"
+  ]), {
+    TAG: "ReopenOrder",
+    orderId: "o1"
+  }), {
+    TAG: "OrderReopened",
+    orderId: "o1"
+  }));
+  test("ReopenOrder on non-cancelled order produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([{
+      TAG: "OrderPlaced",
+      productIds: ["p1"]
+    }]), {
+    TAG: "ReopenOrder",
+    orderId: "o1"
+  })));
+  test("ReopenOrder on non-existent order returns OrderNotFound", () => thenError(whenCmd(givenEvents([]), {
+    TAG: "ReopenOrder",
+    orderId: "o1"
+  }), "OrderNotFound"));
+});
+
+let Spec = include.Spec;
+
+let todo = include.todo;
+
+let thenEvents = include.thenEvents;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
+
+let thenAppendsConditionedOnExactly = include.thenAppendsConditionedOnExactly;
+
+export {
+  Spec,
+  describe,
+  todo,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenEvents,
+  thenNoEvent,
+  thenEventWithError,
+  thenEventsWithError,
+  thenError,
+  thenAppendsConditionedOn,
+  thenAppendsConditionedOnExactly,
+}
+/* include Not a pure module */

package/tests/Order/StateChangeSlice/PlaceOrder_GWT.res

@@ -0,0 +1,33 @@
+@@reventless.gwt
+
+describe("PlaceOrder StateChangeSlice", () => {
+  test("requires referenced products to be synced first", () =>
+    givenEvents([])
+    ->whenCmd(PlaceOrder({orderId: "o1", customerId: "c1", productIds: ["p1"]}))
+    ->thenError(ProductsNotAvailable({missing: ["p1"]}))
+  )
+
+  test("placement succeeds when products are available", () =>
+    givenEvents([CatalogProductSynced({productId: "p1"})])
+    ->whenCmd(PlaceOrder({orderId: "o1", customerId: "c1", productIds: ["p1"]}))
+    ->thenEvent(OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1"]}))
+  )
+
+  test("partial product availability returns ProductsNotAvailable with missing list", () =>
+    givenEvents([CatalogProductSynced({productId: "p1"})])
+    ->whenCmd(PlaceOrder({orderId: "o1", customerId: "c1", productIds: ["p1", "p2"]}))
+    ->thenError(ProductsNotAvailable({missing: ["p2"]}))
+  )
+
+  test("re-placing the same orderId returns OrderAlreadyPlaced", () =>
+    givenEvents([CatalogProductSynced({productId: "p1"}), OrderPlaced({orderId: "o1"})])
+    ->whenCmd(PlaceOrder({orderId: "o1", customerId: "c1", productIds: ["p1"]}))
+    ->thenError(OrderAlreadyPlaced)
+  )
+
+  test("a sibling OrderPlaced for a different orderId does not block placement", () =>
+    givenEvents([CatalogProductSynced({productId: "p1"}), OrderPlaced({orderId: "o2"})])
+    ->whenCmd(PlaceOrder({orderId: "o1", customerId: "c1", productIds: ["p1"]}))
+    ->thenEvent(OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1"]}))
+  )
+})

package/tests/Order/StateChangeSlice/PlaceOrder_GWT.res.mjs

@@ -0,0 +1,139 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as PlaceOrder$OrderingPlugin from "../../../src/Order/StateChangeSlice/PlaceOrder.res.mjs";
+import * as Behavior_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Behavior_GWT.res.mjs";
+import * as PlaceOrder_Behavior$OrderingPlugin from "../../../src/Order/StateChangeSlice/PlaceOrder_Behavior.res.mjs";
+
+let include = Behavior_GWT$ReventlessGwt.Make({
+  name: PlaceOrder$OrderingPlugin.name,
+  consumedEventSchema: PlaceOrder$OrderingPlugin.consumedEventSchema,
+  commandSchema: PlaceOrder$OrderingPlugin.commandSchema,
+  errorSchema: PlaceOrder$OrderingPlugin.errorSchema,
+  eventSchema: PlaceOrder$OrderingPlugin.eventSchema
+})({
+  initialState: PlaceOrder_Behavior$OrderingPlugin.initialState,
+  evolve: PlaceOrder_Behavior$OrderingPlugin.evolve,
+  decide: PlaceOrder_Behavior$OrderingPlugin.decide
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenCmd = include.whenCmd;
+
+let thenEvent = include.thenEvent;
+
+let thenError = include.thenError;
+
+describe("PlaceOrder StateChangeSlice", () => {
+  test("requires referenced products to be synced first", () => thenError(whenCmd(givenEvents([]), {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    customerId: "c1",
+    productIds: ["p1"]
+  }), {
+    TAG: "ProductsNotAvailable",
+    missing: ["p1"]
+  }));
+  test("placement succeeds when products are available", () => thenEvent(whenCmd(givenEvents([{
+      TAG: "CatalogProductSynced",
+      productId: "p1"
+    }]), {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    customerId: "c1",
+    productIds: ["p1"]
+  }), {
+    TAG: "OrderPlaced",
+    orderId: "o1",
+    customerId: "c1",
+    productIds: ["p1"]
+  }));
+  test("partial product availability returns ProductsNotAvailable with missing list", () => thenError(whenCmd(givenEvents([{
+      TAG: "CatalogProductSynced",
+      productId: "p1"
+    }]), {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    customerId: "c1",
+    productIds: [
+      "p1",
+      "p2"
+    ]
+  }), {
+    TAG: "ProductsNotAvailable",
+    missing: ["p2"]
+  }));
+  test("re-placing the same orderId returns OrderAlreadyPlaced", () => thenError(whenCmd(givenEvents([
+    {
+      TAG: "CatalogProductSynced",
+      productId: "p1"
+    },
+    {
+      TAG: "OrderPlaced",
+      orderId: "o1"
+    }
+  ]), {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    customerId: "c1",
+    productIds: ["p1"]
+  }), "OrderAlreadyPlaced"));
+  test("a sibling OrderPlaced for a different orderId does not block placement", () => thenEvent(whenCmd(givenEvents([
+    {
+      TAG: "CatalogProductSynced",
+      productId: "p1"
+    },
+    {
+      TAG: "OrderPlaced",
+      orderId: "o2"
+    }
+  ]), {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    customerId: "c1",
+    productIds: ["p1"]
+  }), {
+    TAG: "OrderPlaced",
+    orderId: "o1",
+    customerId: "c1",
+    productIds: ["p1"]
+  }));
+});
+
+let Spec = include.Spec;
+
+let todo = include.todo;
+
+let thenEvents = include.thenEvents;
+
+let thenNoEvent = include.thenNoEvent;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
+
+let thenAppendsConditionedOnExactly = include.thenAppendsConditionedOnExactly;
+
+export {
+  Spec,
+  describe,
+  todo,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenEvents,
+  thenNoEvent,
+  thenEventWithError,
+  thenEventsWithError,
+  thenError,
+  thenAppendsConditionedOn,
+  thenAppendsConditionedOnExactly,
+}
+/* include Not a pure module */

package/tests/Order/StateChangeSlice/RefundOrder_GWT.res

@@ -0,0 +1,31 @@
+@@reventless.gwt
+
+describe("RefundOrder StateChangeSlice", () => {
+  test("non-existent order returns OrderNotFound", () =>
+    givenEvents([])
+    ->whenCmd(IssueRefund({orderId: "o1", reason: "duplicate"}))
+    ->thenError(OrderNotFound)
+  )
+
+  test("non-cancelled order returns OrderNotCancelled", () =>
+    givenEvents([OrderPlaced])
+    ->whenCmd(IssueRefund({orderId: "o1", reason: "duplicate"}))
+    ->thenError(OrderNotCancelled)
+  )
+
+  test("cancelled order produces RefundIssued", () =>
+    givenEvents([OrderPlaced, OrderCancelled])
+    ->whenCmd(IssueRefund({orderId: "o1", reason: "duplicate"}))
+    ->thenEvent(RefundIssued({orderId: "o1", reason: "duplicate"}))
+  )
+
+  test("already refunded order returns RefundAlreadyIssued", () =>
+    givenEvents([
+      OrderPlaced,
+      OrderCancelled,
+      RefundIssued({reason: "duplicate"}),
+    ])
+    ->whenCmd(IssueRefund({orderId: "o1", reason: "again"}))
+    ->thenError(RefundAlreadyIssued)
+  )
+})

package/tests/Order/StateChangeSlice/RefundOrder_GWT.res.mjs

@@ -0,0 +1,100 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Behavior_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Behavior_GWT.res.mjs";
+import * as RefundOrder$OrderingPlugin from "../../../src/Order/StateChangeSlice/RefundOrder.res.mjs";
+import * as RefundOrder_Behavior$OrderingPlugin from "../../../src/Order/StateChangeSlice/RefundOrder_Behavior.res.mjs";
+
+let include = Behavior_GWT$ReventlessGwt.Make({
+  name: RefundOrder$OrderingPlugin.name,
+  consumedEventSchema: RefundOrder$OrderingPlugin.consumedEventSchema,
+  commandSchema: RefundOrder$OrderingPlugin.commandSchema,
+  errorSchema: RefundOrder$OrderingPlugin.errorSchema,
+  eventSchema: RefundOrder$OrderingPlugin.eventSchema
+})({
+  initialState: RefundOrder_Behavior$OrderingPlugin.initialState,
+  evolve: RefundOrder_Behavior$OrderingPlugin.evolve,
+  decide: RefundOrder_Behavior$OrderingPlugin.decide
+});
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvents = include.givenEvents;
+
+let whenCmd = include.whenCmd;
+
+let thenEvent = include.thenEvent;
+
+let thenError = include.thenError;
+
+describe("RefundOrder StateChangeSlice", () => {
+  test("non-existent order returns OrderNotFound", () => thenError(whenCmd(givenEvents([]), {
+    TAG: "IssueRefund",
+    orderId: "o1",
+    reason: "duplicate"
+  }), "OrderNotFound"));
+  test("non-cancelled order returns OrderNotCancelled", () => thenError(whenCmd(givenEvents(["OrderPlaced"]), {
+    TAG: "IssueRefund",
+    orderId: "o1",
+    reason: "duplicate"
+  }), "OrderNotCancelled"));
+  test("cancelled order produces RefundIssued", () => thenEvent(whenCmd(givenEvents([
+    "OrderPlaced",
+    "OrderCancelled"
+  ]), {
+    TAG: "IssueRefund",
+    orderId: "o1",
+    reason: "duplicate"
+  }), {
+    TAG: "RefundIssued",
+    orderId: "o1",
+    reason: "duplicate"
+  }));
+  test("already refunded order returns RefundAlreadyIssued", () => thenError(whenCmd(givenEvents([
+    "OrderPlaced",
+    "OrderCancelled",
+    {
+      TAG: "RefundIssued",
+      reason: "duplicate"
+    }
+  ]), {
+    TAG: "IssueRefund",
+    orderId: "o1",
+    reason: "again"
+  }), "RefundAlreadyIssued"));
+});
+
+let Spec = include.Spec;
+
+let todo = include.todo;
+
+let thenEvents = include.thenEvents;
+
+let thenNoEvent = include.thenNoEvent;
+
+let thenEventWithError = include.thenEventWithError;
+
+let thenEventsWithError = include.thenEventsWithError;
+
+let thenAppendsConditionedOn = include.thenAppendsConditionedOn;
+
+let thenAppendsConditionedOnExactly = include.thenAppendsConditionedOnExactly;
+
+export {
+  Spec,
+  describe,
+  todo,
+  test,
+  givenEvents,
+  whenCmd,
+  thenEvent,
+  thenEvents,
+  thenNoEvent,
+  thenEventWithError,
+  thenEventsWithError,
+  thenError,
+  thenAppendsConditionedOn,
+  thenAppendsConditionedOnExactly,
+}
+/* include Not a pure module */

package/tests/Order/StateChangeSlice/ShipOrder_GWT.res

@@ -0,0 +1,27 @@
+@@reventless.gwt
+
+describe("ShipOrder StateChangeSlice", () => {
+  test("non-existent order returns OrderNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ShipOrder({orderId: "o1"}))
+    ->thenError(OrderNotFound)
+  )
+
+  test("placed order produces OrderShipped", () =>
+    givenEvents([OrderPlaced])
+    ->whenCmd(ShipOrder({orderId: "o1"}))
+    ->thenEvent(OrderShipped({orderId: "o1"}))
+  )
+
+  test("already shipped order produces no events (idempotent)", () =>
+    givenEvents([OrderPlaced, OrderShipped])
+    ->whenCmd(ShipOrder({orderId: "o1"}))
+    ->thenNoEvent
+  )
+
+  test("cancelled order returns OrderAlreadyCancelled", () =>
+    givenEvents([OrderPlaced, OrderCancelled])
+    ->whenCmd(ShipOrder({orderId: "o1"}))
+    ->thenError(OrderAlreadyCancelled)
+  )
+})