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

package/lib/ocaml/ArchiveCategory.res

@@ -0,0 +1,18 @@
+// ArchiveCategory StateChangeSlice.
+// Requires category to exist; idempotent if already archived.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | CategoryAdded
+  | CategoryArchived
+
+@schema
+type command =
+  | @authorize(AllowGroups(["Admin"])) ArchiveCategory({categoryId: string})
+
+@schema
+type error = CategoryNotFound
+
+@schema
+type event = CategoryArchived({categoryId: string})

package/lib/ocaml/ArchiveCategory_Behavior.res

@@ -0,0 +1,23 @@
+@@reventless.behavior
+
+type state = {exists: bool, archived: bool}
+
+let initialState = {exists: false, archived: false}
+
+let evolve = (state, event) =>
+  switch event {
+  | CategoryAdded => {exists: true, archived: false}
+  | CategoryArchived => {...state, archived: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | ArchiveCategory({categoryId: theId}) =>
+    if !state.exists {
+      Error(CategoryNotFound)
+    } else if state.archived {
+      Ok([]) // idempotent — already archived
+    } else {
+      Ok([CategoryArchived({categoryId: theId})])
+    }
+  }

package/lib/ocaml/ArchiveCategory_GWT.res

@@ -0,0 +1,21 @@
+@@reventless.gwt
+
+describe("ArchiveCategory StateChangeSlice", () => {
+  test("non-existent category returns CategoryNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ArchiveCategory({categoryId: "c1"}))
+    ->thenError(CategoryNotFound)
+  )
+
+  test("existing active category produces CategoryArchived", () =>
+    givenEvents([CategoryAdded])
+    ->whenCmd(ArchiveCategory({categoryId: "c1"}))
+    ->thenEvent(CategoryArchived({categoryId: "c1"}))
+  )
+
+  test("already archived category produces no events (idempotent)", () =>
+    givenEvents([CategoryAdded, CategoryArchived])
+    ->whenCmd(ArchiveCategory({categoryId: "c1"}))
+    ->thenNoEvent
+  )
+})

package/lib/ocaml/CatalogPlugin.mlmap

@@ -0,0 +1,46 @@
+randjbuildsystem
+AddCategory
+AddCategory_Behavior
+AddCategory_GWT
+AddProduct
+AddProduct_Behavior
+AddProduct_GWT
+ArchiveCategory
+ArchiveCategory_Behavior
+ArchiveCategory_GWT
+Categories
+Categories_GWT
+Categories_Projection
+CategoryActivity
+CategoryActivity_GWT
+CategoryActivity_Projections
+ChangeProductDescription
+ChangeProductDescription_Behavior
+ChangeProductDescription_GWT
+ChangeProductName
+ChangeProductName_Behavior
+ChangeProductName_GWT
+ChangeProductPrice
+ChangeProductPrice_Behavior
+ChangeProductPrice_GWT
+ImportProduct
+ImportProduct_GWT
+ImportProduct_Translation
+ImportProducts
+Orders_Extension
+Orders_Extension_GWT
+Plugin
+ProductDemand
+ProductDemand_GWT
+ProductDemand_Projection
+Products
+Products_ExtensionPointMapping
+Products_ExtensionPointMapping_GWT
+Products_GWT
+Products_Projection
+RecordProductDemand
+RecordProductDemand_Behavior
+RecordProductDemand_GWT
+RenameCategory
+RenameCategory_Behavior
+RenameCategory_GWT

package/lib/ocaml/Categories.res

@@ -0,0 +1,12 @@
+// Categories StateViewSlice.
+// Projects category events from the shared catalog event log into a Categories read model.
+@@reventless.spec
+
+@schema
+type state = {categoryId: string, name: string, archived: bool}
+
+@schema
+type consumedEvent =
+  | CategoryAdded({categoryId: string, name: string})
+  | CategoryRenamed({categoryId: string, name: string})
+  | CategoryArchived({categoryId: string})

package/lib/ocaml/Categories_GWT.res

@@ -0,0 +1,21 @@
+@@reventless.gwt
+
+describe("Categories StateViewSlice", () => {
+  test("CategoryAdded creates a row", () =>
+    givenEvents([])
+    ->whenEvent(CategoryAdded({categoryId: "c1", name: "Electronics"}))
+    ->thenStateWithId("c1", {categoryId: "c1", name: "Electronics", archived: false})
+  )
+
+  test("CategoryRenamed updates the name", () =>
+    givenEvents([CategoryAdded({categoryId: "c1", name: "Electronics"})])
+    ->whenEvent(CategoryRenamed({categoryId: "c1", name: "Consumer Electronics"}))
+    ->thenStateWithId("c1", {categoryId: "c1", name: "Consumer Electronics", archived: false})
+  )
+
+  test("CategoryArchived sets archived flag", () =>
+    givenEvents([CategoryAdded({categoryId: "c1", name: "Electronics"})])
+    ->whenEvent(CategoryArchived({categoryId: "c1"}))
+    ->thenStateWithId("c1", {categoryId: "c1", name: "Electronics", archived: true})
+  )
+})

package/lib/ocaml/Categories_Projection.res

@@ -0,0 +1,10 @@
+@@reventless.projection
+
+let project = event =>
+  switch event {
+  | CategoryAdded({categoryId, name}) => [
+      Set(categoryId, {categoryId, name, archived: false}),
+    ]
+  | CategoryRenamed({categoryId, name}) => [Update(categoryId, state => {...state, name})]
+  | CategoryArchived({categoryId}) => [Update(categoryId, state => {...state, archived: true})]
+  }

package/lib/ocaml/CategoryActivity.res

@@ -0,0 +1,25 @@
+// Catalog activity read model — a denormalised audit row per entity (category
+// or product) that has changed in the catalog. Populated from TWO views of the
+// shared catalog DCB EventLog: Category-side events and Product-side events.
+// See `CategoryActivity_Projections.res` for the multi-source mapping. The
+// example stays DCB-pure: both sources resolve to the same DCB EventLog name.
+
+@@reventless.spec
+
+@schema
+type kind =
+  | Category
+  | Product
+
+@schema
+type change =
+  | Added
+  | Renamed
+  | Archived
+
+@schema
+type state = {
+  name: string,
+  kind: kind,
+  lastChange: change,
+}

package/lib/ocaml/CategoryActivity_GWT.res

@@ -0,0 +1,100 @@
+// Multi-source ReadModel: one `_GWT` instance per source mapping. The
+// `MultiSourceProjection_GWT.Make` functor is single-source — wire one GWT
+// module per Source view and let each describe its own slice of behaviour.
+
+module CategoryGwt = ReventlessGwt.MultiSourceProjection_GWT.Make(
+  CategoryActivity_Projections.CategoryActivityMapping,
+)
+module ProductGwt = ReventlessGwt.MultiSourceProjection_GWT.Make(
+  CategoryActivity_Projections.ProductActivityMapping,
+)
+
+CategoryGwt.describe("CategoryActivity ReadModel ← Category DCB events", () => {
+  CategoryGwt.test("CategoryAdded sets name + kind=Category lastChange=Added", () =>
+    CategoryGwt.givenEvents([])
+    ->CategoryGwt.whenEvent(
+      CategoryActivity_Projections.CategoryEvents.CategoryAdded({
+        categoryId: "c1",
+        name: "Electronics",
+      }),
+    )
+    ->CategoryGwt.thenStateWithId(
+      "c1",
+      {CategoryActivity.name: "Electronics", kind: Category, lastChange: Added},
+    )
+  )
+
+  CategoryGwt.test("CategoryRenamed updates name + lastChange=Renamed", () =>
+    CategoryGwt.givenEvents([
+      CategoryActivity_Projections.CategoryEvents.CategoryAdded({
+        categoryId: "c1",
+        name: "Electronics",
+      }),
+    ])
+    ->CategoryGwt.whenEvent(
+      CategoryActivity_Projections.CategoryEvents.CategoryRenamed({
+        categoryId: "c1",
+        name: "Consumer Electronics",
+      }),
+    )
+    ->CategoryGwt.thenStateWithId(
+      "c1",
+      {CategoryActivity.name: "Consumer Electronics", kind: Category, lastChange: Renamed},
+    )
+  )
+
+  CategoryGwt.test("CategoryArchived keeps name and sets lastChange=Archived", () =>
+    CategoryGwt.givenEvents([
+      CategoryActivity_Projections.CategoryEvents.CategoryAdded({
+        categoryId: "c1",
+        name: "Electronics",
+      }),
+    ])
+    ->CategoryGwt.whenEvent(
+      CategoryActivity_Projections.CategoryEvents.CategoryArchived({categoryId: "c1"}),
+    )
+    ->CategoryGwt.thenStateWithId(
+      "c1",
+      {CategoryActivity.name: "Electronics", kind: Category, lastChange: Archived},
+    )
+  )
+})
+
+ProductGwt.describe("CategoryActivity ReadModel ← Product DCB events", () => {
+  ProductGwt.test("ProductAdded sets name + kind=Product lastChange=Added", () =>
+    ProductGwt.givenEvents([])
+    ->ProductGwt.whenEvent(
+      CategoryActivity_Projections.ProductEvents.ProductAdded({
+        productId: "p1",
+        name: "Laptop",
+        description: "x",
+        price: 1.0,
+      }),
+    )
+    ->ProductGwt.thenStateWithId(
+      "p1",
+      {CategoryActivity.name: "Laptop", kind: Product, lastChange: Added},
+    )
+  )
+
+  ProductGwt.test("ProductNameChanged updates name + lastChange=Renamed", () =>
+    ProductGwt.givenEvents([
+      CategoryActivity_Projections.ProductEvents.ProductAdded({
+        productId: "p1",
+        name: "Laptop",
+        description: "x",
+        price: 1.0,
+      }),
+    ])
+    ->ProductGwt.whenEvent(
+      CategoryActivity_Projections.ProductEvents.ProductNameChanged({
+        productId: "p1",
+        name: "Gaming Laptop",
+      }),
+    )
+    ->ProductGwt.thenStateWithId(
+      "p1",
+      {CategoryActivity.name: "Gaming Laptop", kind: Product, lastChange: Renamed},
+    )
+  )
+})

package/lib/ocaml/CategoryActivity_Projections.res

@@ -0,0 +1,92 @@
+// CategoryActivity mappings: a single ReadModel fed by TWO DCB source views of
+// the catalog plugin's shared DCB EventLog.
+//
+// `Mapping.sourceName` MUST equal `<pluginName>DcbEventLog` for both sources
+// (this is the key under which `Plugin_Builder` registers the catalog plugin's
+// DCB EventTopic AND the `meta.service` value DcbEventLog stamps on every
+// published event). Multiple Mappings with the same `sourceName` is the
+// canonical DCB-pure multi-source pattern: each Mapping carves a typed subset
+// of the full DCB event union and projects into a different shape of the
+// shared ReadModel state.
+
+@@reventless.mappings
+
+// ─────────────────────────────────────────────────────────────
+// DCB source view 1 — Category-side events
+// ─────────────────────────────────────────────────────────────
+
+module CategoryEvents = {
+  let name = "CatalogDcbEventLog"
+
+  @schema
+  type event =
+    | CategoryAdded({categoryId: string, name: string})
+    | CategoryRenamed({categoryId: string, name: string})
+    | CategoryArchived({categoryId: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// DCB source view 2 — Product-side events
+// ─────────────────────────────────────────────────────────────
+
+module ProductEvents = {
+  let name = "CatalogDcbEventLog"
+
+  @schema
+  type event =
+    | ProductAdded({productId: string, name: string, description: string, price: float})
+    | ProductNameChanged({productId: string, name: string})
+}
+
+// ─────────────────────────────────────────────────────────────
+// Mapping 1 — Category source view
+// ─────────────────────────────────────────────────────────────
+
+module CategoryActivityMapping = Mapping.Make(
+  CategoryEvents,
+  CategoryActivity,
+  {
+    open CategoryEvents
+    let project = ({event, _}) =>
+      switch event {
+      | CategoryAdded({categoryId, name}) =>
+        Set(
+          categoryId,
+          {
+            CategoryActivity.name: name,
+            kind: Category,
+            lastChange: (Added: CategoryActivity.change),
+          },
+        )
+      | CategoryRenamed({categoryId, name}) =>
+        Update(categoryId, state => {
+          ...state,
+          name,
+          lastChange: (Renamed: CategoryActivity.change),
+        })
+      | CategoryArchived({categoryId}) =>
+        Update(categoryId, state => {...state, lastChange: (Archived: CategoryActivity.change)})
+      }
+  },
+)
+
+// ─────────────────────────────────────────────────────────────
+// Mapping 2 — Product source view
+// ─────────────────────────────────────────────────────────────
+
+module ProductActivityMapping = Mapping.Make(
+  ProductEvents,
+  CategoryActivity,
+  {
+    open ProductEvents
+    let project = ({event, _}) =>
+      switch event {
+      | ProductAdded({productId, name}) =>
+        Set(productId, {CategoryActivity.name: name, kind: Product, lastChange: Added})
+      | ProductNameChanged({productId, name}) =>
+        Update(productId, state => {...state, name, lastChange: Renamed})
+      }
+  },
+)
+
+let mappings: array<module(Mapping)> = [module(CategoryActivityMapping), module(ProductActivityMapping)]

package/lib/ocaml/ChangeProductDescription.res

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

package/lib/ocaml/ChangeProductDescription_Behavior.res

@@ -0,0 +1,26 @@
+@@reventless.behavior
+
+type state = {exists: bool, currentDescription: string}
+
+let initialState = {exists: false, currentDescription: ""}
+
+let evolve = (state, event) =>
+  switch event {
+  | ProductAdded({description}) => {exists: true, currentDescription: description}
+  | ProductDescriptionChanged({description}) => {
+      ...state,
+      currentDescription: description,
+    }
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | ChangeProductDescription({productId, description}) =>
+    if !state.exists {
+      Error(ProductNotFound)
+    } else if description == state.currentDescription {
+      Ok([]) // idempotent — description unchanged
+    } else {
+      Ok([ProductDescriptionChanged({productId, description})])
+    }
+  }

package/lib/ocaml/ChangeProductDescription_GWT.res

@@ -0,0 +1,21 @@
+@@reventless.gwt
+
+describe("ChangeProductDescription StateChangeSlice", () => {
+  test("non-existent product returns ProductNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ChangeProductDescription({productId: "p1", description: "high-end"}))
+    ->thenError(ProductNotFound)
+  )
+
+  test("existing product produces ProductDescriptionChanged", () =>
+    givenEvents([ProductAdded({description: "A laptop"})])
+    ->whenCmd(ChangeProductDescription({productId: "p1", description: "high-end laptop"}))
+    ->thenEvent(ProductDescriptionChanged({productId: "p1", description: "high-end laptop"}))
+  )
+
+  test("same description produces no events (idempotent)", () =>
+    givenEvents([ProductAdded({description: "A laptop"})])
+    ->whenCmd(ChangeProductDescription({productId: "p1", description: "A laptop"}))
+    ->thenNoEvent
+  )
+})

package/lib/ocaml/ChangeProductName.res

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

package/lib/ocaml/ChangeProductName_Behavior.res

@@ -0,0 +1,23 @@
+@@reventless.behavior
+
+type state = {exists: bool, currentName: string}
+
+let initialState = {exists: false, currentName: ""}
+
+let evolve = (state, event) =>
+  switch event {
+  | ProductAdded({name}) => {exists: true, currentName: name}
+  | ProductNameChanged({name}) => {...state, currentName: name}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | ChangeProductName({productId, name}) =>
+    if !state.exists {
+      Error(ProductNotFound)
+    } else if name == state.currentName {
+      Ok([]) // idempotent — name unchanged
+    } else {
+      Ok([ProductNameChanged({productId, name})])
+    }
+  }