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

package/lib/bs/tests/Order/Aggregate/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/bs/tests/Order/Aggregate/Order_GWT.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Order$OrderingPlugin from "../../../src/Order/Aggregate/Order.res.mjs";
+import * as ProductId$CatalogSpec from "@reventlessdev/online-shop-aggregates-catalog-spec/src/ProductId.res.mjs";
+import * as CustomerId$OrderingPlugin from "../../../src/Customer/CustomerId.res.mjs";
 import * as Behavior_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/Behavior_GWT.res.mjs";
 import * as Order_Behavior$OrderingPlugin from "../../../src/Order/Aggregate/Order_Behavior.res.mjs";
 
@@ -37,109 +39,115 @@ let thenNoEvent = include.thenNoEvent;
 
 let thenError = include.thenError;
 
+let cust1 = CustomerId$OrderingPlugin.make("cust-1");
+
+let prod1 = ProductId$CatalogSpec.make("prod-1");
+
+let prod2 = ProductId$CatalogSpec.make("prod-2");
+
 describe("Order Behavior", () => {
   test("Place on new aggregate produces Placed", () => thenEvent(whenCmd(givenEvents([]), {
     TAG: "Place",
-    customerId: "cust-1",
+    customerId: cust1,
     productIds: [
-      "prod-1",
-      "prod-2"
+      prod1,
+      prod2
     ]
   }), {
     TAG: "Placed",
-    customerId: "cust-1",
+    customerId: cust1,
     productIds: [
-      "prod-1",
-      "prod-2"
+      prod1,
+      prod2
     ]
   }));
   test("Place on existing order returns OrderAlreadyPlaced", () => thenError(whenCmd(givenEvents([{
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     }]), {
     TAG: "Place",
-    customerId: "cust-1",
-    productIds: ["prod-1"]
+    customerId: cust1,
+    productIds: [prod1]
   }), "OrderAlreadyPlaced"));
   test("Place on shipped order returns OrderAlreadyShipped", () => thenError(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     "Shipped"
   ]), {
     TAG: "Place",
-    customerId: "cust-1",
-    productIds: ["prod-1"]
+    customerId: cust1,
+    productIds: [prod1]
   }), "OrderAlreadyShipped"));
   test("Place on cancelled order returns OrderAlreadyCancelled", () => thenError(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     {
       TAG: "Cancelled",
-      productIds: ["prod-1"]
+      productIds: [prod1]
     }
   ]), {
     TAG: "Place",
-    customerId: "cust-1",
-    productIds: ["prod-1"]
+    customerId: cust1,
+    productIds: [prod1]
   }), "OrderAlreadyCancelled"));
   test("Ship on non-existent order returns OrderNotFound", () => thenError(whenCmd(givenEvents([]), "Ship"), "OrderNotFound"));
   test("Ship on placed order produces Shipped", () => thenEvent(whenCmd(givenEvents([{
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     }]), "Ship"), "Shipped"));
   test("Ship on shipped order produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     "Shipped"
   ]), "Ship")));
   test("Ship on cancelled order returns OrderAlreadyCancelled", () => thenError(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     {
       TAG: "Cancelled",
-      productIds: ["prod-1"]
+      productIds: [prod1]
     }
   ]), "Ship"), "OrderAlreadyCancelled"));
   test("Cancel on non-existent order returns OrderNotFound", () => thenError(whenCmd(givenEvents([]), "Cancel"), "OrderNotFound"));
   test("Cancel on placed order produces Cancelled", () => thenEvent(whenCmd(givenEvents([{
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     }]), "Cancel"), {
     TAG: "Cancelled",
-    productIds: ["prod-1"]
+    productIds: [prod1]
   }));
   test("Cancel on shipped order returns OrderAlreadyShipped", () => thenError(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     "Shipped"
   ]), "Cancel"), "OrderAlreadyShipped"));
   test("Cancel on cancelled order produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     {
       TAG: "Cancelled",
-      productIds: ["prod-1"]
+      productIds: [prod1]
     }
   ]), "Cancel")));
   test("Refund on non-existent order returns OrderNotFound", () => thenError(whenCmd(givenEvents([]), {
@@ -148,8 +156,8 @@ describe("Order Behavior", () => {
   }), "OrderNotFound"));
   test("Refund on placed order returns OrderNotCancelled", () => thenError(whenCmd(givenEvents([{
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     }]), {
     TAG: "Refund",
     reason: "customer-changed-mind"
@@ -157,8 +165,8 @@ describe("Order Behavior", () => {
   test("Refund on shipped order returns OrderNotCancelled", () => thenError(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     "Shipped"
   ]), {
@@ -168,12 +176,12 @@ describe("Order Behavior", () => {
   test("Refund on cancelled order produces Refunded", () => thenEvent(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     {
       TAG: "Cancelled",
-      productIds: ["prod-1"]
+      productIds: [prod1]
     }
   ]), {
     TAG: "Refund",
@@ -185,12 +193,12 @@ describe("Order Behavior", () => {
   test("Refund on already-refunded order produces no events (idempotent)", () => thenNoEvent(whenCmd(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     {
       TAG: "Cancelled",
-      productIds: ["prod-1"]
+      productIds: [prod1]
     },
     {
       TAG: "Refunded",
@@ -228,5 +236,8 @@ export {
   thenCompareEvents,
   thenEventsWithError,
   thenError,
+  cust1,
+  prod1,
+  prod2,
 }
 /* include Not a pure module */

package/lib/bs/tests/Order/ReadModel/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,
     })
   )

package/lib/bs/tests/Order/ReadModel/Orders_GWT.res.mjs

@@ -1,5 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as ProductId$CatalogSpec from "@reventlessdev/online-shop-aggregates-catalog-spec/src/ProductId.res.mjs";
+import * as CustomerId$OrderingPlugin from "../../../src/Customer/CustomerId.res.mjs";
 import * as Orders_Projections$OrderingPlugin from "../../../src/Order/ReadModel/Orders_Projections.res.mjs";
 import * as MultiSourceProjection_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/MultiSourceProjection_GWT.res.mjs";
 
@@ -15,59 +17,65 @@ let whenEvent = include.whenEvent;
 
 let thenState = include.thenState;
 
+let cust1 = CustomerId$OrderingPlugin.make("cust-1");
+
+let prod1 = ProductId$CatalogSpec.make("prod-1");
+
+let prod2 = ProductId$CatalogSpec.make("prod-2");
+
 describe("Orders ReadModel ← Order", () => {
   test("Placed sets initial read model state", undefined, () => thenState(whenEvent(givenEvents([]), {
     TAG: "Placed",
-    customerId: "cust-1",
+    customerId: cust1,
     productIds: [
-      "prod-1",
-      "prod-2"
+      prod1,
+      prod2
     ]
   }), {
-    customerId: "cust-1",
+    customerId: cust1,
     productIds: [
-      "prod-1",
-      "prod-2"
+      prod1,
+      prod2
     ],
     lifecycle: "Placed"
   }));
   test("Shipped updates status", undefined, () => thenState(whenEvent(givenEvents([{
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     }]), "Shipped"), {
-    customerId: "cust-1",
-    productIds: ["prod-1"],
+    customerId: cust1,
+    productIds: [prod1],
     lifecycle: "Shipped"
   }));
   test("Cancelled updates status", undefined, () => thenState(whenEvent(givenEvents([{
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     }]), {
     TAG: "Cancelled",
-    productIds: ["prod-1"]
+    productIds: [prod1]
   }), {
-    customerId: "cust-1",
-    productIds: ["prod-1"],
+    customerId: cust1,
+    productIds: [prod1],
     lifecycle: "Cancelled"
   }));
   test("Refunded updates status", undefined, () => thenState(whenEvent(givenEvents([
     {
       TAG: "Placed",
-      customerId: "cust-1",
-      productIds: ["prod-1"]
+      customerId: cust1,
+      productIds: [prod1]
     },
     {
       TAG: "Cancelled",
-      productIds: ["prod-1"]
+      productIds: [prod1]
     }
   ]), {
     TAG: "Refunded",
     reason: "customer-changed-mind"
   }), {
-    customerId: "cust-1",
-    productIds: ["prod-1"],
+    customerId: cust1,
+    productIds: [prod1],
     lifecycle: "Refunded"
   }));
 });
@@ -114,5 +122,8 @@ export {
   thenNoState,
   thenThrow,
   thenFail,
+  cust1,
+  prod1,
+  prod2,
 }
 /* include Not a pure module */

package/lib/bs/tests/Order/SideEffect/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/bs/tests/Order/SideEffect/Order_EmailNotification_GWT.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as ProductId$CatalogSpec from "@reventlessdev/online-shop-aggregates-catalog-spec/src/ProductId.res.mjs";
+import * as OrderId$OrderingPlugin from "../../../src/Order/OrderId.res.mjs";
+import * as CustomerId$OrderingPlugin from "../../../src/Customer/CustomerId.res.mjs";
 import * as SideEffect_GWT$ReventlessGwt from "@reventlessdev/reventless-gwt/src/SideEffect_GWT.res.mjs";
 import * as EmailService_Mock$OrderingPlugin from "./EmailService_Mock.res.mjs";
 import * as Order_EmailNotification$OrderingPlugin from "../../../src/Order/SideEffect/Order_EmailNotification.res.mjs";
@@ -8,7 +10,7 @@ import * as Order_EmailNotification$OrderingPlugin from "../../../src/Order/Side
 let include = SideEffect_GWT$ReventlessGwt.Make({
   Source: {
     name: Order_EmailNotification$OrderingPlugin.Source.name,
-    Id: Id$Reventless.$$String,
+    Id: OrderId$OrderingPlugin,
     eventSchema: Order_EmailNotification$OrderingPlugin.Source.eventSchema
   },
   moduleUrl: Order_EmailNotification$OrderingPlugin.moduleUrl,
@@ -32,10 +34,10 @@ let thenExternalCalls = include.thenExternalCalls;
 describe(Order_EmailNotification$OrderingPlugin.name + " SideEffect", () => {
   test("Placed triggers a confirmation email", undefined, () => {
     EmailService_Mock$OrderingPlugin.install();
-    return thenExternalCalls(whenExecuted(givenEventForId(Id$Reventless.$$String.makeFromString("o1"), {
+    return thenExternalCalls(whenExecuted(givenEventForId(OrderId$OrderingPlugin.makeFromString("o1"), {
       TAG: "Placed",
-      customerId: "alice@example.com",
-      productIds: ["p1"]
+      customerId: CustomerId$OrderingPlugin.make("alice@example.com"),
+      productIds: [ProductId$CatalogSpec.make("p1")]
     }), EmailService_Mock$OrderingPlugin.mock, undefined), [{
         TAG: "SendOrderConfirmation",
         email: "alice@example.com",
@@ -50,7 +52,7 @@ describe(Order_EmailNotification$OrderingPlugin.name + " SideEffect", () => {
     EmailService_Mock$OrderingPlugin.install();
     return thenNoExternalCalls(whenExecuted(givenEvent({
       TAG: "Cancelled",
-      productIds: ["p1"]
+      productIds: [ProductId$CatalogSpec.make("p1")]
     }), EmailService_Mock$OrderingPlugin.mock, undefined));
   });
 });

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1789940154691)
-#Done(1789940160402)
+#Start(1789994023811)
+#Done(1789994029825)

package/lib/ocaml/AvailableProducts.res

@@ -8,5 +8,7 @@
 @@reventless.spec
 @@reventless.visibility(Internal)
 
+module Id = CatalogSpec.ProductId
+
 @schema
 type state = {name: string, price: float}

package/lib/ocaml/CatalogProduct.res

@@ -4,6 +4,8 @@
 
 @@reventless.spec
 
+module Id = CatalogSpec.ProductId
+
 @schema
 type command =
   | Sync({name: string, price: float})