@reventlessdev/online-shop-aggregates-ordering 3.0.0-alpha.244 → 3.0.0-alpha.246

package/lib/ocaml/Customer.res

@@ -3,6 +3,8 @@
 
 @@reventless.spec
 
+module Id = CustomerId
+
 // The command is where an address is first accepted, so it is where the type
 // belongs — a value that reaches the log is already permanent. The events below
 // stay plain `string`: they record what was accepted, and re-validating history

package/lib/ocaml/CustomerId.res

@@ -0,0 +1,4 @@
+// A customer's id: the Customer stream, the Customers rows, and an order's buyer.
+include Reventless.Id.Make({
+  let key = "customerId"
+})

package/lib/ocaml/Customers.res

@@ -3,6 +3,8 @@
 
 @@reventless.spec
 
+module Id = CustomerId
+
 // Marked on the query side too, where it is what makes the field render as a
 // mailto link instead of a text box: the AutoUI reads the semantic off this
 // state schema, not off the command's.

package/lib/ocaml/Order.res

@@ -3,18 +3,22 @@
 
 @@reventless.spec
 
+module Id = OrderId
+
 @schema
 type command =
-  | Place({customerId: string, @ref("AvailableProducts") @noDcbTag productIds: array<string>})
+  // Both references are derived from the types: AvailableProducts is the one view
+  // here keyed by ProductId, and Customers the one keyed by CustomerId.
+  | Place({customerId: CustomerId.t, productIds: array<CatalogSpec.ProductId.t>})
   | Ship
   | Cancel
   | Refund({reason: string})
 
 @schema
 type event =
-  | Placed({customerId: string, productIds: array<string>})
+  | Placed({customerId: CustomerId.t, productIds: array<CatalogSpec.ProductId.t>})
   | Shipped
-  | Cancelled({productIds: array<string>})
+  | Cancelled({productIds: array<CatalogSpec.ProductId.t>})
   | Refunded({reason: string})
 
 @schema

package/lib/ocaml/OrderId.res

@@ -0,0 +1,4 @@
+// An order's id: the Order stream and the Orders rows are keyed by it.
+include Reventless.Id.Make({
+  let key = "orderId"
+})

package/lib/ocaml/OrderMappings_GWT.res

@@ -17,13 +17,15 @@ module AutoShipGwtMapping = {
 
 include ReventlessGwt.Mapping_GWT.Make(AutoShipGwtMapping)
 
-let placedEvent = Order.Placed({customerId: "cust-1", productIds: ["prod-1"]})
+let cust1 = CustomerId.make("cust-1")
+let prod1 = CatalogSpec.ProductId.make("prod-1")
+let placedEvent = Order.Placed({customerId: cust1, productIds: [prod1]})
 
 describe("Order auto-ship mapping (Placed → Ship)", () => {
   test("Place → AutoShipMapping issues Ship → target emits Shipped", () =>
     givenSourceEvents([])
     ->andTargetEvents([("order-1", [placedEvent])])
-    ->whenSourceCmd("order-1", Place({customerId: "cust-1", productIds: ["prod-1"]}))
+    ->whenSourceCmd("order-1", Place({customerId: cust1, productIds: [prod1]}))
     ->thenTargetEvent("order-1", Order.Shipped)
   )
 
@@ -42,8 +44,8 @@ describe("Order auto-ship mapping (Placed → Ship)", () => {
   )
 
   test("Refund command does not fire the mapping (only Placed events do)", () =>
-    givenSourceEvents([placedEvent, Order.Cancelled({productIds: ["prod-1"]})])
-    ->andTargetEvents([("order-1", [placedEvent, Order.Cancelled({productIds: ["prod-1"]})])])
+    givenSourceEvents([placedEvent, Order.Cancelled({productIds: [prod1]})])
+    ->andTargetEvents([("order-1", [placedEvent, Order.Cancelled({productIds: [prod1]})])])
     ->whenSourceCmd("order-1", Refund({reason: "customer-changed-mind"}))
     ->thenNoTargetEvent
   )

package/lib/ocaml/Order_Behavior.res

@@ -6,7 +6,7 @@
 @schema
 type state =
   | NotCreated
-  | Placed({customerId: string, productIds: array<string>})
+  | Placed({customerId: CustomerId.t, productIds: array<CatalogSpec.ProductId.t>})
   | Shipped
   | Cancelled
   | Refunded

package/lib/ocaml/Order_EmailNotification.res

@@ -10,6 +10,9 @@ module Source = {
 let execute = async (orderId, _meta, event, _queryEngine) =>
   switch event {
   | Order.Placed({customerId}) =>
-    await EmailService.sendOrderConfirmation(~email=customerId, ~orderId=orderId->Order.Id.toString)
+    await EmailService.sendOrderConfirmation(
+      ~email=customerId->CustomerId.toString,
+      ~orderId=orderId->Order.Id.toString,
+    )
   | _ => ()
   }

package/lib/ocaml/Order_EmailNotification_GWT.res

@@ -16,7 +16,10 @@ describe(name ++ " SideEffect", () => {
     EmailService_Mock.install()
     givenEventForId(
       Order.Id.makeFromString("o1"),
-      Order.Placed({customerId: "alice@example.com", productIds: ["p1"]}),
+      Order.Placed({
+        customerId: CustomerId.make("alice@example.com"),
+        productIds: [CatalogSpec.ProductId.make("p1")],
+      }),
     )
     ->whenExecuted(EmailService_Mock.mock)
     ->thenExternalCalls([
@@ -33,7 +36,7 @@ describe(name ++ " SideEffect", () => {
 
   test("Cancelled is a no-op", () => {
     EmailService_Mock.install()
-    givenEvent(Order.Cancelled({productIds: ["p1"]}))
+    givenEvent(Order.Cancelled({productIds: [CatalogSpec.ProductId.make("p1")]}))
     ->whenExecuted(EmailService_Mock.mock)
     ->thenNoExternalCalls
   })

package/lib/ocaml/Order_GWT.res

@@ -1,30 +1,35 @@
 @@reventless.gwt
 
+// Ids are typed; the literals are made once, here.
+let cust1 = CustomerId.make("cust-1")
+let prod1 = CatalogSpec.ProductId.make("prod-1")
+let prod2 = CatalogSpec.ProductId.make("prod-2")
+
 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"]}))
+    ->whenCmd(Place({customerId: cust1, productIds: [prod1, prod2]}))
+    ->thenEvent(Placed({customerId: cust1, productIds: [prod1, prod2]}))
   )
 
   test("Place on existing order returns OrderAlreadyPlaced", () =>
-    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]})])
-    ->whenCmd(Place({customerId: "cust-1", productIds: ["prod-1"]}))
+    givenEvents([Placed({customerId: cust1, productIds: [prod1]})])
+    ->whenCmd(Place({customerId: cust1, productIds: [prod1]}))
     ->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"]}))
+    givenEvents([Placed({customerId: cust1, productIds: [prod1]}), Shipped])
+    ->whenCmd(Place({customerId: cust1, productIds: [prod1]}))
     ->thenError(OrderAlreadyShipped)
   )
 
   test("Place on cancelled order returns OrderAlreadyCancelled", () =>
     givenEvents([
-      Placed({customerId: "cust-1", productIds: ["prod-1"]}),
-      Cancelled({productIds: ["prod-1"]}),
+      Placed({customerId: cust1, productIds: [prod1]}),
+      Cancelled({productIds: [prod1]}),
     ])
-    ->whenCmd(Place({customerId: "cust-1", productIds: ["prod-1"]}))
+    ->whenCmd(Place({customerId: cust1, productIds: [prod1]}))
     ->thenError(OrderAlreadyCancelled)
   )
 
@@ -35,21 +40,21 @@ describe("Order Behavior", () => {
   )
 
   test("Ship on placed order produces Shipped", () =>
-    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    givenEvents([Placed({customerId: cust1, productIds: [prod1]})])
     ->whenCmd(Ship)
     ->thenEvent(Shipped)
   )
 
   test("Ship on shipped order produces no events (idempotent)", () =>
-    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]}), Shipped])
+    givenEvents([Placed({customerId: cust1, productIds: [prod1]}), Shipped])
     ->whenCmd(Ship)
     ->thenNoEvent
   )
 
   test("Ship on cancelled order returns OrderAlreadyCancelled", () =>
     givenEvents([
-      Placed({customerId: "cust-1", productIds: ["prod-1"]}),
-      Cancelled({productIds: ["prod-1"]}),
+      Placed({customerId: cust1, productIds: [prod1]}),
+      Cancelled({productIds: [prod1]}),
     ])
     ->whenCmd(Ship)
     ->thenError(OrderAlreadyCancelled)
@@ -62,21 +67,21 @@ describe("Order Behavior", () => {
   )
 
   test("Cancel on placed order produces Cancelled", () =>
-    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    givenEvents([Placed({customerId: cust1, productIds: [prod1]})])
     ->whenCmd(Cancel)
-    ->thenEvent(Cancelled({productIds: ["prod-1"]}))
+    ->thenEvent(Cancelled({productIds: [prod1]}))
   )
 
   test("Cancel on shipped order returns OrderAlreadyShipped", () =>
-    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]}), Shipped])
+    givenEvents([Placed({customerId: cust1, productIds: [prod1]}), 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"]}),
+      Placed({customerId: cust1, productIds: [prod1]}),
+      Cancelled({productIds: [prod1]}),
     ])
     ->whenCmd(Cancel)
     ->thenNoEvent
@@ -89,21 +94,21 @@ describe("Order Behavior", () => {
   )
 
   test("Refund on placed order returns OrderNotCancelled", () =>
-    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    givenEvents([Placed({customerId: cust1, productIds: [prod1]})])
     ->whenCmd(Refund({reason: "customer-changed-mind"}))
     ->thenError(OrderNotCancelled)
   )
 
   test("Refund on shipped order returns OrderNotCancelled", () =>
-    givenEvents([Placed({customerId: "cust-1", productIds: ["prod-1"]}), Shipped])
+    givenEvents([Placed({customerId: cust1, productIds: [prod1]}), 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"]}),
+      Placed({customerId: cust1, productIds: [prod1]}),
+      Cancelled({productIds: [prod1]}),
     ])
     ->whenCmd(Refund({reason: "customer-changed-mind"}))
     ->thenEvent(Refunded({reason: "customer-changed-mind"}))
@@ -111,8 +116,8 @@ describe("Order Behavior", () => {
 
   test("Refund on already-refunded order produces no events (idempotent)", () =>
     givenEvents([
-      Placed({customerId: "cust-1", productIds: ["prod-1"]}),
-      Cancelled({productIds: ["prod-1"]}),
+      Placed({customerId: cust1, productIds: [prod1]}),
+      Cancelled({productIds: [prod1]}),
       Refunded({reason: "customer-changed-mind"}),
     ])
     ->whenCmd(Refund({reason: "customer-changed-mind"}))

package/lib/ocaml/OrderingPlugin.mlmap

@@ -6,6 +6,7 @@ CatalogProduct
 CatalogProduct_Behavior
 CatalogProduct_GWT
 Customer
+CustomerId
 Customer_Behavior
 Customer_GWT
 Customers
@@ -15,6 +16,7 @@ EmailService
 EmailService_Mock
 LifecycleModel
 Order
+OrderId
 OrderMappings_GWT
 OrderNotifications
 Order_Behavior

package/lib/ocaml/Orders.res

@@ -3,6 +3,8 @@
 
 @@reventless.spec
 
+module Id = OrderId
+
 @schema
 type lifecycle =
   | Placed
@@ -12,8 +14,8 @@ type lifecycle =
 
 @schema
 type state = {
-  customerId: string,
-  productIds: array<string>,
+  customerId: CustomerId.t,
+  productIds: array<CatalogSpec.ProductId.t>,
   // No annotation: the field name is the declaration. `@lifecycle` exists for
   // records whose lifecycle field is honestly called something else.
   lifecycle: lifecycle,

package/lib/ocaml/Orders_ExtensionPointMapping.res

@@ -10,16 +10,31 @@ let mapIncomingCommand = (_id, _command, _meta) => []
 let mapOutgoingEvent = Some(
   (_id, event, _meta, _queryEngine) =>
     switch event {
+    // The published contract carries plain strings: a consumer outside this
+    // plugin has no OrderId or CustomerId type to hold them in.
     | Order.Placed({customerId, productIds}) =>
-      productIds->Array.map(productId => PublishEvent(
-        productId,
-        OrderingSpec.Orders_ExtensionPoint.ItemOrdered({productId, orderId: _id, customerId}),
-      ))
+      productIds->Array.map(productId => {
+        let productId = productId->CatalogSpec.ProductId.toString
+        PublishEvent(
+          productId,
+          OrderingSpec.Orders_ExtensionPoint.ItemOrdered({
+            productId,
+            orderId: _id,
+            customerId: customerId->CustomerId.toString,
+          }),
+        )
+      })
     | Order.Cancelled({productIds}) =>
-      productIds->Array.map(productId => PublishEvent(
-        productId,
-        OrderingSpec.Orders_ExtensionPoint.ItemOrderCancelled({productId, orderId: _id}),
-      ))
+      productIds->Array.map(productId => {
+        let productId = productId->CatalogSpec.ProductId.toString
+        PublishEvent(
+          productId,
+          OrderingSpec.Orders_ExtensionPoint.ItemOrderCancelled({
+            productId,
+            orderId: _id,
+          }),
+        )
+      })
     | _ => []
     },
 )

package/lib/ocaml/Orders_ExtensionPointMapping_GWT.res

@@ -2,10 +2,14 @@
 // into one public per-product event each (one-to-many fan-out).
 @@reventless.gwt
 
+let c1 = CustomerId.make("c1")
+let p1 = CatalogSpec.ProductId.make("p1")
+let p2 = CatalogSpec.ProductId.make("p2")
+
 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"]}),
+      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"})),
@@ -13,7 +17,7 @@ describe("Orders ExtensionPoint mapping — per-product fan-out", () => {
   )
 
   test("Cancelled fans out to one ItemOrderCancelled per product", () =>
-    whenDelegateEvent(Delegate.Cancelled({productIds: ["p1", "p2"]}))->thenPublishesEvents([
+    whenDelegateEvent(Delegate.Cancelled({productIds: [p1, p2]}))->thenPublishesEvents([
       ("p1", ExtensionPoint.ItemOrderCancelled({productId: "p1", orderId: "gwt-id"})),
       ("p2", ExtensionPoint.ItemOrderCancelled({productId: "p2", orderId: "gwt-id"})),
     ])

package/lib/ocaml/Orders_GWT.res

@@ -1,45 +1,50 @@
 @@reventless.gwt(Orders_Projections.OrderMapping)
 
+// Ids are typed; the literals are made once, here.
+let cust1 = CustomerId.make("cust-1")
+let prod1 = CatalogSpec.ProductId.make("prod-1")
+let prod2 = CatalogSpec.ProductId.make("prod-2")
+
 describe("Orders ReadModel ← Order", () => {
   test("Placed sets initial read model state", () =>
     givenEvents([])
-    ->whenEvent(Order.Placed({customerId: "cust-1", productIds: ["prod-1", "prod-2"]}))
+    ->whenEvent(Order.Placed({customerId: cust1, productIds: [prod1, prod2]}))
     ->thenState({
-      Orders.customerId: "cust-1",
-      productIds: ["prod-1", "prod-2"],
+      Orders.customerId: cust1,
+      productIds: [prod1, prod2],
       lifecycle: Placed,
     })
   )
 
   test("Shipped updates status", () =>
-    givenEvents([Order.Placed({customerId: "cust-1", productIds: ["prod-1"]})])
+    givenEvents([Order.Placed({customerId: cust1, productIds: [prod1]})])
     ->whenEvent(Order.Shipped)
     ->thenState({
-      Orders.customerId: "cust-1",
-      productIds: ["prod-1"],
+      Orders.customerId: cust1,
+      productIds: [prod1],
       lifecycle: Shipped,
     })
   )
 
   test("Cancelled updates status", () =>
-    givenEvents([Order.Placed({customerId: "cust-1", productIds: ["prod-1"]})])
-    ->whenEvent(Order.Cancelled({productIds: ["prod-1"]}))
+    givenEvents([Order.Placed({customerId: cust1, productIds: [prod1]})])
+    ->whenEvent(Order.Cancelled({productIds: [prod1]}))
     ->thenState({
-      Orders.customerId: "cust-1",
-      productIds: ["prod-1"],
+      Orders.customerId: cust1,
+      productIds: [prod1],
       lifecycle: Cancelled,
     })
   )
 
   test("Refunded updates status", () =>
     givenEvents([
-      Order.Placed({customerId: "cust-1", productIds: ["prod-1"]}),
-      Order.Cancelled({productIds: ["prod-1"]}),
+      Order.Placed({customerId: cust1, productIds: [prod1]}),
+      Order.Cancelled({productIds: [prod1]}),
     ])
     ->whenEvent(Order.Refunded({reason: "customer-changed-mind"}))
     ->thenState({
-      Orders.customerId: "cust-1",
-      productIds: ["prod-1"],
+      Orders.customerId: cust1,
+      productIds: [prod1],
       lifecycle: Refunded,
     })
   )