@reventlessdev/online-shop-dcb-ordering 1.0.0-alpha.103

package/lib/ocaml/RegisterCustomer.res

@@ -0,0 +1,22 @@
+// RegisterCustomer StateChangeSlice.
+// Handles the RegisterCustomer command; rejects duplicate registration.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | CustomerRegistered
+
+@schema
+type command =
+  | RegisterCustomer({customerId: string, email: string, address: string})
+
+@schema
+type error = CustomerAlreadyRegistered
+
+@schema
+type event =
+  | CustomerRegistered({
+      customerId: string,
+      email: string,
+      address: string,
+    })

package/lib/ocaml/RegisterCustomer_Behavior.res

@@ -0,0 +1,20 @@
+@@reventless.behavior
+
+type state = {exists: bool}
+
+let initialState = {exists: false}
+
+let evolve = (_state, event) =>
+  switch event {
+  | CustomerRegistered => {exists: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | RegisterCustomer({customerId, email, address}) =>
+    if state.exists {
+      Error(CustomerAlreadyRegistered)
+    } else {
+      Ok([CustomerRegistered({customerId, email, address})])
+    }
+  }

package/lib/ocaml/RegisterCustomer_GWT.res

@@ -0,0 +1,21 @@
+@@reventless.gwt
+
+describe("RegisterCustomer StateChangeSlice", () => {
+  test("empty event log produces CustomerRegistered", () =>
+    givenEvents([])
+    ->whenCmd(
+      RegisterCustomer({customerId: "c1", email: "alice@x.y", address: "123 Main"}),
+    )
+    ->thenEvent(
+      CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"}),
+    )
+  )
+
+  test("existing customer returns CustomerAlreadyRegistered", () =>
+    givenEvents([CustomerRegistered])
+    ->whenCmd(
+      RegisterCustomer({customerId: "c1", email: "bob@x.y", address: "456 Oak"}),
+    )
+    ->thenError(CustomerAlreadyRegistered)
+  )
+})

package/lib/ocaml/SendOrderConfirmation.res

@@ -0,0 +1,19 @@
+// SendOrderConfirmation OutboundTranslationSlice.
+// When OrderPlaced is emitted, sends a confirmation email via EmailService.
+// Fire-and-forget pattern (no inbound command).
+
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | OrderPlaced({orderId: string, customerId: string})
+
+@schema
+type outboundItem = {orderId: string, customerId: string}
+
+@schema
+type inboundCommand = unit
+
+let maxRetries = 3
+let heartbeatInterval = 60
+let targetName = None

package/lib/ocaml/SendOrderConfirmation_GWT.res

@@ -0,0 +1,33 @@
+// `OutboundTranslation_GWT.Make` expects a single SliceSpec with `collect` at
+// the top level. The split-form production layout keeps `collect` in the
+// translation body file, so we compose it onto the spec module locally.
+//
+// `translate` is supplied at test time via `whenTranslateMocked`; the real
+// `translate` (which calls `EmailService`) is exercised in component tests.
+
+module SendOrderConfirmationSlice = {
+  include SendOrderConfirmation
+  let collect = SendOrderConfirmation_Translation.collect
+}
+
+@@reventless.gwt
+
+describe("SendOrderConfirmation OutboundTranslationSlice", () => {
+  testSync("collect: OrderPlaced queues an outbound TODO", () =>
+    givenEvent(OrderPlaced({orderId: "o1", customerId: "c1"}))
+    ->whenCollect
+    ->thenTodos([("o1", {orderId: "o1", customerId: "c1"})])
+  )
+
+  test("translate success marks the TODO Completed", () =>
+    givenTodo("o1", {orderId: "o1", customerId: "c1"})
+    ->whenTranslateMocked((_id, _item) => Promise.resolve(Ok(None)))
+    ->thenTodoStatus("o1", #Completed)
+  )
+
+  test("translate failure leaves the TODO Pending for retry", () =>
+    givenTodo("o1", {orderId: "o1", customerId: "c1"})
+    ->whenTranslateMocked((_id, _item) => Promise.resolve(Error("smtp down")))
+    ->thenTodoStatus("o1", #Pending)
+  )
+})

package/lib/ocaml/SendOrderConfirmation_Translation.res

@@ -0,0 +1,24 @@
+@@reventless.translation
+
+let collect = event =>
+  switch event {
+  | OrderPlaced({orderId, customerId}) => [(orderId, {orderId, customerId})]
+  }
+
+let translate = async (_id, item) => {
+  try {
+    await EmailService.sendOrderConfirmation(
+      ~email=item.customerId,
+      ~orderId=item.orderId,
+    )
+    Ok(None)
+  } catch {
+  | exn =>
+    let msg =
+      exn
+      ->JsExn.fromException
+      ->Option.flatMap(JsExn.message)
+      ->Option.getOr("email send failed")
+    Error(msg)
+  }
+}

package/lib/ocaml/ShipOrder.res

@@ -0,0 +1,21 @@
+// ShipOrder StateChangeSlice.
+// Requires order to exist and not be cancelled; idempotent if already shipped.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | OrderPlaced
+  | OrderShipped
+  | OrderCancelled
+
+@schema
+type command =
+  | @allowedStates([Orders.Placed]) ShipOrder({orderId: string})
+
+@schema
+type error =
+  | OrderNotFound
+  | OrderAlreadyCancelled
+
+@schema
+type event = OrderShipped({orderId: string})

package/lib/ocaml/ShipOrder_Behavior.res

@@ -0,0 +1,26 @@
+@@reventless.behavior
+
+type state = {exists: bool, shipped: bool, cancelled: bool}
+
+let initialState = {exists: false, shipped: false, cancelled: false}
+
+let evolve = (state, event) =>
+  switch event {
+  | OrderPlaced => {exists: true, shipped: false, cancelled: false}
+  | OrderShipped => {...state, shipped: true}
+  | OrderCancelled => {...state, cancelled: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | ShipOrder({orderId: theId}) =>
+    if !state.exists {
+      Error(OrderNotFound)
+    } else if state.cancelled {
+      Error(OrderAlreadyCancelled)
+    } else if state.shipped {
+      Ok([]) // idempotent — already shipped
+    } else {
+      Ok([OrderShipped({orderId: theId})])
+    }
+  }

package/lib/ocaml/ShipOrder_GWT.res

@@ -0,0 +1,27 @@
+@@reventless.gwt
+
+describe("ShipOrder StateChangeSlice", () => {
+  test("non-existent order returns OrderNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ShipOrder({orderId: "o1"}))
+    ->thenError(OrderNotFound)
+  )
+
+  test("placed order produces OrderShipped", () =>
+    givenEvents([OrderPlaced])
+    ->whenCmd(ShipOrder({orderId: "o1"}))
+    ->thenEvent(OrderShipped({orderId: "o1"}))
+  )
+
+  test("already shipped order produces no events (idempotent)", () =>
+    givenEvents([OrderPlaced, OrderShipped])
+    ->whenCmd(ShipOrder({orderId: "o1"}))
+    ->thenNoEvent
+  )
+
+  test("cancelled order returns OrderAlreadyCancelled", () =>
+    givenEvents([OrderPlaced, OrderCancelled])
+    ->whenCmd(ShipOrder({orderId: "o1"}))
+    ->thenError(OrderAlreadyCancelled)
+  )
+})

package/lib/ocaml/SyncCatalogProduct.res

@@ -0,0 +1,28 @@
+// SyncCatalogProduct StateChangeSlice.
+// Maintains a local shadow of Catalog products inside the Ordering DCB event log.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | CatalogProductSynced({name: string, price: float})
+  | CatalogProductPriceChanged({price: float})
+
+@schema
+type command =
+  | SyncNewProduct({productId: string, name: string, price: float})
+  | ChangeSyncedPrice({productId: string, price: float})
+
+@schema
+type error = unit // always succeeds — sync is idempotent
+
+@schema
+type event =
+  | CatalogProductSynced({
+      productId: string,
+      name: string,
+      price: float,
+    })
+  | CatalogProductPriceChanged({
+      productId: string,
+      price: float,
+    })

package/lib/ocaml/SyncCatalogProduct_Behavior.res

@@ -0,0 +1,27 @@
+@@reventless.behavior
+
+type state = {name: string, price: float}
+let initialState = {name: "", price: 0.0}
+
+let evolve = (state, event) =>
+  switch event {
+  | CatalogProductSynced({name, price}) => {name, price}
+  | CatalogProductPriceChanged({price}) => {...state, price}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | SyncNewProduct({productId, name, price}) =>
+    // Idempotent: re-syncing identical data emits nothing (at-least-once delivery).
+    if state.name == name && state.price == price {
+      Ok([])
+    } else {
+      Ok([CatalogProductSynced({productId, name, price})])
+    }
+  | ChangeSyncedPrice({productId, price}) =>
+    if state.price == price {
+      Ok([])
+    } else {
+      Ok([CatalogProductPriceChanged({productId, price})])
+    }
+  }

package/lib/ocaml/SyncCatalogProduct_GWT.res

@@ -0,0 +1,27 @@
+@@reventless.gwt
+
+describe("SyncCatalogProduct StateChangeSlice", () => {
+  test("SyncNewProduct produces CatalogProductSynced", () =>
+    givenEvents([])
+    ->whenCmd(SyncNewProduct({productId: "p1", name: "Laptop", price: 999.99}))
+    ->thenEvent(CatalogProductSynced({productId: "p1", name: "Laptop", price: 999.99}))
+  )
+
+  test("ChangeSyncedPrice produces CatalogProductPriceChanged", () =>
+    givenEvents([CatalogProductSynced({name: "Laptop", price: 999.99})])
+    ->whenCmd(ChangeSyncedPrice({productId: "p1", price: 899.99}))
+    ->thenEvent(CatalogProductPriceChanged({productId: "p1", price: 899.99}))
+  )
+
+  test("re-syncing identical product data produces no events (idempotent)", () =>
+    givenEvents([CatalogProductSynced({name: "Laptop", price: 999.99})])
+    ->whenCmd(SyncNewProduct({productId: "p1", name: "Laptop", price: 999.99}))
+    ->thenNoEvent
+  )
+
+  test("re-applying the current price produces no events (idempotent)", () =>
+    givenEvents([CatalogProductSynced({name: "Laptop", price: 999.99})])
+    ->whenCmd(ChangeSyncedPrice({productId: "p1", price: 999.99}))
+    ->thenNoEvent
+  )
+})

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@reventlessdev/online-shop-dcb-ordering",
+  "version": "1.0.0-alpha.103",
+  "description": "Online Shop example — Ordering bounded context (Customer & Order) 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-ordering-spec": "1.0.0-alpha.58",
+    "@reventlessdev/online-shop-dcb-catalog-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-ordering",
+  "package-specs": {
+    "module": "esmodule",
+    "in-source": true
+  },
+  "namespace": "OrderingPlugin",
+  "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-ordering-spec",
+    "@reventlessdev/online-shop-dcb-catalog-spec"
+  ],
+  "compiler-flags": [],
+  "suffix": ".res.mjs"
+}

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct.res

@@ -0,0 +1,28 @@
+// SyncCatalogProduct StateChangeSlice.
+// Maintains a local shadow of Catalog products inside the Ordering DCB event log.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | CatalogProductSynced({name: string, price: float})
+  | CatalogProductPriceChanged({price: float})
+
+@schema
+type command =
+  | SyncNewProduct({productId: string, name: string, price: float})
+  | ChangeSyncedPrice({productId: string, price: float})
+
+@schema
+type error = unit // always succeeds — sync is idempotent
+
+@schema
+type event =
+  | CatalogProductSynced({
+      productId: string,
+      name: string,
+      price: float,
+    })
+  | CatalogProductPriceChanged({
+      productId: string,
+      price: float,
+    })

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct.res.mjs

@@ -0,0 +1,71 @@
+// 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.schema(s => ({
+    TAG: "CatalogProductSynced",
+    name: s.m(S.string),
+    price: s.m(S.float)
+  })),
+  S.schema(s => ({
+    TAG: "CatalogProductPriceChanged",
+    price: s.m(S.float)
+  }))
+]);
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "SyncNewProduct",
+    productId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string),
+    price: s.m(S.float)
+  })),
+  S.schema(s => ({
+    TAG: "ChangeSyncedPrice",
+    productId: s.m(DcbTag$Reventless.string),
+    price: s.m(S.float)
+  }))
+]);
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "CatalogProductSynced",
+    productId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string),
+    price: s.m(S.float)
+  })),
+  S.schema(s => ({
+    TAG: "CatalogProductPriceChanged",
+    productId: s.m(DcbTag$Reventless.string),
+    price: s.m(S.float)
+  }))
+]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "SyncCatalogProduct";
+
+let Id;
+
+let errorSchema = S.unit;
+
+let moduleUrl = "@reventlessdev/online-shop-dcb-ordering/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* consumedEventSchema Not a pure module */

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct_Behavior.res

@@ -0,0 +1,27 @@
+@@reventless.behavior
+
+type state = {name: string, price: float}
+let initialState = {name: "", price: 0.0}
+
+let evolve = (state, event) =>
+  switch event {
+  | CatalogProductSynced({name, price}) => {name, price}
+  | CatalogProductPriceChanged({price}) => {...state, price}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | SyncNewProduct({productId, name, price}) =>
+    // Idempotent: re-syncing identical data emits nothing (at-least-once delivery).
+    if state.name == name && state.price == price {
+      Ok([])
+    } else {
+      Ok([CatalogProductSynced({productId, name, price})])
+    }
+  | ChangeSyncedPrice({productId, price}) =>
+    if state.price == price {
+      Ok([])
+    } else {
+      Ok([CatalogProductPriceChanged({productId, price})])
+    }
+  }