@reventlessdev/online-shop-aggregates-ordering 3.0.0-alpha.101

package/lib/ocaml/Order_Behavior.res

@@ -0,0 +1,52 @@
+// Order aggregate behavior.
+// Implements the lifecycle for placing, shipping, cancelling, and refunding orders.
+
+@@reventless.behavior
+
+@schema
+type state =
+  | NotCreated
+  | Placed({customerId: string, productIds: array<string>})
+  | Shipped
+  | Cancelled
+  | Refunded
+
+let initialState = NotCreated
+
+let evolve = (state, event) =>
+  switch (state, event) {
+  | (NotCreated, Order.Placed({customerId, productIds})) => Placed({customerId, productIds})
+  | (Placed(_), Order.Placed({customerId, productIds})) => Placed({customerId, productIds})
+  | (Placed(_), Order.Shipped) => Shipped
+  | (Placed(_), Order.Cancelled(_)) => Cancelled
+  | (Cancelled, Order.Refunded(_)) => Refunded
+  | (Shipped, _) => state
+  | (Cancelled, _) => state
+  | (Refunded, _) => state
+  | (NotCreated, _) => state
+  }
+
+let decide = (state, command) =>
+  switch (state, command) {
+  | (NotCreated, Place({customerId, productIds})) =>
+    Ok([Order.Placed({customerId, productIds})])
+  | (NotCreated, Ship) => Error(OrderNotFound)
+  | (NotCreated, Cancel) => Error(OrderNotFound)
+  | (NotCreated, Refund(_)) => Error(OrderNotFound)
+  | (Placed(_), Place(_)) => Error(OrderAlreadyPlaced)
+  | (Placed(_), Ship) => Ok([Order.Shipped])
+  | (Placed({productIds}), Cancel) => Ok([Order.Cancelled({productIds: productIds})])
+  | (Placed(_), Refund(_)) => Error(OrderNotCancelled)
+  | (Shipped, Place(_)) => Error(OrderAlreadyShipped)
+  | (Shipped, Ship) => Ok([]) // idempotent
+  | (Shipped, Cancel) => Error(OrderAlreadyShipped)
+  | (Shipped, Refund(_)) => Error(OrderNotCancelled)
+  | (Cancelled, Place(_)) => Error(OrderAlreadyCancelled)
+  | (Cancelled, Ship) => Error(OrderAlreadyCancelled)
+  | (Cancelled, Cancel) => Ok([]) // idempotent
+  | (Cancelled, Refund({reason})) => Ok([Order.Refunded({reason: reason})])
+  | (Refunded, Place(_)) => Error(OrderAlreadyRefunded)
+  | (Refunded, Ship) => Error(OrderAlreadyRefunded)
+  | (Refunded, Cancel) => Error(OrderAlreadyRefunded)
+  | (Refunded, Refund(_)) => Ok([]) // idempotent
+  }

package/lib/ocaml/Order_EmailNotification.res

@@ -0,0 +1,18 @@
+// Send an order confirmation email when an order is placed.
+@@reventless.spec
+
+module Source = {
+  let name = Order.name
+  module Id = Order.Id
+  @schema type event = Order.event
+}
+
+let execute = async (orderId, _meta, event, _queryEngine) =>
+  switch event {
+  | Order.Placed({customerId}) =>
+    await EmailService.sendOrderConfirmation(
+      ~email=customerId,
+      ~orderId=orderId->Order.Id.toString,
+    )
+  | _ => ()
+  }

package/lib/ocaml/Order_EmailNotification_GWT.res

@@ -0,0 +1,37 @@
+// GWT for the aggregate-style egress `Order_EmailNotification`. Mirrors the
+// hybrid example's DCB-side `SendOrderConfirmation_GWT` (OutboundTranslation).
+// The folder `SideEffect/` is what the PPX uses to infer the DSL kind.
+
+@@reventless.gwt
+
+// Each test installs the recording backend at the start of its pipeline; the
+// install also resets the recorded-calls ref, so tests stay isolated without
+// pulling rescript-jest's `beforeEach` into the example's dependencies.
+
+describe("Order_EmailNotification SideEffect", () => {
+  test("Placed triggers a confirmation email", () => {
+    EmailService_Mock.install()
+    givenEventForId(
+      Order.Id.makeFromString("o1"),
+      Order.Placed({customerId: "alice@example.com", productIds: ["p1"]}),
+    )
+    ->whenExecuted(EmailService_Mock.mock)
+    ->thenExternalCalls([
+      EmailService_Mock.SendOrderConfirmation({email: "alice@example.com", orderId: "o1"}),
+    ])
+  })
+
+  test("Shipped is a no-op", () => {
+    EmailService_Mock.install()
+    givenEvent(Order.Shipped)
+    ->whenExecuted(EmailService_Mock.mock)
+    ->thenNoExternalCalls
+  })
+
+  test("Cancelled is a no-op", () => {
+    EmailService_Mock.install()
+    givenEvent(Order.Cancelled({productIds: ["p1"]}))
+    ->whenExecuted(EmailService_Mock.mock)
+    ->thenNoExternalCalls
+  })
+})

package/lib/ocaml/Order_GWT.res

@@ -0,0 +1,121 @@
+@@reventless.gwt
+
+describe("Order Behavior", () => {
+  test("Place on new aggregate produces Placed", () =>
+    givenEvents([])
+    ->whenCmd(Place({customerId: "cust-1", productIds: ["prod-1", "prod-2"]}))
+    ->thenEvent(Placed({customerId: "cust-1", productIds: ["prod-1", "prod-2"]}))
+  )
+
+  test("Place on existing order returns OrderAlreadyPlaced", () =>
+    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    ->whenCmd(Place({customerId: "cust-1", productIds: ["prod-1"]}))
+    ->thenError(OrderAlreadyPlaced)
+  )
+
+  test("Place on shipped order returns OrderAlreadyShipped", () =>
+    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]}), Shipped])
+    ->whenCmd(Place({customerId: "cust-1", productIds: ["prod-1"]}))
+    ->thenError(OrderAlreadyShipped)
+  )
+
+  test("Place on cancelled order returns OrderAlreadyCancelled", () =>
+    givenEvents([
+      Placed({customerId: "cust-1", productIds: ["prod-1"]}),
+      Cancelled({productIds: ["prod-1"]}),
+    ])
+    ->whenCmd(Place({customerId: "cust-1", productIds: ["prod-1"]}))
+    ->thenError(OrderAlreadyCancelled)
+  )
+
+  test("Ship on non-existent order returns OrderNotFound", () =>
+    givenEvents([])
+    ->whenCmd(Ship)
+    ->thenError(OrderNotFound)
+  )
+
+  test("Ship on placed order produces Shipped", () =>
+    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    ->whenCmd(Ship)
+    ->thenEvent(Shipped)
+  )
+
+  test("Ship on shipped order produces no events (idempotent)", () =>
+    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]}), Shipped])
+    ->whenCmd(Ship)
+    ->thenNoEvent
+  )
+
+  test("Ship on cancelled order returns OrderAlreadyCancelled", () =>
+    givenEvents([
+      Placed({customerId: "cust-1", productIds: ["prod-1"]}),
+      Cancelled({productIds: ["prod-1"]}),
+    ])
+    ->whenCmd(Ship)
+    ->thenError(OrderAlreadyCancelled)
+  )
+
+  test("Cancel on non-existent order returns OrderNotFound", () =>
+    givenEvents([])
+    ->whenCmd(Cancel)
+    ->thenError(OrderNotFound)
+  )
+
+  test("Cancel on placed order produces Cancelled", () =>
+    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    ->whenCmd(Cancel)
+    ->thenEvent(Cancelled({productIds: ["prod-1"]}))
+  )
+
+  test("Cancel on shipped order returns OrderAlreadyShipped", () =>
+    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]}), Shipped])
+    ->whenCmd(Cancel)
+    ->thenError(OrderAlreadyShipped)
+  )
+
+  test("Cancel on cancelled order produces no events (idempotent)", () =>
+    givenEvents([
+      Placed({customerId: "cust-1", productIds: ["prod-1"]}),
+      Cancelled({productIds: ["prod-1"]}),
+    ])
+    ->whenCmd(Cancel)
+    ->thenNoEvent
+  )
+
+  test("Refund on non-existent order returns OrderNotFound", () =>
+    givenEvents([])
+    ->whenCmd(Refund({reason: "lost-in-transit"}))
+    ->thenError(OrderNotFound)
+  )
+
+  test("Refund on placed order returns OrderNotCancelled", () =>
+    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    ->whenCmd(Refund({reason: "customer-changed-mind"}))
+    ->thenError(OrderNotCancelled)
+  )
+
+  test("Refund on shipped order returns OrderNotCancelled", () =>
+    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]}), Shipped])
+    ->whenCmd(Refund({reason: "delivered-damaged"}))
+    ->thenError(OrderNotCancelled)
+  )
+
+  test("Refund on cancelled order produces Refunded", () =>
+    givenEvents([
+      Placed({customerId: "cust-1", productIds: ["prod-1"]}),
+      Cancelled({productIds: ["prod-1"]}),
+    ])
+    ->whenCmd(Refund({reason: "customer-changed-mind"}))
+    ->thenEvent(Refunded({reason: "customer-changed-mind"}))
+  )
+
+  test("Refund on already-refunded order produces no events (idempotent)", () =>
+    givenEvents([
+      Placed({customerId: "cust-1", productIds: ["prod-1"]}),
+      Cancelled({productIds: ["prod-1"]}),
+      Refunded({reason: "customer-changed-mind"}),
+    ])
+    ->whenCmd(Refund({reason: "customer-changed-mind"}))
+    ->thenNoEvent
+  )
+})

package/lib/ocaml/Order_Mappings.res

@@ -0,0 +1,15 @@
+// Order event mappings — maps Order events to Order commands.
+// When an order is placed, automatically issue a Ship command.
+@@reventless.mappings
+
+module AutoShipMapping = {
+  module Source = Order
+
+  let map = (orderId, event, _queryEngine) =>
+    switch event {
+    | Order.Placed(_) => [Publish(orderId, Order.Ship)]
+    | _ => []
+    }
+}
+
+let mappings: array<module(Mapping)> = [module(AutoShipMapping)]

package/lib/ocaml/OrderingPlugin.mlmap

@@ -0,0 +1,31 @@
+randjbuildsystem
+AvailableProducts
+AvailableProducts_GWT
+AvailableProducts_Projections
+CatalogProduct
+CatalogProduct_Behavior
+CatalogProduct_GWT
+Customer
+Customer_Behavior
+Customer_GWT
+Customers
+Customers_GWT
+Customers_Projections
+EmailService
+EmailService_Mock
+Order
+OrderMappings_GWT
+OrderNotifications
+Order_Behavior
+Order_EmailNotification
+Order_EmailNotification_GWT
+Order_GWT
+Order_Mappings
+Orders
+Orders_ExtensionPointMapping
+Orders_ExtensionPointMapping_GWT
+Orders_GWT
+Orders_Projections
+Plugin
+Products_Extension
+Products_Extension_GWT

package/lib/ocaml/Orders.res

@@ -0,0 +1,19 @@
+// Orders read model specification.
+// Query-side state for customer orders.
+
+@@reventless.spec
+
+@schema
+type status =
+  | Placed
+  | Shipped
+  | Cancelled
+  | Refunded
+
+@schema
+type state = {
+  customerId: string,
+  productIds: array<string>,
+  @status status: status,
+}
+

package/lib/ocaml/Orders_ExtensionPointMapping.res

@@ -0,0 +1,28 @@
+// Maps internal Order aggregate events to the stable OrdersExtensionPoint public API.
+// Decomposes a batch OrderPlaced (multiple productIds) into one ItemOrdered per product.
+@@reventless.spec
+
+module ExtensionPoint = OrderingSpec.Orders_ExtensionPoint
+module Delegate = Order
+
+let mapIncomingCommand = (_id, _command, _meta) => []
+
+let mapOutgoingEvent = Some((_id, event, _meta, _queryEngine) =>
+  switch event {
+  | Order.Placed({customerId, productIds}) =>
+    productIds->Array.map(productId =>
+      PublishEvent(
+        productId,
+        OrderingSpec.Orders_ExtensionPoint.ItemOrdered({productId, orderId: _id, customerId}),
+      )
+    )
+  | Order.Cancelled({productIds}) =>
+    productIds->Array.map(productId =>
+      PublishEvent(
+        productId,
+        OrderingSpec.Orders_ExtensionPoint.ItemOrderCancelled({productId, orderId: _id}),
+      )
+    )
+  | _ => []
+  }
+)

package/lib/ocaml/Orders_ExtensionPointMapping_GWT.res

@@ -0,0 +1,33 @@
+// 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("Placed fans out to one ItemOrdered per product", () =>
+    whenDelegateEvent(
+      Delegate.Placed({customerId: "c1", productIds: ["p1", "p2"]}),
+    )->thenPublishesEvents([
+      ("p1", ExtensionPoint.ItemOrdered({productId: "p1", orderId: "gwt-id", customerId: "c1"})),
+      ("p2", ExtensionPoint.ItemOrdered({productId: "p2", orderId: "gwt-id", customerId: "c1"})),
+    ])
+  )
+
+  test("Cancelled fans out to one ItemOrderCancelled per product", () =>
+    whenDelegateEvent(
+      Delegate.Cancelled({productIds: ["p1", "p2"]}),
+    )->thenPublishesEvents([
+      ("p1", ExtensionPoint.ItemOrderCancelled({productId: "p1", orderId: "gwt-id"})),
+      ("p2", ExtensionPoint.ItemOrderCancelled({productId: "p2", orderId: "gwt-id"})),
+    ])
+  )
+
+  test("Shipped publishes nothing", () =>
+    whenDelegateEvent(Delegate.Shipped)->thenPublishesNothing
+  )
+
+  test("Refunded publishes nothing", () =>
+    whenDelegateEvent(
+      Delegate.Refunded({reason: "customer-changed-mind"}),
+    )->thenPublishesNothing
+  )
+})

package/lib/ocaml/Orders_GWT.res

@@ -0,0 +1,46 @@
+@@reventless.gwt(Orders_Projections.OrderMapping)
+
+describe("Orders ReadModel ← Order", () => {
+  test("Placed sets initial read model state", () =>
+    givenEvents([])
+    ->whenEvent(Order.Placed({customerId: "cust-1", productIds: ["prod-1", "prod-2"]}))
+    ->thenState({
+      Orders.customerId: "cust-1",
+      productIds: ["prod-1", "prod-2"],
+      status: Placed,
+    })
+  )
+
+  test("Shipped updates status", () =>
+    givenEvents([Order.Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    ->whenEvent(Order.Shipped)
+    ->thenState({
+      Orders.customerId: "cust-1",
+      productIds: ["prod-1"],
+      status: Shipped,
+    })
+  )
+
+  test("Cancelled updates status", () =>
+    givenEvents([Order.Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    ->whenEvent(Order.Cancelled({productIds: ["prod-1"]}))
+    ->thenState({
+      Orders.customerId: "cust-1",
+      productIds: ["prod-1"],
+      status: Cancelled,
+    })
+  )
+
+  test("Refunded updates status", () =>
+    givenEvents([
+      Order.Placed({customerId: "cust-1", productIds: ["prod-1"]}),
+      Order.Cancelled({productIds: ["prod-1"]}),
+    ])
+    ->whenEvent(Order.Refunded({reason: "customer-changed-mind"}))
+    ->thenState({
+      Orders.customerId: "cust-1",
+      productIds: ["prod-1"],
+      status: Refunded,
+    })
+  )
+})

package/lib/ocaml/Orders_Projections.res

@@ -0,0 +1,31 @@
+// Order projection mappings.
+// Maps Order aggregate events to Orders read model state changes.
+@@reventless.mappings
+
+module OrderMapping = Mapping.Make(
+  Order,
+  Orders,
+  {
+    open Order
+    let project = ({event, id, _}) =>
+      switch event {
+      | Placed({customerId, productIds}) =>
+        Set(
+          id,
+          {
+            Orders.customerId: customerId,
+            productIds,
+            status: (Placed: Orders.status),
+          },
+        )
+      | Shipped =>
+        Update(id, state => {...state, status: (Shipped: Orders.status)})
+      | Cancelled(_) =>
+        Update(id, state => {...state, status: (Cancelled: Orders.status)})
+      | Refunded(_) =>
+        Update(id, state => {...state, status: (Refunded: Orders.status)})
+      }
+  },
+)
+
+let mappings: array<module(Mapping)> = [module(OrderMapping)]

package/lib/ocaml/Plugin.res

@@ -0,0 +1,65 @@
+// 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) => {
+  // Aggregates
+  module CatalogProductAggregate = Platform.Aggregate.Make(
+    CatalogProduct,
+    CatalogProduct_Behavior,
+    ReventlessInfra.NoEventMappings.Make(CatalogProduct),
+  )
+  module CustomerAggregate = Platform.Aggregate.Make(
+    Customer,
+    Customer_Behavior,
+    ReventlessInfra.NoEventMappings.Make(Customer),
+  )
+  module OrderAggregate = Platform.Aggregate.Make(
+    Order,
+    Order_Behavior,
+    Order_Mappings,
+  )
+
+  // ReadModels
+  module AvailableProductsReadModel = Platform.ReadModel.Make(AvailableProducts, AvailableProducts_Projections)
+  module CustomersReadModel = Platform.ReadModel.Make(Customers, Customers_Projections)
+  module OrdersReadModel = Platform.ReadModel.Make(Orders, Orders_Projections)
+
+  // Tasks
+  module OrderNotificationsTask = Platform.Task.Make(OrderNotifications)
+
+  // 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",
+    ~aggregates=[module(CatalogProductAggregate), module(CustomerAggregate), module(OrderAggregate)],
+    ~readModels=[module(AvailableProductsReadModel), module(CustomersReadModel), module(OrdersReadModel)],
+    ~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)],
+      ~aggregates=[module(CatalogProductAggregate), module(CustomerAggregate), module(OrderAggregate)],
+      ~readModels=[module(AvailableProductsReadModel), module(CustomersReadModel), module(OrdersReadModel)],
+      ~tasks=[module(OrderNotificationsTask)],
+      ~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 ProductsExtensionPoint.
+// Routes ProductBecameAvailable / ProductPriceChanged events to CatalogProduct commands.
+
+@@reventless.extension
+
+module Mapping = {
+  module ExtensionPoint = CatalogSpec.Products_ExtensionPoint
+  module Delegate = CatalogProduct
+
+  open ExtensionPoint
+  open Delegate
+  let mapIncomingEvent = (_id, event, _meta, _pluginDef, _queryEngine) =>
+    switch event {
+    | ProductBecameAvailable({productId, name, price}) => [
+        PublishAggregateCommand(productId, Sync({name, price})),
+      ]
+    | ProductPriceChanged({productId, price}) => [
+        PublishAggregateCommand(productId, UpdatePrice({price: price})),
+      ]
+    }
+
+  let mapOutgoingEvent = None
+}