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

package/src/Customer/Aggregate/Customer.res.mjs

@@ -0,0 +1,64 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Register",
+    email: s.m(S.string),
+    address: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "UpdateEmail",
+    email: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "UpdateAddress",
+    address: s.m(S.string)
+  })),
+  S.literal("Deactivate")
+]);
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "Registered",
+    email: s.m(S.string),
+    address: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "EmailUpdated",
+    email: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "AddressUpdated",
+    address: s.m(S.string)
+  })),
+  S.literal("Deactivated")
+]);
+
+let errorSchema = S.union([
+  S.literal("CustomerAlreadyRegistered"),
+  S.literal("CustomerNotFound"),
+  S.literal("CustomerAlreadyDeactivated")
+]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "Customer";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Customer/Aggregate/Customer.res.mjs";
+
+export {
+  name,
+  Id,
+  commandSchema,
+  eventSchema,
+  errorSchema,
+  moduleUrl,
+  commandAuthorization,
+}
+/* commandSchema Not a pure module */

package/src/Customer/Aggregate/Customer_Behavior.res

@@ -0,0 +1,41 @@
+// Customer aggregate behavior.
+// Implements the state machine for registering and managing customers.
+
+@@reventless.behavior
+
+@schema
+type state =
+  | NotCreated
+  | Active({email: string, address: string})
+  | Deactivated
+
+let initialState = NotCreated
+
+let evolve = (state, event) =>
+  switch (state, event) {
+  | (NotCreated, Registered({email, address})) => Active({email, address})
+  | (Active(_), Registered({email, address})) => Active({email, address})
+  | (Active(s), EmailUpdated({email})) => Active({...s, email})
+  | (Active(s), AddressUpdated({address})) => Active({...s, address})
+  | (Active(_), Customer.Deactivated) => Deactivated
+  | (Deactivated, _) => state
+  | (NotCreated, _) => state
+  }
+
+let decide = (state, command) =>
+  switch (state, command) {
+  | (NotCreated, Register({email, address})) => Ok([Registered({email, address})])
+  | (NotCreated, UpdateEmail(_)) => Error(CustomerNotFound)
+  | (NotCreated, UpdateAddress(_)) => Error(CustomerNotFound)
+  | (NotCreated, Deactivate) => Error(CustomerNotFound)
+  | (Active(_), Register(_)) => Error(CustomerAlreadyRegistered)
+  | (Active(s), UpdateEmail({email})) if email == s.email => Ok([])
+  | (Active(_), UpdateEmail({email})) => Ok([EmailUpdated({email: email})])
+  | (Active(s), UpdateAddress({address})) if address == s.address => Ok([])
+  | (Active(_), UpdateAddress({address})) => Ok([AddressUpdated({address: address})])
+  | (Active(_), Deactivate) => Ok([Customer.Deactivated])
+  | (Deactivated, Register(_)) => Error(CustomerAlreadyDeactivated)
+  | (Deactivated, UpdateEmail(_)) => Error(CustomerAlreadyDeactivated)
+  | (Deactivated, UpdateAddress(_)) => Error(CustomerAlreadyDeactivated)
+  | (Deactivated, Deactivate) => Ok([]) // idempotent
+  }

package/src/Customer/Aggregate/Customer_Behavior.res.mjs

@@ -0,0 +1,143 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let stateSchema = S.union([
+  S.literal("NotCreated"),
+  S.schema(s => ({
+    TAG: "Active",
+    email: s.m(S.string),
+    address: s.m(S.string)
+  })),
+  S.literal("Deactivated")
+]);
+
+function evolve(state, event) {
+  if (typeof state !== "object") {
+    if (state === "NotCreated" && typeof event === "object" && event.TAG === "Registered") {
+      return {
+        TAG: "Active",
+        email: event.email,
+        address: event.address
+      };
+    } else {
+      return state;
+    }
+  }
+  if (typeof event !== "object") {
+    return "Deactivated";
+  }
+  switch (event.TAG) {
+    case "Registered" :
+      return {
+        TAG: "Active",
+        email: event.email,
+        address: event.address
+      };
+    case "EmailUpdated" :
+      return {
+        TAG: "Active",
+        email: event.email,
+        address: state.address
+      };
+    case "AddressUpdated" :
+      return {
+        TAG: "Active",
+        email: state.email,
+        address: event.address
+      };
+  }
+}
+
+function decide(state, command) {
+  if (typeof state !== "object") {
+    if (state === "NotCreated") {
+      if (typeof command !== "object" || command.TAG !== "Register") {
+        return {
+          TAG: "Error",
+          _0: "CustomerNotFound"
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "Registered",
+              email: command.email,
+              address: command.address
+            }]
+        };
+      }
+    } else if (typeof command !== "object") {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "CustomerAlreadyDeactivated"
+      };
+    }
+  }
+  if (typeof command !== "object") {
+    return {
+      TAG: "Ok",
+      _0: ["Deactivated"]
+    };
+  }
+  switch (command.TAG) {
+    case "Register" :
+      return {
+        TAG: "Error",
+        _0: "CustomerAlreadyRegistered"
+      };
+    case "UpdateEmail" :
+      let email = command.email;
+      if (email === state.email) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "EmailUpdated",
+              email: email
+            }]
+        };
+      }
+    case "UpdateAddress" :
+      let address = command.address;
+      if (address === state.address) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "AddressUpdated",
+              address: address
+            }]
+        };
+      }
+  }
+}
+
+let Spec;
+
+let initialState = "NotCreated";
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Customer/Aggregate/Customer_Behavior.res.mjs";
+
+export {
+  Spec,
+  stateSchema,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* stateSchema Not a pure module */

package/src/Customer/ReadModelStream/Customers.res

@@ -0,0 +1,15 @@
+// Customers read model specification.
+// Query-side state for registered customers. This is a **mixed-source** read
+// model: the customer profile fields come from the Customer aggregate, while
+// `orderCount` is fed by the Ordering DCB log's `OrderPlaced` events (keyed by
+// `customerId`). See `Customers_Projections.res` for the two source mappings.
+
+@@reventless.spec
+
+@schema
+type state = {
+  @displayName email: string,
+  address: string,
+  deactivated: bool,
+  orderCount: int,
+}

package/src/Customer/ReadModelStream/Customers.res.mjs

@@ -0,0 +1,44 @@
+// 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 DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
+
+let stateSchema = S.schema(s => ({
+  email: s.m(S.string),
+  address: s.m(S.string),
+  deactivated: s.m(S.bool),
+  orderCount: s.m(S.int),
+  displayName: s.m(S.option(S.string))
+}));
+
+let stateSchema$1 = S.Metadata.set(stateSchema, DisplayName$Reventless.displayNameId, {
+  fields: ["email"],
+  separator: " "
+});
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let name = "Customers";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Customer/ReadModelStream/Customers.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  stateSchema$1 as stateSchema,
+  config,
+  subIdConfig,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* stateSchema Not a pure module */

package/src/Customer/ReadModelStream/Customers_Projections.res

@@ -0,0 +1,78 @@
+// Customer projection mappings — a single read model fed by TWO sources:
+//
+//   1. the **Customer aggregate** (profile: email, address, deactivated), and
+//   2. the **Ordering DCB EventLog** (`orderCount`, from `OrderPlaced` events).
+//
+// This is the canonical mixed **aggregate + DCB** read model: an aggregate's
+// per-instance state correlated with DCB events that reference it by a shared
+// key (`customerId`). Both mappings write to the same row id, so the framework
+// merges them into one `Customers` record.
+//
+// The DCB source's `name` MUST equal `<pluginName>DcbEventLog`
+// ("OrderingDcbEventLog") — the key under which `Plugin_Builder` registers the
+// ordering plugin's DCB EventTopic AND the `meta.service` DcbEventLog stamps on
+// every published event.
+//
+// Both mappings use `UpdateWithDefault` so the merge is order-independent: an
+// `OrderPlaced` that arrives before its customer's `Registered` still creates a
+// row (and vice-versa), and neither source clobbers the other's fields.
+
+@@reventless.mappings
+
+// ─────────────────────────────────────────────────────────────
+// DCB source view — Order-side events (only what this read model needs)
+// ─────────────────────────────────────────────────────────────
+
+module OrderEvents = {
+  let name = "OrderingDcbEventLog"
+
+  @schema
+  type event = OrderPlaced({orderId: string, customerId: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// Source 1 — Customer aggregate (profile)
+// ─────────────────────────────────────────────────────────────
+
+module CustomerMapping = Mapping.Make(
+  Customer,
+  Customers,
+  {
+    open Customer
+    let project = ({event, id, _}) =>
+      switch event {
+      | Registered({email, address}) =>
+        UpdateWithDefault(
+          id,
+          {Customers.email: email, address, deactivated: false, orderCount: 0},
+          state => {...state, email, address, deactivated: false},
+        )
+      | EmailUpdated({email}) => Update(id, state => {...state, email})
+      | AddressUpdated({address}) => Update(id, state => {...state, address})
+      | Deactivated => Update(id, state => {...state, deactivated: true})
+      }
+  },
+)
+
+// ─────────────────────────────────────────────────────────────
+// Source 2 — Ordering DCB EventLog (order count, keyed by customerId)
+// ─────────────────────────────────────────────────────────────
+
+module CustomerOrdersMapping = Mapping.Make(
+  OrderEvents,
+  Customers,
+  {
+    open OrderEvents
+    let project = ({event, _}) =>
+      switch event {
+      | OrderPlaced({customerId}) =>
+        UpdateWithDefault(
+          customerId,
+          {Customers.email: "", address: "", deactivated: false, orderCount: 1},
+          state => {...state, orderCount: state.orderCount + 1},
+        )
+      }
+  },
+)
+
+let mappings: array<module(Mapping)> = [module(CustomerMapping), module(CustomerOrdersMapping)]

package/src/Customer/ReadModelStream/Customers_Projections.res.mjs

@@ -0,0 +1,153 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Projection$Reventless from "@reventlessdev/reventless-spec/src/types/Projection.res.mjs";
+import * as Customer$OrderingPlugin from "../Aggregate/Customer.res.mjs";
+import * as Customers$OrderingPlugin from "./Customers.res.mjs";
+
+let M = Projection$Reventless.Mappings.Make({
+  Id: Id$Reventless.$$String,
+  name: Customers$OrderingPlugin.name,
+  stateSchema: Customers$OrderingPlugin.stateSchema,
+  subIdConfig: undefined
+});
+
+let name = "OrderingDcbEventLog";
+
+let eventSchema = S.schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(DcbTag$Reventless.string),
+  customerId: s.m(DcbTag$Reventless.string)
+}));
+
+let OrderEvents = {
+  Id: undefined,
+  name: name,
+  eventSchema: eventSchema
+};
+
+function project(param) {
+  let event = param.event;
+  let id = param.id;
+  if (typeof event !== "object") {
+    return {
+      TAG: "Update",
+      _0: id,
+      _1: state => {
+        let newrecord = {...state};
+        newrecord.deactivated = true;
+        return newrecord;
+      }
+    };
+  }
+  switch (event.TAG) {
+    case "Registered" :
+      let address = event.address;
+      let email = event.email;
+      return {
+        TAG: "UpdateWithDefault",
+        _0: id,
+        _1: {
+          email: email,
+          address: address,
+          deactivated: false,
+          orderCount: 0
+        },
+        _2: state => {
+          let newrecord = {...state};
+          newrecord.deactivated = false;
+          newrecord.address = address;
+          newrecord.email = email;
+          return newrecord;
+        }
+      };
+    case "EmailUpdated" :
+      let email$1 = event.email;
+      return {
+        TAG: "Update",
+        _0: id,
+        _1: state => {
+          let newrecord = {...state};
+          newrecord.email = email$1;
+          return newrecord;
+        }
+      };
+    case "AddressUpdated" :
+      let address$1 = event.address;
+      return {
+        TAG: "Update",
+        _0: id,
+        _1: state => {
+          let newrecord = {...state};
+          newrecord.address = address$1;
+          return newrecord;
+        }
+      };
+  }
+}
+
+let CustomerMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: Customer$OrderingPlugin.name,
+  eventSchema: Customer$OrderingPlugin.eventSchema
+})({
+  Id: Id$Reventless.$$String,
+  name: Customers$OrderingPlugin.name,
+  stateSchema: Customers$OrderingPlugin.stateSchema,
+  subIdConfig: undefined
+})({
+  project: project
+});
+
+function project$1(param) {
+  return {
+    TAG: "UpdateWithDefault",
+    _0: param.event.customerId,
+    _1: {
+      email: "",
+      address: "",
+      deactivated: false,
+      orderCount: 1
+    },
+    _2: state => {
+      let newrecord = {...state};
+      newrecord.orderCount = state.orderCount + 1 | 0;
+      return newrecord;
+    }
+  };
+}
+
+let CustomerOrdersMapping = Projection$Reventless.Mapping.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema
+})({
+  Id: Id$Reventless.$$String,
+  name: Customers$OrderingPlugin.name,
+  stateSchema: Customers$OrderingPlugin.stateSchema,
+  subIdConfig: undefined
+})({
+  project: project$1
+});
+
+let mappings = [
+  CustomerMapping,
+  CustomerOrdersMapping
+];
+
+let Target;
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Customer/ReadModelStream/Customers_Projections.res.mjs";
+
+export {
+  Target,
+  M,
+  OrderEvents,
+  CustomerMapping,
+  CustomerOrdersMapping,
+  mappings,
+  moduleUrl,
+}
+/* M Not a pure module */

package/src/Extension/Products_Extension.res

@@ -0,0 +1,23 @@
+// Ordering's extension subscribing to Catalog's Products_ExtensionPoint.
+// Routes ProductBecameAvailable / ProductPriceChanged events to SyncCatalogProduct commands.
+
+@@reventless.extension
+
+module Mapping = {
+  module ExtensionPoint = CatalogSpec.Products_ExtensionPoint
+  module Delegate = SyncCatalogProduct
+
+  open ExtensionPoint
+  open SyncCatalogProduct
+  let mapIncomingEvent = (_id, event, _meta, _pluginDef, _queryEngine) =>
+    switch event {
+    | ProductBecameAvailable({productId, name, price}) => [
+        PublishStateChangeSliceCommand(SyncNewProduct({productId, name, price})),
+      ]
+    | ProductPriceChanged({productId, price}) => [
+        PublishStateChangeSliceCommand(ChangeSyncedPrice({productId, price})),
+      ]
+    }
+
+  let mapOutgoingEvent = None
+}

package/src/Extension/Products_Extension.res.mjs

@@ -0,0 +1,43 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SyncCatalogProduct$OrderingPlugin from "../CatalogProduct/StateChangeSlice/SyncCatalogProduct.res.mjs";
+
+function mapIncomingEvent(_id, event, _meta, _pluginDef, _queryEngine) {
+  if (event.TAG === "ProductBecameAvailable") {
+    return [{
+        TAG: "PublishStateChangeSliceCommand",
+        _0: {
+          TAG: "SyncNewProduct",
+          productId: event.productId,
+          name: event.name,
+          price: event.price
+        }
+      }];
+  } else {
+    return [{
+        TAG: "PublishStateChangeSliceCommand",
+        _0: {
+          TAG: "ChangeSyncedPrice",
+          productId: event.productId,
+          price: event.price
+        }
+      }];
+  }
+}
+
+let Mapping = {
+  ExtensionPoint: undefined,
+  Delegate: undefined,
+  mapIncomingEvent: mapIncomingEvent,
+  mapOutgoingEvent: undefined,
+  delegateModuleUrl: SyncCatalogProduct$OrderingPlugin.moduleUrl,
+  moduleUrl: "@reventlessdev/online-shop-hybrid-ordering/src/Extension/Products_Extension.res.mjs"
+};
+
+let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/Extension/Products_Extension.res.mjs";
+
+export {
+  Mapping,
+  moduleUrl,
+}
+/* SyncCatalogProduct-OrderingPlugin Not a pure module */

package/src/ExtensionPoint/Orders_ExtensionPointMapping.res

@@ -0,0 +1,33 @@
+// Maps internal Ordering events to the stable Orders_ExtensionPoint public API.
+// Decomposes batch OrderPlaced / OrderCancelled events into per-product EP events.
+@@reventless.spec
+
+module ExtensionPoint = OrderingSpec.Orders_ExtensionPoint
+
+// DCB adapter: defines the event type used for outgoing event mapping.
+// Only the events relevant to the extension point are included.
+module Delegate = {
+  let name = "OrderingDcbEventLog"
+  @schema
+  type event =
+    | OrderPlaced({orderId: string, customerId: string, productIds: array<string>})
+    | OrderCancelled({orderId: string, productIds: array<string>})
+}
+
+let mapIncomingCommand = (_id, _command, _meta) => []
+
+let mapOutgoingEvent = Some((_id, event, _meta, _queryEngine) =>
+  switch event {
+  | Delegate.OrderPlaced({orderId, customerId, productIds}) =>
+    productIds->Array.map(pid =>
+      PublishEvent(
+        pid,
+        OrderingSpec.Orders_ExtensionPoint.ItemOrdered({productId: pid, orderId, customerId}),
+      )
+    )
+  | Delegate.OrderCancelled({orderId, productIds}) =>
+    productIds->Array.map(pid =>
+      PublishEvent(pid, OrderingSpec.Orders_ExtensionPoint.ItemOrderCancelled({productId: pid, orderId}))
+    )
+  }
+)