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

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.CATALOG_UI_BUNDLE_URL"
+
+module Make = (Platform: ReventlessInfra.Platform.T) => {
+  // Aggregates
+  module CategoryAggregate = Platform.Aggregate.Make(
+    Category,
+    Category_Behavior,
+    ReventlessInfra.NoEventMappings.Make(Category),
+  )
+  module ProductAggregate = Platform.Aggregate.Make(
+    Product,
+    Product_Behavior,
+    ReventlessInfra.NoEventMappings.Make(Product),
+  )
+  module ProductDemandAggregate = Platform.Aggregate.Make(
+    ProductDemand,
+    ProductDemand_Behavior,
+    ReventlessInfra.NoEventMappings.Make(ProductDemand),
+  )
+
+  // ReadModels
+  module CategoriesReadModel = Platform.ReadModel.Make(Categories, Categories_Projections)
+  module ProductDemandsReadModel = Platform.ReadModel.Make(ProductDemands, ProductDemands_Projections)
+  module ProductsReadModel = Platform.ReadModel.Make(Products, Products_Projections)
+
+  // Tasks
+  module ImportProductsTask = Platform.Task.Make(ImportProducts)
+
+  // ExtensionPoints
+  module Products_ExtensionPoint = Platform.ExtensionPoint.Make(Products_ExtensionPointMapping)
+
+  // Extensions
+  module Orders_Extension = Platform.Extension.Make(Orders_Extension.Mapping)
+
+  let pluginStructure = Platform.Plugin.makePluginDefinition(
+    ~name="Catalog",
+    ~aggregates=[module(CategoryAggregate), module(ProductAggregate), module(ProductDemandAggregate)],
+    ~readModels=[module(CategoriesReadModel), module(ProductDemandsReadModel), module(ProductsReadModel)],
+    ~extensions=[module(Orders_Extension)],
+    ~extensionPoints=[module(Products_ExtensionPointMapping)],
+  )
+
+  let make = () =>
+    Platform.Plugin.make(
+      ~name="Catalog",
+      ~heartbeatInterval=5,
+      ~extensionPoints=[module(Products_ExtensionPoint)],
+      ~extensions=[module(Orders_Extension)],
+      ~aggregates=[module(CategoryAggregate), module(ProductAggregate), module(ProductDemandAggregate)],
+      ~readModels=[module(CategoriesReadModel), module(ProductDemandsReadModel), module(ProductsReadModel)],
+      ~tasks=[module(ImportProductsTask)],
+      ~pluginStructure=pluginStructure,
+      ~uiFragments=?uiBundleUrl->Option.map(url =>
+        Platform.Plugin.makeAutoUIManifest(
+          ~remoteEntryUrl=url,
+          ~name="Catalog",
+          ~pluginStructure,
+          ~readModelPositions=["platform-summary"],
+          ~aggregatePositions=["resource-detail"],
+        )
+      ),
+    )
+}

package/lib/ocaml/Product.res

@@ -0,0 +1,23 @@
+// Product aggregate specification.
+// A product listing with name, description, and price.
+
+@@reventless.spec
+
+@schema
+type command =
+  | Add({name: string, description: string, price: float})
+  | UpdateName({name: string})
+  | UpdateDescription({description: string})
+  | UpdatePrice({price: float})
+
+@schema
+type event =
+  | Added({name: string, description: string, price: float})
+  | NameUpdated({name: string})
+  | DescriptionUpdated({description: string})
+  | PriceUpdated({price: float})
+
+@schema
+type error =
+  | ProductAlreadyExists
+  | ProductNotFound

package/lib/ocaml/ProductDemand.res

@@ -0,0 +1,20 @@
+// ProductDemand aggregate specification.
+// Records per-product order demand, driven by Ordering's OrdersExtensionPoint.
+
+@@reventless.spec
+
+// Not a UI/API command — driven only by Ordering's OrdersExtensionPoint.
+// @noApi removes it from the GraphQL/MCP/AutoUI surface, so the cross-plugin
+// `orderId` is never rendered as a picker and needs no @ref.
+@schema @noApi
+type command =
+  | Record({orderId: string})
+  | Revoke({orderId: string})
+
+@schema
+type event =
+  | Recorded({orderId: string})
+  | Revoked({orderId: string})
+
+@schema
+type error = unit

package/lib/ocaml/ProductDemand_Behavior.res

@@ -0,0 +1,39 @@
+// ProductDemand aggregate behavior.
+// Idempotently records and revokes order demand per product.
+
+@@reventless.behavior
+
+@schema
+type state =
+  | NotCreated
+  | Created({recordedOrderIds: array<string>})
+
+let initialState = NotCreated
+
+let evolve = (state, event) =>
+  switch (state, event) {
+  | (NotCreated, Recorded({orderId})) => Created({recordedOrderIds: [orderId]})
+  | (Created(s), Recorded({orderId})) =>
+    Created({recordedOrderIds: Array.concat(s.recordedOrderIds, [orderId])})
+  | (Created(s), Revoked({orderId})) =>
+    Created({recordedOrderIds: s.recordedOrderIds->Array.filter(id => id !== orderId)})
+  | (NotCreated, Revoked(_)) => state
+  }
+
+let decide = (state, command) =>
+  switch (state, command) {
+  | (NotCreated, Record({orderId})) => Ok([Recorded({orderId: orderId})])
+  | (NotCreated, Revoke(_)) => Ok([]) // nothing recorded yet — idempotent
+  | (Created(s), Record({orderId})) =>
+    if s.recordedOrderIds->Array.includes(orderId) {
+      Ok([]) // idempotent
+    } else {
+      Ok([Recorded({orderId: orderId})])
+    }
+  | (Created(s), Revoke({orderId})) =>
+    if !(s.recordedOrderIds->Array.includes(orderId)) {
+      Ok([]) // idempotent
+    } else {
+      Ok([Revoked({orderId: orderId})])
+    }
+  }

package/lib/ocaml/ProductDemand_GWT.res

@@ -0,0 +1,39 @@
+@@reventless.gwt
+
+describe("ProductDemand Behavior", () => {
+  test("Record on new aggregate produces Recorded", () =>
+    givenEvents([])
+    ->whenCmd(Record({orderId: "order-1"}))
+    ->thenEvent(Recorded({orderId: "order-1"}))
+  )
+
+  test("Record with new orderId on existing aggregate produces Recorded", () =>
+    givenEvents([Recorded({orderId: "order-1"})])
+    ->whenCmd(Record({orderId: "order-2"}))
+    ->thenEvent(Recorded({orderId: "order-2"}))
+  )
+
+  test("Record with already-recorded orderId produces no events (idempotent)", () =>
+    givenEvents([Recorded({orderId: "order-1"})])
+    ->whenCmd(Record({orderId: "order-1"}))
+    ->thenNoEvent
+  )
+
+  test("Revoke on never-recorded aggregate produces no events (idempotent)", () =>
+    givenEvents([])
+    ->whenCmd(Revoke({orderId: "order-1"}))
+    ->thenNoEvent
+  )
+
+  test("Revoke of unrecorded orderId on existing aggregate produces no events (idempotent)", () =>
+    givenEvents([Recorded({orderId: "order-1"})])
+    ->whenCmd(Revoke({orderId: "order-2"}))
+    ->thenNoEvent
+  )
+
+  test("Revoke of recorded orderId produces Revoked", () =>
+    givenEvents([Recorded({orderId: "order-1"})])
+    ->whenCmd(Revoke({orderId: "order-1"}))
+    ->thenEvent(Revoked({orderId: "order-1"}))
+  )
+})

package/lib/ocaml/ProductDemands.res

@@ -0,0 +1,8 @@
+// ProductDemand read model specification.
+// Tracks per-product order demand counts, combining data from Product and ProductDemand aggregates.
+
+@@reventless.spec
+
+@schema
+type state = {name: string, orderCount: int}
+

package/lib/ocaml/ProductDemands_GWT.res

@@ -0,0 +1,56 @@
+// Multi-source ReadModel: separate `_GWT` instances per source mapping.
+// `MultiSourceProjection_GWT.Make` is single-source; spec-stem uniqueness keeps
+// the file name singular while we instantiate one functor per mapping.
+
+module ProductGwt = ReventlessGwt.MultiSourceProjection_GWT.Make(
+  ProductDemands_Projections.ProductMapping,
+)
+module ProductDemandGwt = ReventlessGwt.MultiSourceProjection_GWT.Make(
+  ProductDemands_Projections.ProductDemandMapping,
+)
+
+ProductGwt.describe("ProductDemands ReadModel ← Product", () => {
+  ProductGwt.test("Added initialises the entry with orderCount = 0", () =>
+    ProductGwt.givenEvents([])
+    ->ProductGwt.whenEvent(Product.Added({name: "Laptop", description: "x", price: 1.0}))
+    ->ProductGwt.thenState({ProductDemands.name: "Laptop", orderCount: 0})
+  )
+
+  ProductGwt.test("NameUpdated is ignored (handled by Products read model)", () =>
+    ProductGwt.givenEvents([Product.Added({name: "Laptop", description: "x", price: 1.0})])
+    ->ProductGwt.whenEvent(Product.NameUpdated({name: "Gaming Laptop"}))
+    ->ProductGwt.thenState({ProductDemands.name: "Laptop", orderCount: 0})
+  )
+
+  ProductGwt.test("DescriptionUpdated is ignored", () =>
+    ProductGwt.givenEvents([Product.Added({name: "Laptop", description: "x", price: 1.0})])
+    ->ProductGwt.whenEvent(Product.DescriptionUpdated({description: "y"}))
+    ->ProductGwt.thenState({ProductDemands.name: "Laptop", orderCount: 0})
+  )
+
+  ProductGwt.test("PriceUpdated is ignored", () =>
+    ProductGwt.givenEvents([Product.Added({name: "Laptop", description: "x", price: 1.0})])
+    ->ProductGwt.whenEvent(Product.PriceUpdated({price: 2.0}))
+    ->ProductGwt.thenState({ProductDemands.name: "Laptop", orderCount: 0})
+  )
+})
+
+// `MultiSourceProjection_GWT` is single-source: the ProductDemand mapping
+// emits `Update(...)` that needs initial state seeded by the Product
+// mapping's `Set(...)`. Tested in isolation, both Update branches surface
+// a `StaleState` error. We assert the throw to lock in that the mapping
+// never tries to initialise its own row — the integration relies on
+// Product.Added arriving first.
+ProductDemandGwt.describe("ProductDemands ReadModel ← ProductDemand", () => {
+  ProductDemandGwt.test("Recorded without prior Product.Added throws StaleState", () =>
+    ProductDemandGwt.givenEvents([])
+    ->ProductDemandGwt.whenEvent(ProductDemand.Recorded({orderId: "order-1"}))
+    ->ProductDemandGwt.thenThrow
+  )
+
+  ProductDemandGwt.test("Revoked without prior Product.Added throws StaleState", () =>
+    ProductDemandGwt.givenEvents([])
+    ->ProductDemandGwt.whenEvent(ProductDemand.Revoked({orderId: "order-1"}))
+    ->ProductDemandGwt.thenThrow
+  )
+})

package/lib/ocaml/ProductDemands_Projections.res

@@ -0,0 +1,36 @@
+// ProductDemands projection mappings.
+// Multi-source read model: combines events from two aggregates.
+// Source 1: Product — initialises the entry on Added.
+// Source 2: ProductDemand — increments / decrements the order count.
+@@reventless.mappings
+
+module ProductMapping = Mapping.Make(
+  Product,
+  ProductDemands,
+  {
+    open Product
+    let project = ({event, id, _}) =>
+      switch event {
+      | Added({name}) =>
+        Set(id, {ProductDemands.name: name, orderCount: 0})
+      | _ => Ignore
+      }
+  },
+)
+
+module ProductDemandMapping = Mapping.Make(
+  ProductDemand,
+  ProductDemands,
+  {
+    open ProductDemand
+    let project = ({event, id, _}) =>
+      switch event {
+      | Recorded(_) =>
+        Update(id, (state: ProductDemands.state) => {...state, orderCount: state.orderCount + 1})
+      | Revoked(_) =>
+        Update(id, (state: ProductDemands.state) => {...state, orderCount: max(0, state.orderCount - 1)})
+      }
+  },
+)
+
+let mappings: array<module(Mapping)> = [module(ProductMapping), module(ProductDemandMapping)]

package/lib/ocaml/Product_Behavior.res

@@ -0,0 +1,38 @@
+// Product aggregate behavior.
+// Implements the state machine for adding and updating products.
+
+@@reventless.behavior
+
+@schema
+type state =
+  | NotCreated
+  | Created({name: string, description: string, price: float})
+
+let initialState = NotCreated
+
+let evolve = (state, event) =>
+  switch (state, event) {
+  | (NotCreated, Added({name, description, price})) => Created({name, description, price})
+  | (Created(_), Added({name, description, price})) => Created({name, description, price})
+  | (Created(s), NameUpdated({name})) => Created({...s, name})
+  | (Created(s), DescriptionUpdated({description})) => Created({...s, description})
+  | (Created(s), PriceUpdated({price})) => Created({...s, price})
+  | (NotCreated, _) => state
+  }
+
+let decide = (state, command) =>
+  switch (state, command) {
+  | (NotCreated, Add({name, description, price})) =>
+    Ok([Added({name, description, price})])
+  | (NotCreated, UpdateName(_)) => Error(ProductNotFound)
+  | (NotCreated, UpdateDescription(_)) => Error(ProductNotFound)
+  | (NotCreated, UpdatePrice(_)) => Error(ProductNotFound)
+  | (Created(_), Add(_)) => Error(ProductAlreadyExists)
+  | (Created(s), UpdateName({name})) if name == s.name => Ok([])
+  | (Created(_), UpdateName({name})) => Ok([NameUpdated({name: name})])
+  | (Created(s), UpdateDescription({description})) if description == s.description => Ok([])
+  | (Created(_), UpdateDescription({description})) =>
+    Ok([DescriptionUpdated({description: description})])
+  | (Created(s), UpdatePrice({price})) if price == s.price => Ok([])
+  | (Created(_), UpdatePrice({price})) => Ok([PriceUpdated({price: price})])
+  }

package/lib/ocaml/Product_GWT.res

@@ -0,0 +1,69 @@
+@@reventless.gwt
+
+describe("Product Behavior", () => {
+  test("Add on new aggregate produces Added", () =>
+    givenEvents([])
+    ->whenCmd(Add({name: "Laptop", description: "A laptop", price: 999.99}))
+    ->thenEvent(Added({name: "Laptop", description: "A laptop", price: 999.99}))
+  )
+
+  test("Add on existing aggregate returns ProductAlreadyExists", () =>
+    givenEvents([Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenCmd(Add({name: "Laptop 2", description: "Another", price: 1.0}))
+    ->thenError(ProductAlreadyExists)
+  )
+
+  test("UpdateName on non-existent aggregate returns ProductNotFound", () =>
+    givenEvents([])
+    ->whenCmd(UpdateName({name: "New Name"}))
+    ->thenError(ProductNotFound)
+  )
+
+  test("UpdateName on existing product produces NameUpdated", () =>
+    givenEvents([Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenCmd(UpdateName({name: "Gaming Laptop"}))
+    ->thenEvent(NameUpdated({name: "Gaming Laptop"}))
+  )
+
+  test("UpdateName to same name produces no events (idempotent)", () =>
+    givenEvents([Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenCmd(UpdateName({name: "Laptop"}))
+    ->thenNoEvent
+  )
+
+  test("UpdateDescription on non-existent aggregate returns ProductNotFound", () =>
+    givenEvents([])
+    ->whenCmd(UpdateDescription({description: "x"}))
+    ->thenError(ProductNotFound)
+  )
+
+  test("UpdateDescription on existing product produces DescriptionUpdated", () =>
+    givenEvents([Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenCmd(UpdateDescription({description: "A high-end laptop"}))
+    ->thenEvent(DescriptionUpdated({description: "A high-end laptop"}))
+  )
+
+  test("UpdateDescription to same description produces no events (idempotent)", () =>
+    givenEvents([Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenCmd(UpdateDescription({description: "A laptop"}))
+    ->thenNoEvent
+  )
+
+  test("UpdatePrice on non-existent aggregate returns ProductNotFound", () =>
+    givenEvents([])
+    ->whenCmd(UpdatePrice({price: 1.0}))
+    ->thenError(ProductNotFound)
+  )
+
+  test("UpdatePrice on existing product produces PriceUpdated", () =>
+    givenEvents([Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenCmd(UpdatePrice({price: 899.99}))
+    ->thenEvent(PriceUpdated({price: 899.99}))
+  )
+
+  test("UpdatePrice to same price produces no events (idempotent)", () =>
+    givenEvents([Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenCmd(UpdatePrice({price: 999.99}))
+    ->thenNoEvent
+  )
+})

package/lib/ocaml/Products.res

@@ -0,0 +1,12 @@
+// Products read model specification.
+// Query-side state for product listings.
+
+@@reventless.spec
+
+@schema
+type state = {
+  name: string,
+  description: string,
+  price: float,
+}
+

package/lib/ocaml/Products_ExtensionPointMapping.res

@@ -0,0 +1,19 @@
+// Maps internal Product aggregate events to the stable ProductsExtensionPoint public API.
+@@reventless.spec
+
+module ExtensionPoint = CatalogSpec.Products_ExtensionPoint
+module Delegate = Product
+
+let mapIncomingCommand = (_id, _command, _meta) => []
+
+let mapOutgoingEvent = Some((id, event, _meta, _queryEngine) =>
+  switch event {
+  | Product.Added({name, price}) => [
+      PublishEvent(id, CatalogSpec.Products_ExtensionPoint.ProductBecameAvailable({productId: id, name, price})),
+    ]
+  | Product.PriceUpdated({price}) => [
+      PublishEvent(id, CatalogSpec.Products_ExtensionPoint.ProductPriceChanged({productId: id, price})),
+    ]
+  | _ => []
+  }
+)

package/lib/ocaml/Products_ExtensionPointMapping_GWT.res

@@ -0,0 +1,31 @@
+// Boundary GWT for the Products extension point: internal Product aggregate
+// events become the stable public events Ordering subscribes to.
+@@reventless.gwt
+
+describe("Products ExtensionPoint mapping", () => {
+  test("Added publishes ProductBecameAvailable", () =>
+    whenDelegateEvent(
+      Delegate.Added({name: "Book", description: "A good book", price: 9.99}),
+    )->thenPublishesEvent(
+      "gwt-id",
+      ExtensionPoint.ProductBecameAvailable({productId: "gwt-id", name: "Book", price: 9.99}),
+    )
+  )
+
+  test("PriceUpdated publishes ProductPriceChanged", () =>
+    whenDelegateEvent(Delegate.PriceUpdated({price: 7.5}))->thenPublishesEvent(
+      "gwt-id",
+      ExtensionPoint.ProductPriceChanged({productId: "gwt-id", price: 7.5}),
+    )
+  )
+
+  test("NameUpdated publishes nothing", () =>
+    whenDelegateEvent(Delegate.NameUpdated({name: "Better Book"}))->thenPublishesNothing
+  )
+
+  test("DescriptionUpdated publishes nothing", () =>
+    whenDelegateEvent(
+      Delegate.DescriptionUpdated({description: "A really good book"}),
+    )->thenPublishesNothing
+  )
+})

package/lib/ocaml/Products_GWT.res

@@ -0,0 +1,27 @@
+@@reventless.gwt(Products_Projections.ProductMapping)
+
+describe("Products ReadModel ← Product", () => {
+  test("Added sets initial read model state", () =>
+    givenEvents([])
+    ->whenEvent(Product.Added({name: "Laptop", description: "A laptop", price: 999.99}))
+    ->thenState({Products.name: "Laptop", description: "A laptop", price: 999.99})
+  )
+
+  test("NameUpdated updates the name", () =>
+    givenEvents([Product.Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenEvent(Product.NameUpdated({name: "Gaming Laptop"}))
+    ->thenState({Products.name: "Gaming Laptop", description: "A laptop", price: 999.99})
+  )
+
+  test("DescriptionUpdated updates the description", () =>
+    givenEvents([Product.Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenEvent(Product.DescriptionUpdated({description: "A high-end laptop"}))
+    ->thenState({Products.name: "Laptop", description: "A high-end laptop", price: 999.99})
+  )
+
+  test("PriceUpdated updates the price", () =>
+    givenEvents([Product.Added({name: "Laptop", description: "A laptop", price: 999.99})])
+    ->whenEvent(Product.PriceUpdated({price: 899.99}))
+    ->thenState({Products.name: "Laptop", description: "A laptop", price: 899.99})
+  )
+})