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

package/src/Order/StateChangeSlice/PlaceOrder.res

@@ -0,0 +1,28 @@
+// PlaceOrder StateChangeSlice.
+// Rejects duplicate placement and validates that all referenced products are
+// available (synced to the ordering event log).
+
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | OrderPlaced({orderId: string})
+  | CatalogProductSynced({productId: string})
+
+@schema
+type command =
+  PlaceOrder({
+    @partitionTag orderId: string,
+    // customerId is payload, not a query key — @noDcbTag stops it auto-tagging.
+    @noDcbTag 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/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(S.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-hybrid-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/src/Order/StateChangeSlice/PlaceOrder_Behavior.res

@@ -0,0 +1,39 @@
+@@reventless.behavior
+
+// 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/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-hybrid-ordering/src/Order/StateChangeSlice/PlaceOrder_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/src/Order/StateChangeSlice/RefundOrder.res

@@ -0,0 +1,27 @@
+// RefundOrder StateChangeSlice.
+// Handles internal refund processing — entirely hidden from public API.
+// This is an automation/admin-only workflow triggered after cancellation.
+
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | OrderPlaced
+  | OrderCancelled
+  | RefundIssued({reason: string})
+
+@schema @noApi
+type command = IssueRefund({orderId: string, reason: string})
+
+@schema
+type error =
+  | OrderNotFound
+  | OrderNotCancelled
+  | RefundAlreadyIssued
+
+@schema
+type event =
+  | RefundIssued({
+      orderId: string,
+      reason: string,
+    })

package/src/Order/StateChangeSlice/RefundOrder.res.mjs

@@ -0,0 +1,59 @@
+// 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("OrderCancelled"),
+  S.schema(s => ({
+    TAG: "RefundIssued",
+    reason: s.m(S.string)
+  }))
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "IssueRefund",
+  orderId: s.m(DcbTag$Reventless.string),
+  reason: s.m(S.string)
+}));
+
+let errorSchema = S.union([
+  S.literal("OrderNotFound"),
+  S.literal("OrderNotCancelled"),
+  S.literal("RefundAlreadyIssued")
+]);
+
+let eventSchema = S.schema(s => ({
+  TAG: "RefundIssued",
+  orderId: s.m(DcbTag$Reventless.string),
+  reason: s.m(S.string)
+}));
+
+let commandSchema$1 = Api$ReventlessInfra.markNoApi(commandSchema);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "RefundOrder";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Order/StateChangeSlice/RefundOrder.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  errorSchema,
+  eventSchema,
+  commandSchema$1 as commandSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */

package/src/Order/StateChangeSlice/RefundOrder_Behavior.res

@@ -0,0 +1,26 @@
+@@reventless.behavior
+
+type state = {exists: bool, cancelled: bool, refunded: bool}
+
+let initialState = {exists: false, cancelled: false, refunded: false}
+
+let evolve = (state, event) =>
+  switch event {
+  | OrderPlaced => {exists: true, cancelled: false, refunded: false}
+  | OrderCancelled => {...state, cancelled: true}
+  | RefundIssued(_) => {...state, refunded: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | IssueRefund({orderId, reason}) =>
+    if !state.exists {
+      Error(OrderNotFound)
+    } else if !state.cancelled {
+      Error(OrderNotCancelled)
+    } else if state.refunded {
+      Error(RefundAlreadyIssued)
+    } else {
+      Ok([RefundIssued({orderId, reason})])
+    }
+  }

package/src/Order/StateChangeSlice/RefundOrder_Behavior.res.mjs

@@ -0,0 +1,77 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function evolve(state, event) {
+  if (typeof event !== "object") {
+    if (event === "OrderPlaced") {
+      return {
+        exists: true,
+        cancelled: false,
+        refunded: false
+      };
+    } else {
+      return {
+        exists: state.exists,
+        cancelled: true,
+        refunded: state.refunded
+      };
+    }
+  } else {
+    return {
+      exists: state.exists,
+      cancelled: state.cancelled,
+      refunded: true
+    };
+  }
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    if (state.cancelled) {
+      if (state.refunded) {
+        return {
+          TAG: "Error",
+          _0: "RefundAlreadyIssued"
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "RefundIssued",
+              orderId: command.orderId,
+              reason: command.reason
+            }]
+        };
+      }
+    } else {
+      return {
+        TAG: "Error",
+        _0: "OrderNotCancelled"
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: "OrderNotFound"
+    };
+  }
+}
+
+let Spec;
+
+let initialState = {
+  exists: false,
+  cancelled: false,
+  refunded: false
+};
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Order/StateChangeSlice/RefundOrder_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/src/Order/StateChangeSlice/ShipOrder.res

@@ -0,0 +1,23 @@
+// 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/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-hybrid-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 */

package/src/Order/StateChangeSlice/ShipOrder_Behavior.res

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

package/src/Order/StateChangeSlice/ShipOrder_Behavior.res.mjs

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

package/src/Order/StateViewSliceStream/Orders.res

@@ -0,0 +1,24 @@
+// Orders StateViewSliceStream.
+// Projects order events from the shared ordering event log into an Orders read model.
+
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | OrderPlaced({orderId: string, customerId: string, productIds: array<string>})
+  | OrderShipped({orderId: string})
+  | OrderCancelled({orderId: string})
+
+@schema
+type status =
+  | Placed
+  | Shipped
+  | Cancelled
+
+@schema
+type state = {
+  orderId: string,
+  customerId: string,
+  productIds: array<string>,
+  @status status: status,
+}

package/src/Order/StateViewSliceStream/Orders.res.mjs

@@ -0,0 +1,80 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(S.string),
+    customerId: s.m(S.string),
+    productIds: s.m(S.array(S.string))
+  })),
+  S.schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "OrderCancelled",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let statusSchema = S.union([
+  S.literal("Placed"),
+  S.literal("Shipped"),
+  S.literal("Cancelled")
+]);
+
+let stateSchema = S.schema(s => ({
+  orderId: s.m(S.string),
+  customerId: s.m(S.string),
+  productIds: s.m(S.array(S.string)),
+  status: s.m(statusSchema)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let stateSchema$1 = S.Metadata.set(stateSchema, StateAnnotations$Reventless.stateAnnotationsId, {
+  ids: [],
+  compositeIds: [],
+  subIds: [],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: [],
+  scanSort: [],
+  status: "status",
+  visibility: undefined
+});
+
+let name = "Orders";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Order/StateViewSliceStream/Orders.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  statusSchema,
+  config,
+  subIdConfig,
+  stateSchema$1 as stateSchema,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* consumedEventSchema Not a pure module */

package/src/Order/StateViewSliceStream/Orders_Projection.res

@@ -0,0 +1,10 @@
+@@reventless.projection
+
+let project = event =>
+  switch event {
+  | OrderPlaced({orderId, customerId, productIds}) => [
+      Set(orderId, {orderId, customerId, productIds, status: Placed}),
+    ]
+  | OrderShipped({orderId}) => [Update(orderId, state => {...state, status: Shipped})]
+  | OrderCancelled({orderId}) => [Update(orderId, state => {...state, status: Cancelled})]
+  }