@reventlessdev/online-shop-dcb-ordering 1.0.0-alpha.246 → 1.0.0-alpha.248

package/lib/ocaml/Customers_GWT.res

@@ -1,39 +1,49 @@
 @@reventless.gwt
 
+let cid = CustomerId.make
+
 describe("Customers StateViewSlice", () => {
   test("CustomerRegistered creates a row", () =>
     givenEvents([])
-    ->whenEvent(CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"}))
+    ->whenEvent(
+      CustomerRegistered({customerId: cid("c1"), email: "alice@x.y", address: "123 Main"}),
+    )
     ->thenStateWithId(
       "c1",
-      {customerId: "c1", email: "alice@x.y", address: "123 Main", deactivated: false},
+      {customerId: cid("c1"), email: "alice@x.y", address: "123 Main", deactivated: false},
     )
   )
 
   test("EmailChanged updates the email", () =>
-    givenEvents([CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"})])
-    ->whenEvent(EmailChanged({customerId: "c1", email: "alice2@x.y"}))
+    givenEvents([
+      CustomerRegistered({customerId: cid("c1"), email: "alice@x.y", address: "123 Main"}),
+    ])
+    ->whenEvent(EmailChanged({customerId: cid("c1"), email: "alice2@x.y"}))
     ->thenStateWithId(
       "c1",
-      {customerId: "c1", email: "alice2@x.y", address: "123 Main", deactivated: false},
+      {customerId: cid("c1"), email: "alice2@x.y", address: "123 Main", deactivated: false},
     )
   )
 
   test("AddressChanged updates the address", () =>
-    givenEvents([CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"})])
-    ->whenEvent(AddressChanged({customerId: "c1", address: "789 Pine"}))
+    givenEvents([
+      CustomerRegistered({customerId: cid("c1"), email: "alice@x.y", address: "123 Main"}),
+    ])
+    ->whenEvent(AddressChanged({customerId: cid("c1"), address: "789 Pine"}))
     ->thenStateWithId(
       "c1",
-      {customerId: "c1", email: "alice@x.y", address: "789 Pine", deactivated: false},
+      {customerId: cid("c1"), email: "alice@x.y", address: "789 Pine", deactivated: false},
     )
   )
 
   test("CustomerDeactivated sets deactivated flag", () =>
-    givenEvents([CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"})])
-    ->whenEvent(CustomerDeactivated({customerId: "c1"}))
+    givenEvents([
+      CustomerRegistered({customerId: cid("c1"), email: "alice@x.y", address: "123 Main"}),
+    ])
+    ->whenEvent(CustomerDeactivated({customerId: cid("c1")}))
     ->thenStateWithId(
       "c1",
-      {customerId: "c1", email: "alice@x.y", address: "123 Main", deactivated: true},
+      {customerId: cid("c1"), email: "alice@x.y", address: "123 Main", deactivated: true},
     )
   )
 })

package/lib/ocaml/DeactivateCustomer.res

@@ -8,10 +8,10 @@ type consumedEvent =
   | CustomerDeactivated
 
 @schema
-type command = DeactivateCustomer({customerId: string})
+type command = DeactivateCustomer({customerId: CustomerId.t})
 
 @schema
 type error = CustomerNotFound
 
 @schema
-type event = CustomerDeactivated({customerId: string})
+type event = CustomerDeactivated({customerId: CustomerId.t})

package/lib/ocaml/DeactivateCustomer_GWT.res

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

package/lib/ocaml/OrderId.res

@@ -0,0 +1,4 @@
+// An order's id: the partition its slices decide about, and the key of its rows.
+include Reventless.Id.Make({
+  let key = "orderId"
+})

package/lib/ocaml/OrderingPlugin.mlmap

@@ -14,6 +14,7 @@ ChangeAddress_GWT
 ChangeEmail
 ChangeEmail_Behavior
 ChangeEmail_GWT
+CustomerId
 Customers
 Customers_GWT
 Customers_Projection
@@ -22,6 +23,7 @@ DeactivateCustomer_Behavior
 DeactivateCustomer_GWT
 EmailService
 LifecycleModel
+OrderId
 Orders
 Orders_ExtensionPointMapping
 Orders_ExtensionPointMapping_GWT

package/lib/ocaml/Orders.res

@@ -2,6 +2,9 @@
 // Projects order events from the shared ordering event log into an Orders read model.
 @@reventless.spec
 
+// Rows are keyed by this identity.
+module Key = OrderId
+
 @schema
 type lifecycle =
   | Placed
@@ -10,9 +13,9 @@ type lifecycle =
 
 @schema
 type state = {
-  orderId: string,
-  customerId: string,
-  productIds: array<string>,
+  orderId: OrderId.t,
+  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,
@@ -20,6 +23,10 @@ type state = {
 
 @schema
 type consumedEvent =
-  | OrderPlaced({orderId: string, customerId: string, productIds: array<string>})
-  | OrderShipped({orderId: string})
-  | OrderCancelled({orderId: string})
+  | OrderPlaced({
+      orderId: OrderId.t,
+      customerId: CustomerId.t,
+      productIds: array<CatalogSpec.ProductId.t>,
+    })
+  | OrderShipped({orderId: OrderId.t})
+  | OrderCancelled({orderId: OrderId.t})

package/lib/ocaml/Orders_ExtensionPointMapping.res

@@ -9,24 +9,43 @@ module Delegate = {
   let name = "OrderingDcbEventLog"
   @schema
   type event =
-    | OrderPlaced({orderId: string, customerId: string, productIds: array<string>})
-    | OrderCancelled({orderId: string, productIds: array<string>})
+    | OrderPlaced({
+        orderId: OrderId.t,
+        customerId: CustomerId.t,
+        productIds: array<CatalogSpec.ProductId.t>,
+      })
+    | OrderCancelled({orderId: OrderId.t, productIds: array<CatalogSpec.ProductId.t>})
 }
 
 let mapIncomingCommand = (_id, _command, _meta) => []
 
 let mapOutgoingEvent = Some(
   (_id, event, _meta, _queryEngine) =>
+    // The published contract carries plain strings: a consumer outside this
+    // plugin has no OrderId or CustomerId type to hold them in.
     switch event {
     | Delegate.OrderPlaced({orderId, customerId, productIds}) =>
-      productIds->Array.map(productId => PublishEvent(
-        productId,
-        OrderingSpec.Orders_ExtensionPoint.ItemOrdered({productId, orderId, customerId}),
-      ))
+      productIds->Array.map(productId => {
+        let productId = productId->CatalogSpec.ProductId.toString
+        PublishEvent(
+          productId,
+          OrderingSpec.Orders_ExtensionPoint.ItemOrdered({
+            productId,
+            orderId: orderId->OrderId.toString,
+            customerId: customerId->CustomerId.toString,
+          }),
+        )
+      })
     | Delegate.OrderCancelled({orderId, productIds}) =>
-      productIds->Array.map(productId => PublishEvent(
-        productId,
-        OrderingSpec.Orders_ExtensionPoint.ItemOrderCancelled({productId, orderId}),
-      ))
+      productIds->Array.map(productId => {
+        let productId = productId->CatalogSpec.ProductId.toString
+        PublishEvent(
+          productId,
+          OrderingSpec.Orders_ExtensionPoint.ItemOrderCancelled({
+            productId,
+            orderId: orderId->OrderId.toString,
+          }),
+        )
+      })
     },
 )

package/lib/ocaml/Orders_ExtensionPointMapping_GWT.res

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

package/lib/ocaml/Orders_GWT.res

@@ -1,30 +1,41 @@
 @@reventless.gwt
 
+let cid = CustomerId.make
+let oid = OrderId.make
+let pid = CatalogSpec.ProductId.make
+
 describe("Orders StateViewSlice", () => {
   test("OrderPlaced creates a row with status Placed", () =>
     givenEvents([])
-    ->whenEvent(OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1", "p2"]}))
+    ->whenEvent(
+      OrderPlaced({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1"), pid("p2")]}),
+    )
     ->thenStateWithId(
       "o1",
-      {orderId: "o1", customerId: "c1", productIds: ["p1", "p2"], lifecycle: Placed},
+      {
+        orderId: oid("o1"),
+        customerId: cid("c1"),
+        productIds: [pid("p1"), pid("p2")],
+        lifecycle: Placed,
+      },
     )
   )
 
   test("OrderShipped updates status to Shipped", () =>
-    givenEvents([OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1"]})])
-    ->whenEvent(OrderShipped({orderId: "o1"}))
+    givenEvents([OrderPlaced({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1")]})])
+    ->whenEvent(OrderShipped({orderId: oid("o1")}))
     ->thenStateWithId(
       "o1",
-      {orderId: "o1", customerId: "c1", productIds: ["p1"], lifecycle: Shipped},
+      {orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1")], lifecycle: Shipped},
     )
   )
 
   test("OrderCancelled updates status to Cancelled", () =>
-    givenEvents([OrderPlaced({orderId: "o1", customerId: "c1", productIds: ["p1"]})])
-    ->whenEvent(OrderCancelled({orderId: "o1"}))
+    givenEvents([OrderPlaced({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1")]})])
+    ->whenEvent(OrderCancelled({orderId: oid("o1")}))
     ->thenStateWithId(
       "o1",
-      {orderId: "o1", customerId: "c1", productIds: ["p1"], lifecycle: Cancelled},
+      {orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1")], lifecycle: Cancelled},
     )
   )
 })

package/lib/ocaml/PlaceOrder.res

@@ -6,21 +6,26 @@
 
 @schema
 type consumedEvent =
-  | OrderPlaced({orderId: string})
-  | CatalogProductSynced({productId: string})
+  | OrderPlaced({orderId: OrderId.t})
+  | CatalogProductSynced({productId: CatalogSpec.ProductId.t})
 
 @schema
 type command =
   | PlaceOrder({
-      orderId: string,
-      customerId: string,
-      @ref("AvailableProducts") productIds: array<string>,
+      orderId: OrderId.t,
+      customerId: CustomerId.t,
+      @ref("AvailableProducts") productIds: array<CatalogSpec.ProductId.t>,
     })
 
 @schema
 type error =
   | OrderAlreadyPlaced
-  | ProductsNotAvailable({missing: array<string>})
+  | ProductsNotAvailable({missing: array<CatalogSpec.ProductId.t>})
 
 @schema
-type event = OrderPlaced({orderId: string, customerId: string, productIds: array<string>})
+type event =
+  | OrderPlaced({
+      orderId: OrderId.t,
+      customerId: CustomerId.t,
+      productIds: array<CatalogSpec.ProductId.t>,
+    })

package/lib/ocaml/PlaceOrder_Behavior.res

@@ -3,7 +3,7 @@
 // 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>}
+type state = {placedOrderIds: array<OrderId.t>, availableProductIds: array<CatalogSpec.ProductId.t>}
 
 let initialState = {placedOrderIds: [], availableProductIds: []}
 

package/lib/ocaml/PlaceOrder_GWT.res

@@ -1,33 +1,39 @@
 @@reventless.gwt
 
+let cid = CustomerId.make
+let oid = OrderId.make
+let pid = CatalogSpec.ProductId.make
+
 describe("PlaceOrder StateChangeSlice", () => {
   test("requires referenced products to be synced first", () =>
     givenEvents([])
-    ->whenCmd(PlaceOrder({orderId: "o1", customerId: "c1", productIds: ["p1"]}))
-    ->thenError(ProductsNotAvailable({missing: ["p1"]}))
+    ->whenCmd(PlaceOrder({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1")]}))
+    ->thenError(ProductsNotAvailable({missing: [pid("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"]}))
+    givenEvents([CatalogProductSynced({productId: pid("p1")})])
+    ->whenCmd(PlaceOrder({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1")]}))
+    ->thenEvent(OrderPlaced({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("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"]}))
+    givenEvents([CatalogProductSynced({productId: pid("p1")})])
+    ->whenCmd(
+      PlaceOrder({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1"), pid("p2")]}),
+    )
+    ->thenError(ProductsNotAvailable({missing: [pid("p2")]}))
   )
 
   test("re-placing the same orderId returns OrderAlreadyPlaced", () =>
-    givenEvents([CatalogProductSynced({productId: "p1"}), OrderPlaced({orderId: "o1"})])
-    ->whenCmd(PlaceOrder({orderId: "o1", customerId: "c1", productIds: ["p1"]}))
+    givenEvents([CatalogProductSynced({productId: pid("p1")}), OrderPlaced({orderId: oid("o1")})])
+    ->whenCmd(PlaceOrder({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("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"]}))
+    givenEvents([CatalogProductSynced({productId: pid("p1")}), OrderPlaced({orderId: oid("o2")})])
+    ->whenCmd(PlaceOrder({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1")]}))
+    ->thenEvent(OrderPlaced({orderId: oid("o1"), customerId: cid("c1"), productIds: [pid("p1")]}))
   )
 })

package/lib/ocaml/Products_Extension_GWT.res

@@ -2,6 +2,8 @@
 // SyncCatalogProduct commands on Ordering's local shadow slice.
 @@reventless.gwt
 
+let pid = CatalogSpec.ProductId.make
+
 // `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
@@ -9,13 +11,15 @@ 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}))
+      ExtensionPoint.ProductBecameAvailable({productId: pid("p1"), name: "Book", price: 9.99}),
+    )->thenPublishesCommand(
+      Delegate.SyncNewProduct({productId: pid("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}))
+      ExtensionPoint.ProductPriceChanged({productId: pid("p1"), price: 7.5}),
+    )->thenPublishesCommand(Delegate.ChangeSyncedPrice({productId: pid("p1"), price: 7.5}))
   )
 })

package/lib/ocaml/RegisterCustomer.res

@@ -6,10 +6,10 @@
 type consumedEvent = CustomerRegistered
 
 @schema
-type command = RegisterCustomer({customerId: string, email: string, address: string})
+type command = RegisterCustomer({customerId: CustomerId.t, email: string, address: string})
 
 @schema
 type error = CustomerAlreadyRegistered
 
 @schema
-type event = CustomerRegistered({customerId: string, email: string, address: string})
+type event = CustomerRegistered({customerId: CustomerId.t, email: string, address: string})

package/lib/ocaml/RegisterCustomer_GWT.res

@@ -1,15 +1,19 @@
 @@reventless.gwt
 
+let cid = CustomerId.make
+
 describe("RegisterCustomer StateChangeSlice", () => {
   test("empty event log produces CustomerRegistered", () =>
     givenEvents([])
-    ->whenCmd(RegisterCustomer({customerId: "c1", email: "alice@x.y", address: "123 Main"}))
-    ->thenEvent(CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"}))
+    ->whenCmd(RegisterCustomer({customerId: cid("c1"), email: "alice@x.y", address: "123 Main"}))
+    ->thenEvent(
+      CustomerRegistered({customerId: cid("c1"), email: "alice@x.y", address: "123 Main"}),
+    )
   )
 
   test("existing customer returns CustomerAlreadyRegistered", () =>
     givenEvents([CustomerRegistered])
-    ->whenCmd(RegisterCustomer({customerId: "c1", email: "bob@x.y", address: "456 Oak"}))
+    ->whenCmd(RegisterCustomer({customerId: cid("c1"), email: "bob@x.y", address: "456 Oak"}))
     ->thenError(CustomerAlreadyRegistered)
   )
 })