@reventlessdev/online-shop-dcb-catalog 1.0.0-alpha.104

package/lib/ocaml/ChangeProductName_GWT.res

@@ -0,0 +1,21 @@
+@@reventless.gwt
+
+describe("ChangeProductName StateChangeSlice", () => {
+  test("non-existent product returns ProductNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ChangeProductName({productId: "p1", name: "Gaming Laptop"}))
+    ->thenError(ProductNotFound)
+  )
+
+  test("existing product produces ProductNameChanged", () =>
+    givenEvents([ProductAdded({name: "Laptop"})])
+    ->whenCmd(ChangeProductName({productId: "p1", name: "Gaming Laptop"}))
+    ->thenEvent(ProductNameChanged({productId: "p1", name: "Gaming Laptop"}))
+  )
+
+  test("same name produces no events (idempotent)", () =>
+    givenEvents([ProductAdded({name: "Laptop"})])
+    ->whenCmd(ChangeProductName({productId: "p1", name: "Laptop"}))
+    ->thenNoEvent
+  )
+})

package/lib/ocaml/ChangeProductPrice.res

@@ -0,0 +1,17 @@
+// ChangeProductPrice StateChangeSlice.
+// Requires product to exist; idempotent when price is unchanged.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | ProductAdded({price: float})
+  | ProductPriceChanged({price: float})
+
+@schema
+type command = ChangeProductPrice({productId: string, price: float})
+
+@schema
+type error = ProductNotFound
+
+@schema
+type event = ProductPriceChanged({productId: string, price: float})

package/lib/ocaml/ChangeProductPrice_Behavior.res

@@ -0,0 +1,23 @@
+@@reventless.behavior
+
+type state = {exists: bool, currentPrice: float}
+
+let initialState = {exists: false, currentPrice: 0.0}
+
+let evolve = (state, event) =>
+  switch event {
+  | ProductAdded({price}) => {exists: true, currentPrice: price}
+  | ProductPriceChanged({price}) => {...state, currentPrice: price}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | ChangeProductPrice({productId, price}) =>
+    if !state.exists {
+      Error(ProductNotFound)
+    } else if price == state.currentPrice {
+      Ok([]) // idempotent — price unchanged
+    } else {
+      Ok([ProductPriceChanged({productId, price})])
+    }
+  }

package/lib/ocaml/ChangeProductPrice_GWT.res

@@ -0,0 +1,21 @@
+@@reventless.gwt
+
+describe("ChangeProductPrice StateChangeSlice", () => {
+  test("non-existent product returns ProductNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ChangeProductPrice({productId: "p1", price: 899.99}))
+    ->thenError(ProductNotFound)
+  )
+
+  test("existing product produces ProductPriceChanged", () =>
+    givenEvents([ProductAdded({price: 999.99})])
+    ->whenCmd(ChangeProductPrice({productId: "p1", price: 899.99}))
+    ->thenEvent(ProductPriceChanged({productId: "p1", price: 899.99}))
+  )
+
+  test("same price produces no events (idempotent)", () =>
+    givenEvents([ProductAdded({price: 999.99})])
+    ->whenCmd(ChangeProductPrice({productId: "p1", price: 999.99}))
+    ->thenNoEvent
+  )
+})

package/lib/ocaml/ImportProduct.res

@@ -0,0 +1,23 @@
+// ImportProduct InboundTranslationSlice.
+// Receives external supplier JSON, validates and translates to an AddProduct command.
+
+@@reventless.spec
+
+@schema
+type externalInput = {
+  sku: string,
+  title: string,
+  desc: string,
+  unitPrice: int,
+  currency: string,
+}
+
+@schema
+type command = AddProduct({
+  productId: string,
+  name: string,
+  description: string,
+  price: float,
+})
+
+let targetName = "AddProduct"

package/lib/ocaml/ImportProduct_GWT.res

@@ -0,0 +1,42 @@
+// `InboundTranslation_GWT.Make` expects a single SliceSpec carrying both the
+// types (from the spec file) and the `translate` function (from the body
+// file). The split-form production layout doesn't expose them as one module,
+// so we compose them locally before handing the result to the DSL.
+
+module ImportProductSlice = {
+  include ImportProduct
+  let translate = ImportProduct_Translation.translate
+}
+
+@@reventless.gwt
+
+describe("ImportProduct InboundTranslationSlice", () => {
+  test("USD payload translates to AddProduct command", () =>
+    whenInput({
+      sku: "p-1",
+      title: "Laptop",
+      desc: "high-end",
+      unitPrice: 99999,
+      currency: "USD",
+    })
+    ->thenCommand(
+      "p-1",
+      AddProduct({productId: "p-1", name: "Laptop", description: "high-end", price: 999.99}),
+    )
+  )
+
+  test("non-USD currency surfaces a translate error", () =>
+    whenInput({sku: "p-1", title: "Laptop", desc: "x", unitPrice: 1, currency: "EUR"})
+    ->thenTranslateError("Unsupported currency: EUR")
+  )
+
+  test("non-positive price surfaces a translate error", () =>
+    whenInput({sku: "p-1", title: "Laptop", desc: "x", unitPrice: 0, currency: "USD"})
+    ->thenTranslateError("Price must be positive")
+  )
+
+  test("empty SKU surfaces a translate error", () =>
+    whenInput({sku: "", title: "Laptop", desc: "x", unitPrice: 100, currency: "USD"})
+    ->thenTranslateError("SKU is required")
+  )
+})

package/lib/ocaml/ImportProduct_Translation.res

@@ -0,0 +1,20 @@
+@@reventless.translation
+
+let translate = input =>
+  if input.currency !== "USD" {
+    Error("Unsupported currency: " ++ input.currency)
+  } else if input.unitPrice <= 0 {
+    Error("Price must be positive")
+  } else if input.sku === "" {
+    Error("SKU is required")
+  } else {
+    Ok([(
+      input.sku,
+      AddProduct({
+        productId: input.sku,
+        name: input.title,
+        description: input.desc,
+        price: Int.toFloat(input.unitPrice) /. 100.0,
+      }),
+    )])
+  }

package/lib/ocaml/ImportProducts.res

@@ -0,0 +1,57 @@
+// Import products from supplier JSON files uploaded to S3.
+// Each row is forwarded as `externalInput` to the ImportProduct
+// InboundTranslationSlice, which validates and translates to an AddProduct
+// command. Style purity: the Task drives a DCB slice, not an aggregate.
+
+@@reventless.task
+
+let importCallback = (~eventName, ~key) => {
+  if eventName->String.includes("ObjectCreated") {
+    Console.log("[ImportProducts] Processing file: " ++ key)
+
+    let meta: Message.meta = {
+      service: "ImportProducts",
+      time: Date.now()->Float.toString,
+      ip: "",
+      user: "system",
+      msgId: key,
+      correlationId: key,
+    }
+
+    // Stub demo payload — in a real implementation the bucket key would be
+    // fetched and parsed. We push a hard-coded supplier line through the
+    // InboundTranslationSlice so the wire-up is exercised end-to-end.
+    let demoInput: ImportProduct.externalInput = {
+      sku: key,
+      title: "Imported Product",
+      desc: "Imported from " ++ key,
+      unitPrice: 999,
+      currency: "USD",
+    }
+
+    [
+      Task.PublishCommands(
+        ImportProduct.name,
+        [
+          {
+            id: key,
+            meta,
+            commandJson: demoInput->Message.encode(ImportProduct.externalInputSchema),
+          },
+        ],
+      ),
+    ]->Promise.resolve
+  } else {
+    []->Promise.resolve
+  }
+}
+
+let setup = (_queryEngine, _queryBucketName, _opts) => {
+  Task.buckets: [
+    {
+      bucketName: "product-imports",
+      bucketMode: Task.Read,
+      callback: importCallback,
+    },
+  ],
+}

package/lib/ocaml/Orders_Extension.res

@@ -0,0 +1,23 @@
+// Catalog's extension subscribing to Ordering's Orders_ExtensionPoint.
+// Routes ItemOrdered / ItemOrderCancelled events to RecordProductDemand commands.
+
+@@reventless.extension
+
+module Mapping = {
+  module ExtensionPoint = OrderingSpec.Orders_ExtensionPoint
+  module Delegate = RecordProductDemand
+
+  open ExtensionPoint
+  open RecordProductDemand
+  let mapIncomingEvent = (_id, event, _meta, _pluginDef, _queryEngine) =>
+    switch event {
+    | ItemOrdered({productId, orderId}) => [
+        PublishStateChangeSliceCommand(RecordDemand({productId, orderId})),
+      ]
+    | ItemOrderCancelled({productId, orderId}) => [
+        PublishStateChangeSliceCommand(RevokeDemand({productId, orderId})),
+      ]
+    }
+
+  let mapOutgoingEvent = None
+}

package/lib/ocaml/Orders_Extension_GWT.res

@@ -0,0 +1,21 @@
+// Boundary GWT for Catalog's Orders extension: public Ordering events become
+// RecordProductDemand commands on Catalog's StateChangeSlices.
+@@reventless.gwt
+
+// `Mapping` is brought into scope by the PPX `open Orders_Extension`; opening
+// it surfaces the extension point's events and the delegate's commands.
+open Mapping
+
+describe("Orders Extension delegate", () => {
+  test("ItemOrdered records demand for the product", () =>
+    whenIncomingEvent(
+      ExtensionPoint.ItemOrdered({productId: "p1", orderId: "o1", customerId: "c1"}),
+    )->thenPublishesCommand(Delegate.RecordDemand({productId: "p1", orderId: "o1"}))
+  )
+
+  test("ItemOrderCancelled revokes demand for the product", () =>
+    whenIncomingEvent(
+      ExtensionPoint.ItemOrderCancelled({productId: "p1", orderId: "o1"}),
+    )->thenPublishesCommand(Delegate.RevokeDemand({productId: "p1", orderId: "o1"}))
+  )
+})

package/lib/ocaml/Plugin.res

@@ -0,0 +1,68 @@
+// 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) => {
+  // StateChangeSlices
+  module AddCategorySlice = Platform.StateChangeSlice.Make(AddCategory, AddCategory_Behavior)
+  module AddProductSlice = Platform.StateChangeSlice.Make(AddProduct, AddProduct_Behavior)
+  module ArchiveCategorySlice = Platform.StateChangeSlice.Make(ArchiveCategory, ArchiveCategory_Behavior)
+  module ChangeProductDescriptionSlice = Platform.StateChangeSlice.Make(ChangeProductDescription, ChangeProductDescription_Behavior)
+  module ChangeProductNameSlice = Platform.StateChangeSlice.Make(ChangeProductName, ChangeProductName_Behavior)
+  module ChangeProductPriceSlice = Platform.StateChangeSlice.Make(ChangeProductPrice, ChangeProductPrice_Behavior)
+  module RecordProductDemandSlice = Platform.StateChangeSlice.Make(RecordProductDemand, RecordProductDemand_Behavior)
+  module RenameCategorySlice = Platform.StateChangeSlice.Make(RenameCategory, RenameCategory_Behavior)
+
+  // StateViewSlices
+  module CategoriesSlice = Platform.StateViewSlice.Make(Categories, Categories_Projection)
+  module ProductDemandSlice = Platform.StateViewSlice.Make(ProductDemand, ProductDemand_Projection)
+  module ProductsSlice = Platform.StateViewSlice.Make(Products, Products_Projection)
+
+  // InboundTranslationSlices
+  module ImportProductSlice = Platform.InboundTranslationSlice.Make(ImportProduct, ImportProduct_Translation)
+
+  // ReadModels
+  module CategoryActivityReadModel = Platform.ReadModel.Make(CategoryActivity, CategoryActivity_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",
+    ~readModels=[module(CategoryActivityReadModel)],
+    ~stateViewSlices=[module(CategoriesSlice), module(ProductDemandSlice), module(ProductsSlice)],
+    ~stateChangeSlices=[module(AddCategorySlice), module(AddProductSlice), module(ArchiveCategorySlice), module(ChangeProductDescriptionSlice), module(ChangeProductNameSlice), module(ChangeProductPriceSlice), module(RecordProductDemandSlice), module(RenameCategorySlice)],
+    ~inboundTranslationSlices=[module(ImportProductSlice)],
+    ~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)],
+      ~readModels=[module(CategoryActivityReadModel)],
+      ~tasks=[module(ImportProductsTask)],
+      ~stateChangeSlices=[module(AddCategorySlice), module(AddProductSlice), module(ArchiveCategorySlice), module(ChangeProductDescriptionSlice), module(ChangeProductNameSlice), module(ChangeProductPriceSlice), module(RecordProductDemandSlice), module(RenameCategorySlice)],
+      ~stateViewSlices=[module(CategoriesSlice), module(ProductDemandSlice), module(ProductsSlice)],
+      ~inboundTranslationSlices=[module(ImportProductSlice)],
+      ~pluginStructure=pluginStructure,
+      ~uiFragments=?uiBundleUrl->Option.map(url =>
+        Platform.Plugin.makeAutoUIManifest(
+          ~remoteEntryUrl=url,
+          ~name="Catalog",
+          ~pluginStructure,
+          ~readModelPositions=["platform-summary"],
+          ~aggregatePositions=["resource-detail"],
+        )
+      ),
+    )
+}

package/lib/ocaml/ProductDemand.res

@@ -0,0 +1,12 @@
+// ProductDemand StateViewSlice.
+// Projects catalog events into a per-product demand counter (order count).
+@@reventless.spec
+
+@schema
+type state = {productId: string, name: string, orderCount: int}
+
+@schema
+type consumedEvent =
+  | ProductAdded({productId: string, name: string})
+  | ProductDemandRecorded({productId: string})
+  | ProductDemandRevoked({productId: string})

package/lib/ocaml/ProductDemand_GWT.res

@@ -0,0 +1,31 @@
+@@reventless.gwt
+
+describe("ProductDemand StateViewSlice", () => {
+  test("ProductAdded initialises a row with orderCount = 0", () =>
+    givenEvents([])
+    ->whenEvent(ProductAdded({productId: "p1", name: "Laptop"}))
+    ->thenStateWithId("p1", {productId: "p1", name: "Laptop", orderCount: 0})
+  )
+
+  test("ProductDemandRecorded increments orderCount", () =>
+    givenEvents([ProductAdded({productId: "p1", name: "Laptop"})])
+    ->whenEvent(ProductDemandRecorded({productId: "p1"}))
+    ->thenStateWithId("p1", {productId: "p1", name: "Laptop", orderCount: 1})
+  )
+
+  test("ProductDemandRevoked decrements orderCount", () =>
+    givenEvents([
+      ProductAdded({productId: "p1", name: "Laptop"}),
+      ProductDemandRecorded({productId: "p1"}),
+      ProductDemandRecorded({productId: "p1"}),
+    ])
+    ->whenEvent(ProductDemandRevoked({productId: "p1"}))
+    ->thenStateWithId("p1", {productId: "p1", name: "Laptop", orderCount: 1})
+  )
+
+  test("ProductDemandRevoked clamps orderCount at zero", () =>
+    givenEvents([ProductAdded({productId: "p1", name: "Laptop"})])
+    ->whenEvent(ProductDemandRevoked({productId: "p1"}))
+    ->thenStateWithId("p1", {productId: "p1", name: "Laptop", orderCount: 0})
+  )
+})

package/lib/ocaml/ProductDemand_Projection.res

@@ -0,0 +1,11 @@
+@@reventless.projection
+
+let project = event =>
+  switch event {
+  | ProductAdded({productId, name}) =>
+    [UpdateWithDefault(productId, {productId, name, orderCount: 0}, s => {...s, name})]
+  | ProductDemandRecorded({productId}) =>
+    [Update(productId, s => {...s, orderCount: s.orderCount + 1})]
+  | ProductDemandRevoked({productId}) =>
+    [Update(productId, s => {...s, orderCount: max(0, s.orderCount - 1)})]
+  }

package/lib/ocaml/Products.res

@@ -0,0 +1,13 @@
+// Products StateViewSlice.
+// Projects product events from the shared catalog event log into a Products read model.
+@@reventless.spec
+
+@schema
+type state = {productId: string, name: string, description: string, price: float}
+
+@schema
+type consumedEvent =
+  | ProductAdded({productId: string, name: string, description: string, price: float})
+  | ProductNameChanged({productId: string, name: string})
+  | ProductDescriptionChanged({productId: string, description: string})
+  | ProductPriceChanged({productId: string, price: float})

package/lib/ocaml/Products_ExtensionPointMapping.res

@@ -0,0 +1,33 @@
+// Maps internal Catalog events to the stable Products_ExtensionPoint public API.
+@@reventless.spec
+
+module ExtensionPoint = CatalogSpec.Products_ExtensionPoint
+
+// DCB adapter: defines the event type used for outgoing event mapping.
+// Only the events relevant to the extension point are included.
+// `name` MUST equal `<pluginName>DcbEventLog` so the dispatch in
+// `Plugin_Callback` resolves it to the topic key `Plugin_Builder` registers
+// under (`name ++ "DcbEventLog"`).
+module Delegate = {
+  let name = "CatalogDcbEventLog"
+  @schema
+  type event =
+    | ProductAdded({productId: string, name: string, description: string, price: float})
+    | ProductPriceChanged({productId: string, price: float})
+}
+
+let mapIncomingCommand = (_id, _command, _meta) => []
+
+let mapOutgoingEvent = Some((_id, event, _meta, _queryEngine) =>
+  switch event {
+  | Delegate.ProductAdded({productId, name, price}) => [
+      PublishEvent(
+        productId,
+        CatalogSpec.Products_ExtensionPoint.ProductBecameAvailable({productId, name, price}),
+      ),
+    ]
+  | Delegate.ProductPriceChanged({productId, price}) => [
+      PublishEvent(productId, CatalogSpec.Products_ExtensionPoint.ProductPriceChanged({productId, price})),
+    ]
+  }
+)

package/lib/ocaml/Products_ExtensionPointMapping_GWT.res

@@ -0,0 +1,21 @@
+// Boundary GWT for the Products extension point: internal Catalog DCB log
+// events become the stable public events Ordering subscribes to.
+@@reventless.gwt
+
+describe("Products ExtensionPoint mapping", () => {
+  test("ProductAdded publishes ProductBecameAvailable", () =>
+    whenDelegateEvent(
+      Delegate.ProductAdded({productId: "p1", name: "Book", description: "A good book", price: 9.99}),
+    )->thenPublishesEvent(
+      "p1",
+      ExtensionPoint.ProductBecameAvailable({productId: "p1", name: "Book", price: 9.99}),
+    )
+  )
+
+  test("ProductPriceChanged publishes ProductPriceChanged", () =>
+    whenDelegateEvent(Delegate.ProductPriceChanged({productId: "p1", price: 7.5}))->thenPublishesEvent(
+      "p1",
+      ExtensionPoint.ProductPriceChanged({productId: "p1", price: 7.5}),
+    )
+  )
+})