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

package/lib/ocaml/Products_GWT.res

@@ -0,0 +1,39 @@
+@@reventless.gwt
+
+describe("Products StateViewSlice", () => {
+  test("ProductAdded creates a row", () =>
+    givenEvents([])
+    ->whenEvent(ProductAdded({productId: "p1", name: "Laptop", description: "x", price: 999.99}))
+    ->thenStateWithId(
+      "p1",
+      {productId: "p1", name: "Laptop", description: "x", price: 999.99},
+    )
+  )
+
+  test("ProductNameChanged updates the name", () =>
+    givenEvents([ProductAdded({productId: "p1", name: "Laptop", description: "x", price: 999.99})])
+    ->whenEvent(ProductNameChanged({productId: "p1", name: "Gaming Laptop"}))
+    ->thenStateWithId(
+      "p1",
+      {productId: "p1", name: "Gaming Laptop", description: "x", price: 999.99},
+    )
+  )
+
+  test("ProductDescriptionChanged updates the description", () =>
+    givenEvents([ProductAdded({productId: "p1", name: "Laptop", description: "x", price: 999.99})])
+    ->whenEvent(ProductDescriptionChanged({productId: "p1", description: "high-end"}))
+    ->thenStateWithId(
+      "p1",
+      {productId: "p1", name: "Laptop", description: "high-end", price: 999.99},
+    )
+  )
+
+  test("ProductPriceChanged updates the price", () =>
+    givenEvents([ProductAdded({productId: "p1", name: "Laptop", description: "x", price: 999.99})])
+    ->whenEvent(ProductPriceChanged({productId: "p1", price: 899.99}))
+    ->thenStateWithId(
+      "p1",
+      {productId: "p1", name: "Laptop", description: "x", price: 899.99},
+    )
+  )
+})

package/lib/ocaml/Products_Projection.res

@@ -0,0 +1,13 @@
+@@reventless.projection
+
+let project = event =>
+  switch event {
+  | ProductAdded({productId, name, description, price}) => [
+      Set(productId, {productId, name, description, price}),
+    ]
+  | ProductNameChanged({productId, name}) => [Update(productId, state => {...state, name})]
+  | ProductDescriptionChanged({productId, description}) => [
+      Update(productId, state => {...state, description}),
+    ]
+  | ProductPriceChanged({productId, price}) => [Update(productId, state => {...state, price})]
+  }

package/lib/ocaml/RecordProductDemand.res

@@ -0,0 +1,30 @@
+// RecordProductDemand StateChangeSlice.
+// Records and revokes per-product order demand driven by Ordering's extension point events.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | ProductDemandRecorded({orderId: string})
+  | ProductDemandRevoked({orderId: string})
+
+// Not a UI/API command — driven only by Ordering's extension-point events.
+// @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 =
+  | RecordDemand({productId: string, orderId: string})
+  | RevokeDemand({productId: string, orderId: string})
+
+@schema
+type error = unit // always succeeds — demand recording is idempotent
+
+@schema
+type event =
+  | ProductDemandRecorded({
+      @partitionTag productId: string,
+      orderId: string,
+    })
+  | ProductDemandRevoked({
+      @partitionTag productId: string,
+      orderId: string,
+    })

package/lib/ocaml/RecordProductDemand_Behavior.res

@@ -0,0 +1,30 @@
+@@reventless.behavior
+
+type state = {recordedOrderIds: array<string>}
+let initialState = {recordedOrderIds: []}
+
+let evolve = (state, event) =>
+  switch event {
+  | ProductDemandRecorded({orderId}) => {
+      recordedOrderIds: Array.concat(state.recordedOrderIds, [orderId]),
+    }
+  | ProductDemandRevoked({orderId}) => {
+      recordedOrderIds: state.recordedOrderIds->Array.filter(id => id !== orderId),
+    }
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | RecordDemand({productId, orderId}) =>
+    if state.recordedOrderIds->Array.includes(orderId) {
+      Ok([]) // idempotent
+    } else {
+      Ok([ProductDemandRecorded({productId, orderId})])
+    }
+  | RevokeDemand({productId, orderId}) =>
+    if !(state.recordedOrderIds->Array.includes(orderId)) {
+      Ok([]) // idempotent
+    } else {
+      Ok([ProductDemandRevoked({productId, orderId})])
+    }
+  }

package/lib/ocaml/RecordProductDemand_GWT.res

@@ -0,0 +1,39 @@
+@@reventless.gwt
+
+describe("RecordProductDemand StateChangeSlice", () => {
+  test("first RecordDemand produces ProductDemandRecorded", () =>
+    givenEvents([])
+    ->whenCmd(RecordDemand({productId: "p1", orderId: "order-1"}))
+    ->thenEvent(ProductDemandRecorded({productId: "p1", orderId: "order-1"}))
+  )
+
+  test("RecordDemand for new orderId on existing product produces ProductDemandRecorded", () =>
+    givenEvents([ProductDemandRecorded({orderId: "order-1"})])
+    ->whenCmd(RecordDemand({productId: "p1", orderId: "order-2"}))
+    ->thenEvent(ProductDemandRecorded({productId: "p1", orderId: "order-2"}))
+  )
+
+  test("RecordDemand for already-recorded orderId produces no events (idempotent)", () =>
+    givenEvents([ProductDemandRecorded({orderId: "order-1"})])
+    ->whenCmd(RecordDemand({productId: "p1", orderId: "order-1"}))
+    ->thenNoEvent
+  )
+
+  test("RevokeDemand on never-recorded product produces no events (idempotent)", () =>
+    givenEvents([])
+    ->whenCmd(RevokeDemand({productId: "p1", orderId: "order-1"}))
+    ->thenNoEvent
+  )
+
+  test("RevokeDemand for unrecorded orderId on existing product produces no events (idempotent)", () =>
+    givenEvents([ProductDemandRecorded({orderId: "order-1"})])
+    ->whenCmd(RevokeDemand({productId: "p1", orderId: "order-2"}))
+    ->thenNoEvent
+  )
+
+  test("RevokeDemand for recorded orderId produces ProductDemandRevoked", () =>
+    givenEvents([ProductDemandRecorded({orderId: "order-1"})])
+    ->whenCmd(RevokeDemand({productId: "p1", orderId: "order-1"}))
+    ->thenEvent(ProductDemandRevoked({productId: "p1", orderId: "order-1"}))
+  )
+})

package/lib/ocaml/RenameCategory.res

@@ -0,0 +1,23 @@
+// RenameCategory StateChangeSlice.
+// Requires category to exist and not be archived. Renaming to the current
+// name is a no-op — commands may be retried under at-least-once delivery.
+@@reventless.spec
+
+// `CategoryAdded` / `CategoryRenamed` carry `name` so the decision model knows
+// the current name and can short-circuit a rename to the same value.
+@schema
+type consumedEvent =
+  | CategoryAdded({name: string})
+  | CategoryRenamed({name: string})
+  | CategoryArchived
+
+@schema
+type command = RenameCategory({categoryId: string, name: string})
+
+@schema
+type error =
+  | CategoryNotFound
+  | CategoryAlreadyArchived
+
+@schema
+type event = CategoryRenamed({categoryId: string, name: string})

package/lib/ocaml/RenameCategory_Behavior.res

@@ -0,0 +1,26 @@
+@@reventless.behavior
+
+type state = {exists: bool, archived: bool, name: string}
+
+let initialState = {exists: false, archived: false, name: ""}
+
+let evolve = (state, event: consumedEvent) =>
+  switch event {
+  | CategoryAdded({name}) => {exists: true, archived: false, name}
+  | CategoryRenamed({name}) => {...state, name}
+  | CategoryArchived => {...state, archived: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | RenameCategory({categoryId, name}) =>
+    if !state.exists {
+      Error(CategoryNotFound)
+    } else if state.archived {
+      Error(CategoryAlreadyArchived)
+    } else if name == state.name {
+      Ok([])
+    } else {
+      Ok([CategoryRenamed({categoryId, name})])
+    }
+  }

package/lib/ocaml/RenameCategory_GWT.res

@@ -0,0 +1,27 @@
+@@reventless.gwt
+
+describe("RenameCategory StateChangeSlice", () => {
+  test("non-existent category returns CategoryNotFound", () =>
+    givenEvents([])
+    ->whenCmd(RenameCategory({categoryId: "c1", name: "Consumer Electronics"}))
+    ->thenError(CategoryNotFound)
+  )
+
+  test("existing active category produces CategoryRenamed", () =>
+    givenEvents([CategoryAdded({name: "Electronics"})])
+    ->whenCmd(RenameCategory({categoryId: "c1", name: "Consumer Electronics"}))
+    ->thenEvent(CategoryRenamed({categoryId: "c1", name: "Consumer Electronics"}))
+  )
+
+  test("renaming to the current name produces no events (idempotent)", () =>
+    givenEvents([CategoryAdded({name: "Electronics"})])
+    ->whenCmd(RenameCategory({categoryId: "c1", name: "Electronics"}))
+    ->thenNoEvent
+  )
+
+  test("archived category returns CategoryAlreadyArchived", () =>
+    givenEvents([CategoryAdded({name: "Electronics"}), CategoryArchived])
+    ->whenCmd(RenameCategory({categoryId: "c1", name: "Consumer Electronics"}))
+    ->thenError(CategoryAlreadyArchived)
+  )
+})

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@reventlessdev/online-shop-dcb-catalog",
+  "version": "1.0.0-alpha.104",
+  "description": "Online Shop example — Catalog bounded context (Product & Category) using the DCB pattern",
+  "license": "Apache-2.0",
+  "jest": {
+    "testMatch": [
+      "<rootDir>/tests/**/*Test.res.mjs",
+      "<rootDir>/tests/**/*_GWT.res.mjs"
+    ],
+    "moduleFileExtensions": [
+      "js",
+      "mjs"
+    ],
+    "moduleNameMapper": {
+      "^@npmcli/arborist$": "<rootDir>/__mocks__/emptyModule.js",
+      "^spdx-license-ids$": "<rootDir>/../../../node_modules/spdx-license-ids/index.json",
+      "^spdx-license-ids/deprecated$": "<rootDir>/../../../node_modules/spdx-license-ids/deprecated.json",
+      "^spdx-exceptions$": "<rootDir>/../../../node_modules/spdx-exceptions/index.json"
+    }
+  },
+  "dependencies": {
+    "sury": "^11.0.0-alpha.4",
+    "@reventlessdev/online-shop-dcb-catalog-spec": "1.0.0-alpha.58",
+    "@reventlessdev/online-shop-dcb-ordering-spec": "1.0.0-alpha.58",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.74",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.81",
+    "@reventlessdev/reventless-local": "3.0.0-alpha.113",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.61"
+  },
+  "devDependencies": {
+    "rescript": "^12.3.0",
+    "sury-ppx": "11.0.0-alpha.2",
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.47"
+  },
+  "peerDependencies": {
+    "rescript": "^12.3.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "generate": "generate-plugin src/",
+    "prebuild": "pnpm run generate",
+    "build": "rescript build",
+    "start": "rescript watch",
+    "clean": "rescript clean",
+    "rebuild": "pnpm run clean && pnpm run build -- -with-deps",
+    "test": "NODE_OPTIONS='--experimental-vm-modules' npx jest"
+  }
+}

package/rescript.json

@@ -0,0 +1,37 @@
+{
+  "name": "@reventlessdev/online-shop-dcb-catalog",
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "namespace": "CatalogPlugin",
+  "ppx-flags": [
+    "@reventlessdev/reventless-ppx/bin",
+    "sury-ppx/bin"
+  ],
+  "warnings": {
+    "error": "-44+101"
+  },
+  "sources": [
+    {
+      "dir": "src",
+      "subdirs": true
+    },
+    {
+      "dir": "tests",
+      "subdirs": true
+    }
+  ],
+  "dependencies": [
+    "sury",
+    "@reventlessdev/reventless-infra",
+    "@reventlessdev/reventless-spec",
+    "@reventlessdev/reventless-local",
+    "@reventlessdev/reventless-gwt",
+    "@reventlessdev/rescript-pulumi-pulumi",
+    "@reventlessdev/online-shop-dcb-catalog-spec",
+    "@reventlessdev/online-shop-dcb-ordering-spec"
+  ],
+  "compiler-flags": [],
+  "suffix": ".res.mjs"
+}

package/src/Category/StateChangeSlice/AddCategory.res

@@ -0,0 +1,17 @@
+// AddCategory StateChangeSlice.
+// Handles the AddCategory command; rejects duplicate creation via DCB optimistic concurrency.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | CategoryAdded
+  | CategoryArchived
+
+@schema
+type command = AddCategory({categoryId: string, name: string})
+
+@schema
+type error = CategoryAlreadyExists
+
+@schema
+type event = CategoryAdded({categoryId: string, name: string})

package/src/Category/StateChangeSlice/AddCategory.res.mjs

@@ -0,0 +1,48 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.literal("CategoryAdded"),
+  S.literal("CategoryArchived")
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "AddCategory",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.literal("CategoryAlreadyExists");
+
+let eventSchema = S.schema(s => ({
+  TAG: "CategoryAdded",
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "AddCategory";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-catalog/src/Category/StateChangeSlice/AddCategory.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */

package/src/Category/StateChangeSlice/AddCategory_Behavior.res

@@ -0,0 +1,21 @@
+@@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 {
+  | AddCategory({categoryId, name}) =>
+    if state.exists {
+      Error(CategoryAlreadyExists)
+    } else {
+      Ok([CategoryAdded({categoryId, name})])
+    }
+  }

package/src/Category/StateChangeSlice/AddCategory_Behavior.res.mjs

@@ -0,0 +1,52 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function evolve(state, event) {
+  if (event === "CategoryAdded") {
+    return {
+      exists: true,
+      archived: false
+    };
+  } else {
+    return {
+      exists: state.exists,
+      archived: true
+    };
+  }
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    return {
+      TAG: "Error",
+      _0: "CategoryAlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "CategoryAdded",
+          categoryId: command.categoryId,
+          name: command.name
+        }]
+    };
+  }
+}
+
+let Spec;
+
+let initialState = {
+  exists: false,
+  archived: false
+};
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-catalog/src/Category/StateChangeSlice/AddCategory_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/src/Category/StateChangeSlice/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/src/Category/StateChangeSlice/ArchiveCategory.res.mjs

@@ -0,0 +1,49 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+
+let consumedEventSchema = S.union([
+  S.literal("CategoryAdded"),
+  S.literal("CategoryArchived")
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "ArchiveCategory",
+  categoryId: s.m(DcbTag$Reventless.string)
+}));
+
+let errorSchema = S.literal("CategoryNotFound");
+
+let eventSchema = S.schema(s => ({
+  TAG: "CategoryArchived",
+  categoryId: s.m(DcbTag$Reventless.string)
+}));
+
+function commandAuthorization(command) {
+  return {
+    TAG: "AllowGroups",
+    _0: ["Admin"]
+  };
+}
+
+let name = "ArchiveCategory";
+
+let Id;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-catalog/src/Category/StateChangeSlice/ArchiveCategory.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */

package/src/Category/StateChangeSlice/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})])
+    }
+  }