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

package/lib/ocaml/DeactivateCustomer_Behavior.res

@@ -0,0 +1,23 @@
+@@reventless.behavior
+
+type state = {exists: bool, deactivated: bool}
+
+let initialState = {exists: false, deactivated: false}
+
+let evolve = (state, event) =>
+  switch event {
+  | CustomerRegistered => {exists: true, deactivated: false}
+  | CustomerDeactivated => {...state, deactivated: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | DeactivateCustomer({customerId: theId}) =>
+    if !state.exists {
+      Error(CustomerNotFound)
+    } else if state.deactivated {
+      Ok([]) // idempotent — already deactivated
+    } else {
+      Ok([CustomerDeactivated({customerId: theId})])
+    }
+  }

package/lib/ocaml/DeactivateCustomer_GWT.res

@@ -0,0 +1,21 @@
+@@reventless.gwt
+
+describe("DeactivateCustomer StateChangeSlice", () => {
+  test("non-existent customer returns CustomerNotFound", () =>
+    givenEvents([])
+    ->whenCmd(DeactivateCustomer({customerId: "c1"}))
+    ->thenError(CustomerNotFound)
+  )
+
+  test("existing customer produces CustomerDeactivated", () =>
+    givenEvents([CustomerRegistered])
+    ->whenCmd(DeactivateCustomer({customerId: "c1"}))
+    ->thenEvent(CustomerDeactivated({customerId: "c1"}))
+  )
+
+  test("already deactivated customer produces no events (idempotent)", () =>
+    givenEvents([CustomerRegistered, CustomerDeactivated])
+    ->whenCmd(DeactivateCustomer({customerId: "c1"}))
+    ->thenNoEvent
+  )
+})

package/lib/ocaml/EmailService.res

@@ -0,0 +1,3 @@
+let sendOrderConfirmation = async (~email as _, ~orderId as _) => {
+  Console.log("[EmailService] Order confirmation sent")
+}

package/lib/ocaml/OrderingPlugin.mlmap

@@ -0,0 +1,46 @@
+randjbuildsystem
+AutoShipOrder
+AutoShipOrder_Automation
+AutoShipOrder_GWT
+AvailableProducts
+AvailableProducts_GWT
+AvailableProducts_Projection
+CancelOrder
+CancelOrder_Behavior
+CancelOrder_GWT
+ChangeAddress
+ChangeAddress_Behavior
+ChangeAddress_GWT
+ChangeEmail
+ChangeEmail_Behavior
+ChangeEmail_GWT
+Customers
+Customers_GWT
+Customers_Projection
+DeactivateCustomer
+DeactivateCustomer_Behavior
+DeactivateCustomer_GWT
+EmailService
+Orders
+Orders_ExtensionPointMapping
+Orders_ExtensionPointMapping_GWT
+Orders_GWT
+Orders_Projection
+PlaceOrder
+PlaceOrder_Behavior
+PlaceOrder_GWT
+Plugin
+Products_Extension
+Products_Extension_GWT
+RegisterCustomer
+RegisterCustomer_Behavior
+RegisterCustomer_GWT
+SendOrderConfirmation
+SendOrderConfirmation_GWT
+SendOrderConfirmation_Translation
+ShipOrder
+ShipOrder_Behavior
+ShipOrder_GWT
+SyncCatalogProduct
+SyncCatalogProduct_Behavior
+SyncCatalogProduct_GWT

package/lib/ocaml/Orders.res

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

package/lib/ocaml/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(productId =>
+      PublishEvent(
+        productId,
+        OrderingSpec.Orders_ExtensionPoint.ItemOrdered({productId, orderId, customerId}),
+      )
+    )
+  | Delegate.OrderCancelled({orderId, productIds}) =>
+    productIds->Array.map(productId =>
+      PublishEvent(productId, OrderingSpec.Orders_ExtensionPoint.ItemOrderCancelled({productId, orderId}))
+    )
+  }
+)

package/lib/ocaml/Orders_ExtensionPointMapping_GWT.res

@@ -0,0 +1,23 @@
+// Boundary GWT for the Orders extension point: batch order events decompose
+// into one public per-product event each (one-to-many fan-out).
+@@reventless.gwt
+
+describe("Orders ExtensionPoint mapping — per-product fan-out", () => {
+  test("OrderPlaced fans out to one ItemOrdered per product", () =>
+    whenDelegateEvent(
+      Delegate.OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1", "p2"]}),
+    )->thenPublishesEvents([
+      ("p1", ExtensionPoint.ItemOrdered({productId: "p1", orderId: "o1", customerId: "c1"})),
+      ("p2", ExtensionPoint.ItemOrdered({productId: "p2", orderId: "o1", customerId: "c1"})),
+    ])
+  )
+
+  test("OrderCancelled fans out to one ItemOrderCancelled per product", () =>
+    whenDelegateEvent(
+      Delegate.OrderCancelled({orderId: "o1", productIds: ["p1", "p2"]}),
+    )->thenPublishesEvents([
+      ("p1", ExtensionPoint.ItemOrderCancelled({productId: "p1", orderId: "o1"})),
+      ("p2", ExtensionPoint.ItemOrderCancelled({productId: "p2", orderId: "o1"})),
+    ])
+  )
+})

package/lib/ocaml/Orders_GWT.res

@@ -0,0 +1,36 @@
+@@reventless.gwt
+
+describe("Orders StateViewSlice", () => {
+  test("OrderPlaced creates a row with status Placed", () =>
+    givenEvents([])
+    ->whenEvent(
+      OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1", "p2"]}),
+    )
+    ->thenStateWithId(
+      "o1",
+      {orderId: "o1", customerId: "c1", productIds: ["p1", "p2"], status: Placed},
+    )
+  )
+
+  test("OrderShipped updates status to Shipped", () =>
+    givenEvents([
+      OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1"]}),
+    ])
+    ->whenEvent(OrderShipped({orderId: "o1"}))
+    ->thenStateWithId(
+      "o1",
+      {orderId: "o1", customerId: "c1", productIds: ["p1"], status: Shipped},
+    )
+  )
+
+  test("OrderCancelled updates status to Cancelled", () =>
+    givenEvents([
+      OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1"]}),
+    ])
+    ->whenEvent(OrderCancelled({orderId: "o1"}))
+    ->thenStateWithId(
+      "o1",
+      {orderId: "o1", customerId: "c1", productIds: ["p1"], status: Cancelled},
+    )
+  )
+})

package/lib/ocaml/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})]
+  }

package/lib/ocaml/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/ocaml/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/ocaml/PlaceOrder_GWT.res

@@ -0,0 +1,39 @@
+@@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/lib/ocaml/Plugin.res

@@ -0,0 +1,64 @@
+// AUTO-GENERATED — do not edit. Run `npm run generate` to update.
+
+@val external uiBundleUrl: option<string> = "process.env.ORDERING_UI_BUNDLE_URL"
+
+module Make = (Platform: ReventlessInfra.Platform.T) => {
+  // StateChangeSlices
+  module CancelOrderSlice = Platform.StateChangeSlice.Make(CancelOrder, CancelOrder_Behavior)
+  module ChangeAddressSlice = Platform.StateChangeSlice.Make(ChangeAddress, ChangeAddress_Behavior)
+  module ChangeEmailSlice = Platform.StateChangeSlice.Make(ChangeEmail, ChangeEmail_Behavior)
+  module DeactivateCustomerSlice = Platform.StateChangeSlice.Make(DeactivateCustomer, DeactivateCustomer_Behavior)
+  module PlaceOrderSlice = Platform.StateChangeSlice.Make(PlaceOrder, PlaceOrder_Behavior)
+  module RegisterCustomerSlice = Platform.StateChangeSlice.Make(RegisterCustomer, RegisterCustomer_Behavior)
+  module ShipOrderSlice = Platform.StateChangeSlice.Make(ShipOrder, ShipOrder_Behavior)
+  module SyncCatalogProductSlice = Platform.StateChangeSlice.Make(SyncCatalogProduct, SyncCatalogProduct_Behavior)
+
+  // StateViewSlices
+  module AvailableProductsSlice = Platform.StateViewSlice.Make(AvailableProducts, AvailableProducts_Projection)
+  module CustomersSlice = Platform.StateViewSlice.Make(Customers, Customers_Projection)
+  module OrdersSlice = Platform.StateViewSlice.Make(Orders, Orders_Projection)
+
+  // AutomationSlices
+  module AutoShipOrderSlice = Platform.AutomationSlice.Make(AutoShipOrder, AutoShipOrder_Automation)
+
+  // OutboundTranslationSlices
+  module SendOrderConfirmationSlice = Platform.OutboundTranslationSlice.Make(SendOrderConfirmation, SendOrderConfirmation_Translation)
+
+  // ExtensionPoints
+  module Orders_ExtensionPoint = Platform.ExtensionPoint.Make(Orders_ExtensionPointMapping)
+
+  // Extensions
+  module Products_Extension = Platform.Extension.Make(Products_Extension.Mapping)
+
+  let pluginStructure = Platform.Plugin.makePluginDefinition(
+    ~name="Ordering",
+    ~stateViewSlices=[module(AvailableProductsSlice), module(CustomersSlice), module(OrdersSlice)],
+    ~stateChangeSlices=[module(CancelOrderSlice), module(ChangeAddressSlice), module(ChangeEmailSlice), module(DeactivateCustomerSlice), module(PlaceOrderSlice), module(RegisterCustomerSlice), module(ShipOrderSlice), module(SyncCatalogProductSlice)],
+    ~automationSlices=[module(AutoShipOrderSlice)],
+    ~outboundTranslationSlices=[module(SendOrderConfirmationSlice)],
+    ~extensions=[module(Products_Extension)],
+    ~extensionPoints=[module(Orders_ExtensionPointMapping)],
+  )
+
+  let make = () =>
+    Platform.Plugin.make(
+      ~name="Ordering",
+      ~heartbeatInterval=5,
+      ~extensionPoints=[module(Orders_ExtensionPoint)],
+      ~extensions=[module(Products_Extension)],
+      ~stateChangeSlices=[module(CancelOrderSlice), module(ChangeAddressSlice), module(ChangeEmailSlice), module(DeactivateCustomerSlice), module(PlaceOrderSlice), module(RegisterCustomerSlice), module(ShipOrderSlice), module(SyncCatalogProductSlice)],
+      ~stateViewSlices=[module(AvailableProductsSlice), module(CustomersSlice), module(OrdersSlice)],
+      ~automationSlices=[module(AutoShipOrderSlice)],
+      ~outboundTranslationSlices=[module(SendOrderConfirmationSlice)],
+      ~pluginStructure=pluginStructure,
+      ~uiFragments=?uiBundleUrl->Option.map(url =>
+        Platform.Plugin.makeAutoUIManifest(
+          ~remoteEntryUrl=url,
+          ~name="Ordering",
+          ~pluginStructure,
+          ~readModelPositions=["platform-summary"],
+          ~aggregatePositions=["resource-detail"],
+        )
+      ),
+    )
+}

package/lib/ocaml/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/lib/ocaml/Products_Extension_GWT.res

@@ -0,0 +1,23 @@
+// Boundary GWT for Ordering's Products extension: public Catalog events become
+// SyncCatalogProduct commands on Ordering's local shadow slice.
+@@reventless.gwt
+
+// `Mapping` is brought into scope by the PPX `open Products_Extension`; opening
+// it surfaces the extension point's events and the delegate's commands.
+open Mapping
+
+describe("Products Extension delegate", () => {
+  test("ProductBecameAvailable issues SyncNewProduct", () =>
+    whenIncomingEvent(
+      ExtensionPoint.ProductBecameAvailable({productId: "p1", name: "Book", price: 9.99}),
+    )->thenPublishesCommand(
+      Delegate.SyncNewProduct({productId: "p1", name: "Book", price: 9.99}),
+    )
+  )
+
+  test("ProductPriceChanged issues ChangeSyncedPrice", () =>
+    whenIncomingEvent(
+      ExtensionPoint.ProductPriceChanged({productId: "p1", price: 7.5}),
+    )->thenPublishesCommand(Delegate.ChangeSyncedPrice({productId: "p1", price: 7.5}))
+  )
+})