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

package/lib/ocaml/AutoShipOrder_Automation.res

@@ -0,0 +1,36 @@
+@@reventless.automation
+
+// Single DCB source — events from the ordering plugin's own event log.
+// `module Id = Reventless.Id.String` and dcbTags on `*Id` fields are
+// auto-injected by `@@reventless.automation` (Source-module scan).
+module OrderingDcbSource = {
+  let name = "OrderingDcbEventLog"
+  @schema
+  type event =
+    | OrderPlaced({orderId: string})
+    | OrderShipped({orderId: string})
+}
+
+module FromOrderingDcb = Mapping.Make(
+  OrderingDcbSource,
+  AutoShipOrder,
+  {
+    open OrderingDcbSource
+
+    let collect = (event, _ctx) =>
+      switch event {
+      | OrderPlaced({orderId}) => [(orderId, ({orderId: orderId}: AutoShipOrder.todoItem))]
+      | OrderShipped(_) => []
+      }
+
+    let resolve = event =>
+      switch event {
+      | OrderShipped({orderId}) => Some(orderId)
+      | OrderPlaced(_) => None
+      }
+  },
+)
+
+let mappings: array<module(Mapping)> = [module(FromOrderingDcb)]
+
+let process = (id, _item) => Some((id, ShipOrder({orderId: id})))

package/lib/ocaml/AutoShipOrder_GWT.res

@@ -0,0 +1,55 @@
+// `Automation_GWT.Make` expects a single SliceSpec with `collect`, `resolve`
+// and `process` as top-level bindings. The split-form production layout puts
+// `collect`/`resolve` inside the per-source `FromOrderingDcb` mapping, so we
+// compose the pieces locally before handing the result to the DSL.
+
+let testContext: Reventless.AutomationSlice.context = {
+  environment: "test",
+  platformName: "test",
+  pluginName: "ordering",
+  sliceName: "AutoShipOrder",
+}
+
+module AutoShipOrderSlice = {
+  include AutoShipOrder
+  type consumedEvent = AutoShipOrder_Automation.FromOrderingDcb.sourceEvent
+  let consumedEventSchema = AutoShipOrder_Automation.FromOrderingDcb.sourceEventSchema
+
+  let collect = e => AutoShipOrder_Automation.FromOrderingDcb.collect(e, testContext)
+  let resolve = AutoShipOrder_Automation.FromOrderingDcb.resolve
+  let process = AutoShipOrder_Automation.process
+}
+
+@@reventless.gwt
+
+describe("AutoShipOrder AutomationSlice", () => {
+  test("collect: OrderPlaced creates a pending TODO", () =>
+    givenEvent(OrderPlaced({orderId: "o1"}))
+    ->whenCollect
+    ->thenTodos([("o1", {orderId: "o1"})])
+  )
+
+  test("collect: OrderShipped is ignored (no TODO)", () =>
+    givenEvent(OrderShipped({orderId: "o1"}))
+    ->whenCollect
+    ->thenTodos([])
+  )
+
+  test("resolve: OrderShipped marks the TODO done", () =>
+    givenEvent(OrderShipped({orderId: "o1"}))
+    ->whenResolve
+    ->thenResolved(Some("o1"))
+  )
+
+  test("resolve: OrderPlaced does not mark anything done", () =>
+    givenEvent(OrderPlaced({orderId: "o1"}))
+    ->whenResolve
+    ->thenResolved(None)
+  )
+
+  test("process: pending TODO emits ShipOrder for the same id", () =>
+    givenTodo("o1", {orderId: "o1"})
+    ->whenProcess
+    ->thenCommand("o1", ShipOrder({orderId: "o1"}))
+  )
+})

package/lib/ocaml/AvailableProducts.res

@@ -0,0 +1,13 @@
+// AvailableProducts StateViewSlice.
+// Projects synced catalog product events into a queryable "available products" read model.
+// This view exists to support Order placement and isn't shown in AutoUI panels.
+@@reventless.spec
+@@reventless.visibility(Internal)
+
+@schema
+type state = {productId: string, name: string, price: float}
+
+@schema
+type consumedEvent =
+  | CatalogProductSynced({productId: string, name: string, price: float})
+  | CatalogProductPriceChanged({productId: string, price: float})

package/lib/ocaml/AvailableProducts_GWT.res

@@ -0,0 +1,15 @@
+@@reventless.gwt
+
+describe("AvailableProducts StateViewSlice", () => {
+  test("CatalogProductSynced creates a row", () =>
+    givenEvents([])
+    ->whenEvent(CatalogProductSynced({productId: "p1", name: "Laptop", price: 999.99}))
+    ->thenStateWithId("p1", {productId: "p1", name: "Laptop", price: 999.99})
+  )
+
+  test("CatalogProductPriceChanged updates the price", () =>
+    givenEvents([CatalogProductSynced({productId: "p1", name: "Laptop", price: 999.99})])
+    ->whenEvent(CatalogProductPriceChanged({productId: "p1", price: 899.99}))
+    ->thenStateWithId("p1", {productId: "p1", name: "Laptop", price: 899.99})
+  )
+})

package/lib/ocaml/AvailableProducts_Projection.res

@@ -0,0 +1,8 @@
+@@reventless.projection
+
+let project = event =>
+  switch event {
+  | CatalogProductSynced({productId, name, price}) => [Set(productId, {productId, name, price})]
+  | CatalogProductPriceChanged({productId, price}) =>
+    [Update(productId, p => {...p, price})]
+  }

package/lib/ocaml/CancelOrder.res

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

package/lib/ocaml/CancelOrder_Behavior.res

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

package/lib/ocaml/CancelOrder_GWT.res

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

package/lib/ocaml/ChangeAddress.res

@@ -0,0 +1,20 @@
+// ChangeAddress StateChangeSlice.
+// Requires customer to exist and not be deactivated; idempotent when address is unchanged.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | CustomerRegistered({address: string})
+  | AddressChanged({address: string})
+  | CustomerDeactivated
+
+@schema
+type command = ChangeAddress({customerId: string, address: string})
+
+@schema
+type error =
+  | CustomerNotFound
+  | CustomerAlreadyDeactivated
+
+@schema
+type event = AddressChanged({customerId: string, address: string})

package/lib/ocaml/ChangeAddress_Behavior.res

@@ -0,0 +1,30 @@
+@@reventless.behavior
+
+type state = {exists: bool, deactivated: bool, currentAddress: string}
+
+let initialState = {exists: false, deactivated: false, currentAddress: ""}
+
+let evolve = (state, event) =>
+  switch event {
+  | CustomerRegistered({address}) => {
+      exists: true,
+      deactivated: false,
+      currentAddress: address,
+    }
+  | AddressChanged({address}) => {...state, currentAddress: address}
+  | CustomerDeactivated => {...state, deactivated: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | ChangeAddress({customerId, address}) =>
+    if !state.exists {
+      Error(CustomerNotFound)
+    } else if state.deactivated {
+      Error(CustomerAlreadyDeactivated)
+    } else if address == state.currentAddress {
+      Ok([]) // idempotent — address unchanged
+    } else {
+      Ok([AddressChanged({customerId, address})])
+    }
+  }

package/lib/ocaml/ChangeAddress_GWT.res

@@ -0,0 +1,27 @@
+@@reventless.gwt
+
+describe("ChangeAddress StateChangeSlice", () => {
+  test("non-existent customer returns CustomerNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ChangeAddress({customerId: "c1", address: "789 Pine"}))
+    ->thenError(CustomerNotFound)
+  )
+
+  test("active customer produces AddressChanged", () =>
+    givenEvents([CustomerRegistered({address: "123 Main"})])
+    ->whenCmd(ChangeAddress({customerId: "c1", address: "789 Pine"}))
+    ->thenEvent(AddressChanged({customerId: "c1", address: "789 Pine"}))
+  )
+
+  test("same address produces no events (idempotent)", () =>
+    givenEvents([CustomerRegistered({address: "123 Main"})])
+    ->whenCmd(ChangeAddress({customerId: "c1", address: "123 Main"}))
+    ->thenNoEvent
+  )
+
+  test("deactivated customer returns CustomerAlreadyDeactivated", () =>
+    givenEvents([CustomerRegistered({address: "123 Main"}), CustomerDeactivated])
+    ->whenCmd(ChangeAddress({customerId: "c1", address: "789 Pine"}))
+    ->thenError(CustomerAlreadyDeactivated)
+  )
+})

package/lib/ocaml/ChangeEmail.res

@@ -0,0 +1,20 @@
+// ChangeEmail StateChangeSlice.
+// Requires customer to exist and not be deactivated; idempotent when email is unchanged.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | CustomerRegistered({email: string})
+  | EmailChanged({email: string})
+  | CustomerDeactivated
+
+@schema
+type command = ChangeEmail({customerId: string, email: string})
+
+@schema
+type error =
+  | CustomerNotFound
+  | CustomerAlreadyDeactivated
+
+@schema
+type event = EmailChanged({customerId: string, email: string})

package/lib/ocaml/ChangeEmail_Behavior.res

@@ -0,0 +1,26 @@
+@@reventless.behavior
+
+type state = {exists: bool, deactivated: bool, currentEmail: string}
+
+let initialState = {exists: false, deactivated: false, currentEmail: ""}
+
+let evolve = (state, event) =>
+  switch event {
+  | CustomerRegistered({email}) => {exists: true, deactivated: false, currentEmail: email}
+  | EmailChanged({email}) => {...state, currentEmail: email}
+  | CustomerDeactivated => {...state, deactivated: true}
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | ChangeEmail({customerId, email}) =>
+    if !state.exists {
+      Error(CustomerNotFound)
+    } else if state.deactivated {
+      Error(CustomerAlreadyDeactivated)
+    } else if email == state.currentEmail {
+      Ok([]) // idempotent — email unchanged
+    } else {
+      Ok([EmailChanged({customerId, email})])
+    }
+  }

package/lib/ocaml/ChangeEmail_GWT.res

@@ -0,0 +1,27 @@
+@@reventless.gwt
+
+describe("ChangeEmail StateChangeSlice", () => {
+  test("non-existent customer returns CustomerNotFound", () =>
+    givenEvents([])
+    ->whenCmd(ChangeEmail({customerId: "c1", email: "alice2@x.y"}))
+    ->thenError(CustomerNotFound)
+  )
+
+  test("active customer produces EmailChanged", () =>
+    givenEvents([CustomerRegistered({email: "alice@x.y"})])
+    ->whenCmd(ChangeEmail({customerId: "c1", email: "alice2@x.y"}))
+    ->thenEvent(EmailChanged({customerId: "c1", email: "alice2@x.y"}))
+  )
+
+  test("same email produces no events (idempotent)", () =>
+    givenEvents([CustomerRegistered({email: "alice@x.y"})])
+    ->whenCmd(ChangeEmail({customerId: "c1", email: "alice@x.y"}))
+    ->thenNoEvent
+  )
+
+  test("deactivated customer returns CustomerAlreadyDeactivated", () =>
+    givenEvents([CustomerRegistered({email: "alice@x.y"}), CustomerDeactivated])
+    ->whenCmd(ChangeEmail({customerId: "c1", email: "alice2@x.y"}))
+    ->thenError(CustomerAlreadyDeactivated)
+  )
+})

package/lib/ocaml/Customers.res

@@ -0,0 +1,18 @@
+// Customers StateViewSlice.
+// Projects customer events from the shared ordering event log into a Customers read model.
+@@reventless.spec
+
+@schema
+type state = {
+  customerId: string,
+  @displayName email: string,
+  address: string,
+  deactivated: bool,
+}
+
+@schema
+type consumedEvent =
+  | CustomerRegistered({customerId: string, email: string, address: string})
+  | EmailChanged({customerId: string, email: string})
+  | AddressChanged({customerId: string, address: string})
+  | CustomerDeactivated({customerId: string})

package/lib/ocaml/Customers_GWT.res

@@ -0,0 +1,45 @@
+@@reventless.gwt
+
+describe("Customers StateViewSlice", () => {
+  test("CustomerRegistered creates a row", () =>
+    givenEvents([])
+    ->whenEvent(CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"}))
+    ->thenStateWithId(
+      "c1",
+      {customerId: "c1", email: "alice@x.y", address: "123 Main", deactivated: false},
+    )
+  )
+
+  test("EmailChanged updates the email", () =>
+    givenEvents([
+      CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"}),
+    ])
+    ->whenEvent(EmailChanged({customerId: "c1", email: "alice2@x.y"}))
+    ->thenStateWithId(
+      "c1",
+      {customerId: "c1", email: "alice2@x.y", address: "123 Main", deactivated: false},
+    )
+  )
+
+  test("AddressChanged updates the address", () =>
+    givenEvents([
+      CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"}),
+    ])
+    ->whenEvent(AddressChanged({customerId: "c1", address: "789 Pine"}))
+    ->thenStateWithId(
+      "c1",
+      {customerId: "c1", email: "alice@x.y", address: "789 Pine", deactivated: false},
+    )
+  )
+
+  test("CustomerDeactivated sets deactivated flag", () =>
+    givenEvents([
+      CustomerRegistered({customerId: "c1", email: "alice@x.y", address: "123 Main"}),
+    ])
+    ->whenEvent(CustomerDeactivated({customerId: "c1"}))
+    ->thenStateWithId(
+      "c1",
+      {customerId: "c1", email: "alice@x.y", address: "123 Main", deactivated: true},
+    )
+  )
+})

package/lib/ocaml/Customers_Projection.res

@@ -0,0 +1,13 @@
+@@reventless.projection
+
+let project = event =>
+  switch event {
+  | CustomerRegistered({customerId, email, address}) => [
+      Set(customerId, {customerId, email, address, deactivated: false}),
+    ]
+  | EmailChanged({customerId, email}) => [Update(customerId, state => {...state, email})]
+  | AddressChanged({customerId, address}) => [Update(customerId, state => {...state, address})]
+  | CustomerDeactivated({customerId}) => [
+      Update(customerId, state => {...state, deactivated: true}),
+    ]
+  }

package/lib/ocaml/DeactivateCustomer.res

@@ -0,0 +1,17 @@
+// DeactivateCustomer StateChangeSlice.
+// Requires customer to exist; idempotent if already deactivated.
+@@reventless.spec
+
+@schema
+type consumedEvent =
+  | CustomerRegistered
+  | CustomerDeactivated
+
+@schema
+type command = DeactivateCustomer({customerId: string})
+
+@schema
+type error = CustomerNotFound
+
+@schema
+type event = CustomerDeactivated({customerId: string})