@reventlessdev/online-shop-dcb-ordering 1.0.0-alpha.103

package/lib/bs/src/Order/OutboundTranslationSlice/SendOrderConfirmation.res

@@ -0,0 +1,19 @@
+// SendOrderConfirmation OutboundTranslationSlice.
+// When OrderPlaced is emitted, sends a confirmation email via EmailService.
+// Fire-and-forget pattern (no inbound command).
+
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | OrderPlaced({orderId: string, customerId: string})
+
+@schema
+type outboundItem = {orderId: string, customerId: string}
+
+@schema
+type inboundCommand = unit
+
+let maxRetries = 3
+let heartbeatInterval = 60
+let targetName = None

package/lib/bs/src/Order/OutboundTranslationSlice/SendOrderConfirmation.res.mjs

@@ -0,0 +1,42 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+
+let consumedEventSchema = S.schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(DcbTag$Reventless.string),
+  customerId: s.m(DcbTag$Reventless.string)
+}));
+
+let outboundItemSchema = S.schema(s => ({
+  orderId: s.m(S.string),
+  customerId: s.m(S.string)
+}));
+
+let name = "SendOrderConfirmation";
+
+let Id;
+
+let inboundCommandSchema = S.unit;
+
+let maxRetries = 3;
+
+let heartbeatInterval = 60;
+
+let targetName;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-ordering/src/Order/OutboundTranslationSlice/SendOrderConfirmation.res.mjs";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  outboundItemSchema,
+  inboundCommandSchema,
+  maxRetries,
+  heartbeatInterval,
+  targetName,
+  moduleUrl,
+}
+/* consumedEventSchema Not a pure module */

package/lib/bs/src/Order/OutboundTranslationSlice/SendOrderConfirmation_Translation.res

@@ -0,0 +1,24 @@
+@@reventless.translation
+
+let collect = event =>
+  switch event {
+  | OrderPlaced({orderId, customerId}) => [(orderId, {orderId, customerId})]
+  }
+
+let translate = async (_id, item) => {
+  try {
+    await EmailService.sendOrderConfirmation(
+      ~email=item.customerId,
+      ~orderId=item.orderId,
+    )
+    Ok(None)
+  } catch {
+  | exn =>
+    let msg =
+      exn
+      ->JsExn.fromException
+      ->Option.flatMap(JsExn.message)
+      ->Option.getOr("email send failed")
+    Error(msg)
+  }
+}

package/lib/bs/src/Order/OutboundTranslationSlice/SendOrderConfirmation_Translation.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as EmailService$OrderingPlugin from "../../Service/EmailService.res.mjs";
+
+function collect(event) {
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId,
+        customerId: event.customerId
+      }
+    ]];
+}
+
+async function translate(_id, item) {
+  try {
+    await EmailService$OrderingPlugin.sendOrderConfirmation(item.customerId, item.orderId);
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "email send failed");
+    return {
+      TAG: "Error",
+      _0: msg
+    };
+  }
+}
+
+let Spec;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-ordering/src/Order/OutboundTranslationSlice/SendOrderConfirmation_Translation.res.mjs";
+
+export {
+  Spec,
+  collect,
+  translate,
+  moduleUrl,
+}
+/* Stdlib_JsExn Not a pure module */

package/lib/bs/src/Order/StateChangeSlice/CancelOrder.res

@@ -0,0 +1,24 @@
+// CancelOrder StateChangeSlice.
+// Requires order to exist and not be shipped; idempotent if already cancelled.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | OrderPlaced({productIds: array<string>})
+  | OrderShipped
+  | OrderCancelled
+
+@schema
+type command =
+  | @allowedStates([Orders.Placed]) CancelOrder({orderId: string})
+
+@schema
+type error =
+  | OrderNotFound
+  | OrderAlreadyShipped
+
+@schema
+type event = OrderCancelled({
+  @partitionTag orderId: string,
+  productIds: array<string>,
+})

package/lib/bs/src/Order/StateChangeSlice/CancelOrder.res.mjs

@@ -0,0 +1,60 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    productIds: s.m(S.array(DcbTag$Reventless.stringForKey("productId")))
+  })),
+  S.literal("OrderShipped"),
+  S.literal("OrderCancelled")
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "CancelOrder",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let errorSchema = S.union([
+  S.literal("OrderNotFound"),
+  S.literal("OrderAlreadyShipped")
+]);
+
+let eventSchema = S.schema(s => ({
+  TAG: "OrderCancelled",
+  orderId: s.m(DcbTag$Reventless.partition),
+  productIds: s.m(S.array(DcbTag$Reventless.stringForKey("productId")))
+}));
+
+let commandSchema$1 = Api$ReventlessInfra.markAllowedStates(commandSchema, [[
+    "CancelOrder",
+    ["Placed"]
+  ]]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "CancelOrder";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-ordering/src/Order/StateChangeSlice/CancelOrder.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  errorSchema,
+  eventSchema,
+  commandSchema$1 as commandSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */

package/lib/bs/src/Order/StateChangeSlice/CancelOrder_Behavior.res

@@ -0,0 +1,26 @@
+@@reventless.behavior
+
+type state = {exists: bool, shipped: bool, cancelled: bool, productIds: array<string>}
+
+let initialState = {exists: false, shipped: false, cancelled: false, productIds: []}
+
+let evolve = (state, event) =>
+  switch event {
+  | OrderPlaced({productIds}) => {exists: true, shipped: false, cancelled: false, productIds}
+  | OrderShipped => {...state, shipped: true}
+  | OrderCancelled => {...state, cancelled: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | CancelOrder({orderId: theId}) =>
+    if !state.exists {
+      Error(OrderNotFound)
+    } else if state.shipped {
+      Error(OrderAlreadyShipped)
+    } else if state.cancelled {
+      Ok([]) // idempotent — already cancelled
+    } else {
+      Ok([OrderCancelled({orderId: theId, productIds: state.productIds})])
+    }
+  }

package/lib/bs/src/Order/StateChangeSlice/CancelOrder_Behavior.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let initialState_productIds = [];
+
+let initialState = {
+  exists: false,
+  shipped: false,
+  cancelled: false,
+  productIds: initialState_productIds
+};
+
+function evolve(state, event) {
+  if (typeof event !== "object") {
+    if (event === "OrderShipped") {
+      return {
+        exists: state.exists,
+        shipped: true,
+        cancelled: state.cancelled,
+        productIds: state.productIds
+      };
+    } else {
+      return {
+        exists: state.exists,
+        shipped: state.shipped,
+        cancelled: true,
+        productIds: state.productIds
+      };
+    }
+  } else {
+    return {
+      exists: true,
+      shipped: false,
+      cancelled: false,
+      productIds: event.productIds
+    };
+  }
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    if (state.shipped) {
+      return {
+        TAG: "Error",
+        _0: "OrderAlreadyShipped"
+      };
+    } else if (state.cancelled) {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "OrderCancelled",
+            orderId: command.orderId,
+            productIds: state.productIds
+          }]
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: "OrderNotFound"
+    };
+  }
+}
+
+let Spec;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-ordering/src/Order/StateChangeSlice/CancelOrder_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/lib/bs/src/Order/StateChangeSlice/PlaceOrder.res

@@ -0,0 +1,33 @@
+// PlaceOrder StateChangeSlice.
+// Handles the PlaceOrder command; rejects duplicate placement and validates
+// that all referenced products have been synced to the ordering event log.
+//
+// The tagged array `productIds: array<string>` triggers automatic multi-clause
+// query construction: one OR clause per orderId and per productId element —
+// fetching both Order and CatalogProduct events. The plural field name is
+// auto-singularised by the PPX so each element is stored under tag key
+// `productId`, sharing the key with single-value `productId: string` producers.
+
+@@reventless.spec
+
+// `OrderPlaced` carries `orderId` (not partial) so the decision model can
+// discriminate placements across the multi-clause query. Without it,
+// OrderPlaced events from sibling orders that share a `productId` tag would
+// leak in and falsely set "this order exists".
+@schema
+type consumedEvent =
+  | OrderPlaced({orderId: string})
+  | CatalogProductSynced({productId: string})
+
+@schema
+type command =
+  PlaceOrder({@partitionTag orderId: string, customerId: string, @ref("AvailableProducts") productIds: array<string>})
+
+@schema
+type error =
+  | OrderAlreadyPlaced
+  | ProductsNotAvailable({missing: array<string>})
+
+@schema
+type event =
+  OrderPlaced({@partitionTag orderId: string, customerId: string, productIds: array<string>})

package/lib/bs/src/Order/StateChangeSlice/PlaceOrder.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "CatalogProductSynced",
+    productId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "PlaceOrder",
+  orderId: s.m(DcbTag$Reventless.partition),
+  customerId: s.m(DcbTag$Reventless.string),
+  productIds: s.m(S.array(Reference$Reventless.to_(undefined, "productId", "AvailableProducts")))
+}));
+
+let errorSchema = S.union([
+  S.literal("OrderAlreadyPlaced"),
+  S.schema(s => ({
+    TAG: "ProductsNotAvailable",
+    missing: s.m(S.array(S.string))
+  }))
+]);
+
+let eventSchema = S.schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(DcbTag$Reventless.partition),
+  customerId: s.m(DcbTag$Reventless.string),
+  productIds: s.m(S.array(DcbTag$Reventless.stringForKey("productId")))
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "PlaceOrder";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-ordering/src/Order/StateChangeSlice/PlaceOrder.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */

package/lib/bs/src/Order/StateChangeSlice/PlaceOrder_Behavior.res

@@ -0,0 +1,44 @@
+@@reventless.behavior
+
+// `placedOrderIds` tracks every OrderPlaced the query returned (regardless of
+// orderId — the multi-clause query also fetches by productId tags), so the
+// `decide` step can ask "is THIS particular orderId already placed?" without
+// being confused by OrderPlaced events from sibling orders sharing a product.
+//
+// Stored as immutable arrays (rather than `Set.t`) so each fold yields a
+// fresh state — `evolve` returns a new record instead of mutating a shared
+// one. This keeps successive `decide` calls (and unit tests) hermetic.
+type state = {placedOrderIds: array<string>, availableProductIds: array<string>}
+
+let initialState = {placedOrderIds: [], availableProductIds: []}
+
+let evolve = (state, event: consumedEvent) =>
+  switch event {
+  | OrderPlaced({orderId}) => {
+      ...state,
+      placedOrderIds: state.placedOrderIds->Array.includes(orderId)
+        ? state.placedOrderIds
+        : Array.concat(state.placedOrderIds, [orderId]),
+    }
+  | CatalogProductSynced({productId}) => {
+      ...state,
+      availableProductIds: state.availableProductIds->Array.includes(productId)
+        ? state.availableProductIds
+        : Array.concat(state.availableProductIds, [productId]),
+    }
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | PlaceOrder({orderId, customerId, productIds}) =>
+    if state.placedOrderIds->Array.includes(orderId) {
+      Error(OrderAlreadyPlaced)
+    } else {
+      let missing = productIds->Array.filter(pid => !(state.availableProductIds->Array.includes(pid)))
+      if missing->Array.length > 0 {
+        Error(ProductsNotAvailable({missing: missing}))
+      } else {
+        Ok([OrderPlaced({orderId, customerId, productIds})])
+      }
+    }
+  }

package/lib/bs/src/Order/StateChangeSlice/PlaceOrder_Behavior.res.mjs

@@ -0,0 +1,70 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let initialState_placedOrderIds = [];
+
+let initialState_availableProductIds = [];
+
+let initialState = {
+  placedOrderIds: initialState_placedOrderIds,
+  availableProductIds: initialState_availableProductIds
+};
+
+function evolve(state, event) {
+  if (event.TAG === "OrderPlaced") {
+    let orderId = event.orderId;
+    return {
+      placedOrderIds: state.placedOrderIds.includes(orderId) ? state.placedOrderIds : state.placedOrderIds.concat([orderId]),
+      availableProductIds: state.availableProductIds
+    };
+  }
+  let productId = event.productId;
+  return {
+    placedOrderIds: state.placedOrderIds,
+    availableProductIds: state.availableProductIds.includes(productId) ? state.availableProductIds : state.availableProductIds.concat([productId])
+  };
+}
+
+function decide(state, command) {
+  let orderId = command.orderId;
+  if (state.placedOrderIds.includes(orderId)) {
+    return {
+      TAG: "Error",
+      _0: "OrderAlreadyPlaced"
+    };
+  }
+  let productIds = command.productIds;
+  let missing = productIds.filter(pid => !state.availableProductIds.includes(pid));
+  if (missing.length !== 0) {
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "ProductsNotAvailable",
+        missing: missing
+      }
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "OrderPlaced",
+          orderId: orderId,
+          customerId: command.customerId,
+          productIds: productIds
+        }]
+    };
+  }
+}
+
+let Spec;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-ordering/src/Order/StateChangeSlice/PlaceOrder_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/lib/bs/src/Order/StateChangeSlice/ShipOrder.res

@@ -0,0 +1,21 @@
+// ShipOrder StateChangeSlice.
+// Requires order to exist and not be cancelled; idempotent if already shipped.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | OrderPlaced
+  | OrderShipped
+  | OrderCancelled
+
+@schema
+type command =
+  | @allowedStates([Orders.Placed]) ShipOrder({orderId: string})
+
+@schema
+type error =
+  | OrderNotFound
+  | OrderAlreadyCancelled
+
+@schema
+type event = OrderShipped({orderId: string})

package/lib/bs/src/Order/StateChangeSlice/ShipOrder.res.mjs

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.literal("OrderPlaced"),
+  S.literal("OrderShipped"),
+  S.literal("OrderCancelled")
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "ShipOrder",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let errorSchema = S.union([
+  S.literal("OrderNotFound"),
+  S.literal("OrderAlreadyCancelled")
+]);
+
+let eventSchema = S.schema(s => ({
+  TAG: "OrderShipped",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let commandSchema$1 = Api$ReventlessInfra.markAllowedStates(commandSchema, [[
+    "ShipOrder",
+    ["Placed"]
+  ]]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "ShipOrder";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-ordering/src/Order/StateChangeSlice/ShipOrder.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  errorSchema,
+  eventSchema,
+  commandSchema$1 as commandSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */