@reventlessdev/online-shop-hybrid-ordering 1.0.0-alpha.210 → 1.0.0-alpha.211

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.211 (2026-08-16)
+
+### Features
+
+* **core:** let [@retired](https://github.com/retired) name a lifecycle state, not only a boolean ([6bb346b](https://github.com/ReventlessDev/reventless-core/commit/6bb346b4f6a5f33826fc24537953482a76067177))
+* **core:** mark the state that retires a row, and allow more than one ([cb1461f](https://github.com/ReventlessDev/reventless-core/commit/cb1461f024d3ca3b53fd9c8b010a054e3fcc4555))
+* **example:** give the hybrid shop's archive a way back ([524d374](https://github.com/ReventlessDev/reventless-core/commit/524d3748e455c70924b7861cbd4748744186de41))
+* **spec:** [@retired](https://github.com/retired) state-field annotation and its schema emission ([2d8234b](https://github.com/ReventlessDev/reventless-core/commit/2d8234b6b3dd8f479031a67eb5b4b47b5c0c2ff9))
+
+
 # 1.0.0-alpha.210 (2026-08-15)
 
 **Note:** Version bump only for package @reventlessdev/online-shop-hybrid-ordering

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/online-shop-hybrid-ordering",
-  "version": "1.0.0-alpha.210",
+  "version": "1.0.0-alpha.211",
   "description": "Online Shop Hybrid example — Ordering plugin (Customer aggregate + Order/CatalogProduct DCB)",
   "license": "Apache-2.0",
   "jest": {
@@ -21,18 +21,18 @@
   },
   "dependencies": {
     "sury": "^11.0.0-alpha.4",
-    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.110",
+    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.111",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/online-shop-hybrid-catalog-spec": "1.0.0-alpha.110",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.183",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.142",
-    "@reventlessdev/reventless-local": "3.0.0-alpha.224",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.114"
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.184",
+    "@reventlessdev/online-shop-hybrid-ordering-spec": "1.0.0-alpha.111",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.143",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.115",
+    "@reventlessdev/reventless-local": "3.0.0-alpha.225"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.66"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.67"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct.res

@@ -7,11 +7,19 @@
 type consumedEvent =
   | CatalogProductSynced({name: string, price: Reventless.Money.t})
   | CatalogProductPriceChanged({price: Reventless.Money.t})
+  | CatalogProductWithdrawn
+  | CatalogProductRelisted
 
 @schema
 type command =
   | SyncNewProduct({productId: string, name: string, price: Reventless.Money.t})
   | ChangeSyncedPrice({productId: string, price: Reventless.Money.t})
+  // The withdrawal and the way back. Both carry only the id: the shadow this
+  // slice maintains already holds the name and price, and it survives the read
+  // model's delete — which is what lets a relist restore availability from state
+  // Ordering owns rather than asking Catalog to re-send facts it already has.
+  | WithdrawSyncedProduct({productId: string})
+  | RelistSyncedProduct({productId: string})
 
 @schema
 type error = unit // always succeeds — sync is idempotent
@@ -27,3 +35,13 @@ type event =
       productId: string,
       price: Reventless.Money.t,
     })
+  | CatalogProductWithdrawn({productId: string})
+  // Carries the shadow's name and price so the projection can restore the row
+  // without a second read: the fold has them in hand at exactly the moment the
+  // decision is made, and an event that states what it caused is what makes the
+  // projection a pure mapping.
+  | CatalogProductRelisted({
+      productId: string,
+      name: string,
+      price: Reventless.Money.t,
+    })

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

@@ -13,7 +13,9 @@ let consumedEventSchema = S.union([
   S.schema(s => ({
     TAG: "CatalogProductPriceChanged",
     price: s.m(Money$Reventless.schema)
-  }))
+  })),
+  S.literal("CatalogProductWithdrawn"),
+  S.literal("CatalogProductRelisted")
 ]);
 
 let commandSchema = S.union([
@@ -27,6 +29,14 @@ let commandSchema = S.union([
     TAG: "ChangeSyncedPrice",
     productId: s.m(DcbTag$Reventless.string),
     price: s.m(Money$Reventless.schema)
+  })),
+  S.schema(s => ({
+    TAG: "WithdrawSyncedProduct",
+    productId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "RelistSyncedProduct",
+    productId: s.m(DcbTag$Reventless.string)
   }))
 ]);
 
@@ -41,6 +51,16 @@ let eventSchema = S.union([
     TAG: "CatalogProductPriceChanged",
     productId: s.m(DcbTag$Reventless.string),
     price: s.m(Money$Reventless.schema)
+  })),
+  S.schema(s => ({
+    TAG: "CatalogProductWithdrawn",
+    productId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "CatalogProductRelisted",
+    productId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string),
+    price: s.m(Money$Reventless.schema)
   }))
 ]);
 

package/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct_Behavior.res

@@ -2,20 +2,26 @@
 
 // No price until one has been synced — see ChangeProductPrice_Behavior for why
 // a money field's "empty" is an absence rather than a zero.
-type state = {name: string, price: option<Reventless.Money.t>}
-let initialState = {name: "", price: None}
+//
+// `withdrawn` sits beside the shadow rather than replacing it: a withdrawn
+// product's name and price are exactly what a relist needs, and dropping them
+// here would force Catalog to re-send facts Ordering already holds.
+type state = {name: string, price: option<Reventless.Money.t>, withdrawn: bool}
+let initialState = {name: "", price: None, withdrawn: false}
 
 let evolve = (state, event) =>
   switch event {
-  | CatalogProductSynced({name, price}) => {name, price: Some(price)}
+  | CatalogProductSynced({name, price}) => {name, price: Some(price), withdrawn: false}
   | CatalogProductPriceChanged({price}) => {...state, price: Some(price)}
+  | CatalogProductWithdrawn => {...state, withdrawn: true}
+  | CatalogProductRelisted => {...state, withdrawn: false}
   }
 
 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 == Some(price) {
+    if state.name == name && state.price == Some(price) && !state.withdrawn {
       Ok([])
     } else {
       Ok([CatalogProductSynced({productId, name, price})])
@@ -26,4 +32,20 @@ let decide = (state, command) =>
     } else {
       Ok([CatalogProductPriceChanged({productId, price})])
     }
+  | WithdrawSyncedProduct({productId: theId}) =>
+    if state.withdrawn {
+      Ok([])
+    } else {
+      Ok([CatalogProductWithdrawn({productId: theId})])
+    }
+  | RelistSyncedProduct({productId: theId}) =>
+    switch (state.withdrawn, state.price) {
+    | (false, _) => Ok([]) // idempotent — already orderable
+    // A relist of a product never synced has nothing to restore. Emitting an
+    // event with an invented name and a zero price would put a row in the
+    // shopper's catalog that no Catalog product backs.
+    | (true, None) => Ok([])
+    | (true, Some(price)) =>
+      Ok([CatalogProductRelisted({productId: theId, name: state.name, price})])
+    }
   }

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

@@ -3,63 +3,123 @@
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 
 function evolve(state, event) {
-  if (event.TAG === "CatalogProductSynced") {
-    return {
-      name: event.name,
-      price: event.price
-    };
-  } else {
-    return {
-      name: state.name,
-      price: event.price
-    };
-  }
-}
-
-function decide(state, command) {
-  if (command.TAG === "SyncNewProduct") {
-    let price = command.price;
-    let name = command.name;
-    if (state.name === name && Primitive_object.equal(state.price, price)) {
+  if (typeof event !== "object") {
+    if (event === "CatalogProductWithdrawn") {
       return {
-        TAG: "Ok",
-        _0: []
+        name: state.name,
+        price: state.price,
+        withdrawn: true
       };
     } else {
       return {
-        TAG: "Ok",
-        _0: [{
-            TAG: "CatalogProductSynced",
-            productId: command.productId,
-            name: name,
-            price: price
-          }]
+        name: state.name,
+        price: state.price,
+        withdrawn: false
       };
     }
-  }
-  let price$1 = command.price;
-  if (Primitive_object.equal(state.price, price$1)) {
+  } else if (event.TAG === "CatalogProductSynced") {
     return {
-      TAG: "Ok",
-      _0: []
+      name: event.name,
+      price: event.price,
+      withdrawn: false
     };
   } else {
     return {
-      TAG: "Ok",
-      _0: [{
-          TAG: "CatalogProductPriceChanged",
-          productId: command.productId,
-          price: price$1
-        }]
+      name: state.name,
+      price: event.price,
+      withdrawn: state.withdrawn
     };
   }
 }
 
+function decide(state, command) {
+  switch (command.TAG) {
+    case "SyncNewProduct" :
+      let price = command.price;
+      let name = command.name;
+      if (state.name === name && Primitive_object.equal(state.price, price) && !state.withdrawn) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "CatalogProductSynced",
+              productId: command.productId,
+              name: name,
+              price: price
+            }]
+        };
+      }
+    case "ChangeSyncedPrice" :
+      let price$1 = command.price;
+      if (Primitive_object.equal(state.price, price$1)) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "CatalogProductPriceChanged",
+              productId: command.productId,
+              price: price$1
+            }]
+        };
+      }
+    case "WithdrawSyncedProduct" :
+      if (state.withdrawn) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "CatalogProductWithdrawn",
+              productId: command.productId
+            }]
+        };
+      }
+    case "RelistSyncedProduct" :
+      let match = state.withdrawn;
+      let match$1 = state.price;
+      if (match) {
+        if (match$1 !== undefined) {
+          return {
+            TAG: "Ok",
+            _0: [{
+                TAG: "CatalogProductRelisted",
+                productId: command.productId,
+                name: state.name,
+                price: match$1
+              }]
+          };
+        } else {
+          return {
+            TAG: "Ok",
+            _0: []
+          };
+        }
+      } else {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+  }
+}
+
 let Spec;
 
 let initialState = {
   name: "",
-  price: undefined
+  price: undefined,
+  withdrawn: false
 };
 
 let moduleUrl = "@reventlessdev/online-shop-hybrid-ordering/src/CatalogProduct/StateChangeSlice/SyncCatalogProduct_Behavior.res.mjs";

package/src/CatalogProduct/StateViewSliceStream/AvailableProducts.res

@@ -10,6 +10,8 @@
 type consumedEvent =
   | CatalogProductSynced({productId: string, name: string, price: Reventless.Money.t})
   | CatalogProductPriceChanged({productId: string, price: Reventless.Money.t})
+  | CatalogProductWithdrawn({productId: string})
+  | CatalogProductRelisted({productId: string, name: string, price: Reventless.Money.t})
 
 @schema
 type state = {productId: string, name: string, price: Reventless.Money.t}

package/src/CatalogProduct/StateViewSliceStream/AvailableProducts.res.mjs

@@ -16,6 +16,16 @@ let consumedEventSchema = S.union([
     TAG: "CatalogProductPriceChanged",
     productId: s.m(S.string),
     price: s.m(Money$Reventless.schema)
+  })),
+  S.schema(s => ({
+    TAG: "CatalogProductWithdrawn",
+    productId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "CatalogProductRelisted",
+    productId: s.m(S.string),
+    name: s.m(S.string),
+    price: s.m(Money$Reventless.schema)
   }))
 ]);
 
@@ -42,10 +52,11 @@ let stateSchema$1 = S.Metadata.set(stateSchema, StateAnnotations$Reventless.stat
   scanSort: [],
   semantic: [],
   metric: [],
-  status: undefined,
+  lifecycle: undefined,
   groupBy: undefined,
   visibility: "Internal",
-  live: undefined
+  live: undefined,
+  retired: undefined
 });
 
 let name = "AvailableProducts";

package/src/CatalogProduct/StateViewSliceStream/AvailableProducts_Projection.res

@@ -5,4 +5,15 @@ let project = ({event}) =>
   | CatalogProductSynced({productId, name, price}) => [Set(productId, {productId, name, price})]
   | CatalogProductPriceChanged({productId, price}) =>
     [Update(productId, p => {...p, price})]
+  // `Delete`, not a flag. This view answers "what can I order", so a withdrawn
+  // product leaves it. Marking it instead — `@retired` on the shopper view —
+  // would look tidy and be wrong twice over: a shopper is not elevated, so the
+  // narrowing would hide it correctly, but an operator IS, and would find
+  // discontinued stock in the shopper's catalog. It would also make Ordering
+  // restate a lifecycle Catalog owns.
+  | CatalogProductWithdrawn({productId}) => [Delete(productId)]
+  // Set again, from the relist event's own payload — which the aggregate filled
+  // from the shadow it kept through the withdrawal. Catalog is never asked to
+  // re-send what Ordering already has.
+  | CatalogProductRelisted({productId, name, price}) => [Set(productId, {productId, name, price})]
   }

package/src/CatalogProduct/StateViewSliceStream/AvailableProducts_Projection.res.mjs

@@ -3,27 +3,36 @@
 
 function project(param) {
   let event = param.event;
-  if (event.TAG === "CatalogProductSynced") {
-    let productId = event.productId;
-    return [{
-        TAG: "Set",
-        _0: productId,
-        _1: {
-          productId: productId,
-          name: event.name,
-          price: event.price
-        }
-      }];
+  switch (event.TAG) {
+    case "CatalogProductPriceChanged" :
+      let price = event.price;
+      return [{
+          TAG: "Update",
+          _0: event.productId,
+          _1: p => ({
+            productId: p.productId,
+            name: p.name,
+            price: price
+          })
+        }];
+    case "CatalogProductWithdrawn" :
+      return [{
+          TAG: "Delete",
+          _0: event.productId
+        }];
+    case "CatalogProductSynced" :
+    case "CatalogProductRelisted" :
+      break;
   }
-  let price = event.price;
+  let productId = event.productId;
   return [{
-      TAG: "Update",
-      _0: event.productId,
-      _1: p => ({
-        productId: p.productId,
-        name: p.name,
-        price: price
-      })
+      TAG: "Set",
+      _0: productId,
+      _1: {
+        productId: productId,
+        name: event.name,
+        price: event.price
+      }
     }];
 }
 

package/src/Customer/Aggregate/Customer.res

@@ -37,7 +37,19 @@ type command =
   // address that has since changed is dropped rather than applied.
   | @noApi SetLocation({location: Reventless.GeoPoint.t, resolvedFrom: string})
   | @noApi MarkAddressUnresolvable({address: string, reason: string})
-  | Deactivate
+  | @allowedStates([Customers.Active]) Deactivate
+  // The way back. Deactivation withdraws a customer from ordinary use; it does
+  // not erase them, so restoring one needs no payload — the profile is still in
+  // the state, and asking a caller to re-supply an email they never changed
+  // would be a second chance to get it wrong.
+  //
+  // `@allowedStates([Deactivated])` is the whole of "offer this on a deactivated
+  // customer and nowhere else". It works because the view's retirement IS a state
+  // of its lifecycle rather than a boolean beside one, so the states a command
+  // names and the states a row can be in are the same vocabulary. The refusal
+  // still lives in `decide`; this only stops a menu offering what the write side
+  // would reject.
+  | @allowedStates([Customers.Deactivated]) Reactivate
 
 @schema
 type event =
@@ -60,6 +72,7 @@ type event =
   // two things is one nobody can act on.
   | AddressUnresolvable({address: string, reason: string})
   | Deactivated
+  | Reactivated
 
 @schema
 type error =

package/src/Customer/Aggregate/Customer.res.mjs

@@ -33,7 +33,8 @@ let commandSchema = S.union([
     address: s.m(S.string),
     reason: s.m(S.string)
   })),
-  S.literal("Deactivate")
+  S.literal("Deactivate"),
+  S.literal("Reactivate")
 ]);
 
 let eventSchema = S.union([
@@ -65,7 +66,8 @@ let eventSchema = S.union([
     address: s.m(S.string),
     reason: s.m(S.string)
   })),
-  S.literal("Deactivated")
+  S.literal("Deactivated"),
+  S.literal("Reactivated")
 ]);
 
 let errorSchema = S.union([
@@ -79,6 +81,17 @@ let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, [
   "MarkAddressUnresolvable"
 ]);
 
+let commandSchema$2 = Api$ReventlessInfra.markAllowedStates(commandSchema$1, [
+  [
+    "Deactivate",
+    ["Active"]
+  ],
+  [
+    "Reactivate",
+    ["Deactivated"]
+  ]
+]);
+
 function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
@@ -94,7 +107,7 @@ export {
   Id,
   eventSchema,
   errorSchema,
-  commandSchema$1 as commandSchema,
+  commandSchema$2 as commandSchema,
   moduleUrl,
   commandAuthorization,
 }

package/src/Customer/Aggregate/Customer_Behavior.res

@@ -20,7 +20,17 @@ type state =
       location: option<Reventless.GeoPoint.t>,
       locationResolvedFrom: option<string>,
     })
-  | Deactivated
+  // Carries the profile it was holding when it was withdrawn. Deactivation is
+  // not deletion — the orders still name this customer — so the state that comes
+  // back on reactivation has to be the state that went in. A payloadless
+  // `Deactivated` would make `Reactivate` either impossible or a second
+  // registration, and a second registration is a different fact.
+  | Deactivated({
+      email: string,
+      address: string,
+      location: option<Reventless.GeoPoint.t>,
+      locationResolvedFrom: option<string>,
+    })
 
 let initialState = NotCreated
 
@@ -44,8 +54,12 @@ let evolve = (state, event) =>
   // handing it back for another round.
   | (Active(s), AddressUnresolvable({address})) =>
     Active({...s, location: None, locationResolvedFrom: Some(address)})
-  | (Active(_), Customer.Deactivated) => Deactivated
-  | (Deactivated, _) => state
+  | (Active({email, address, location, locationResolvedFrom}), Customer.Deactivated) =>
+    Deactivated({email, address, location, locationResolvedFrom})
+  | (Deactivated({email, address, location, locationResolvedFrom}), Reactivated) =>
+    Active({email, address, location, locationResolvedFrom})
+  | (Deactivated(_), _) => state
+  | (Active(_), Reactivated) => state
   | (NotCreated, _) => state
   }
 
@@ -58,6 +72,7 @@ let decide = (state, command) =>
   | (NotCreated, SetLocation(_)) => Error(CustomerNotFound)
   | (NotCreated, MarkAddressUnresolvable(_)) => Error(CustomerNotFound)
   | (NotCreated, Deactivate) => Error(CustomerNotFound)
+  | (NotCreated, Reactivate) => Error(CustomerNotFound)
 
   | (Active(_), Register(_)) => Error(CustomerAlreadyRegistered)
   | (Active(s), UpdateEmail({email})) if email == s.email => Ok([])
@@ -94,15 +109,19 @@ let decide = (state, command) =>
     Ok([AddressUnresolvable({address, reason})])
 
   | (Active(_), Deactivate) => Ok([Customer.Deactivated])
+  // Already where the caller is asking it to be.
+  | (Active(_), Reactivate) => Ok([])
 
-  | (Deactivated, Register(_)) => Error(CustomerAlreadyDeactivated)
-  | (Deactivated, UpdateEmail(_)) => Error(CustomerAlreadyDeactivated)
-  | (Deactivated, UpdateAddress(_)) => Error(CustomerAlreadyDeactivated)
-  | (Deactivated, SetAddressLocation(_)) => Error(CustomerAlreadyDeactivated)
+  | (Deactivated(_), Register(_)) => Error(CustomerAlreadyDeactivated)
+  | (Deactivated(_), UpdateEmail(_)) => Error(CustomerAlreadyDeactivated)
+  | (Deactivated(_), UpdateAddress(_)) => Error(CustomerAlreadyDeactivated)
+  | (Deactivated(_), SetAddressLocation(_)) => Error(CustomerAlreadyDeactivated)
   // A deactivated customer has no location work owing — swallow rather than
   // error, so an in-flight geocode landing after deactivation does not park a
   // TODO row in Failed forever.
-  | (Deactivated, SetLocation(_)) => Ok([])
-  | (Deactivated, MarkAddressUnresolvable(_)) => Ok([])
-  | (Deactivated, Deactivate) => Ok([]) // idempotent
+  | (Deactivated(_), SetLocation(_)) => Ok([])
+  | (Deactivated(_), MarkAddressUnresolvable(_)) => Ok([])
+  | (Deactivated(_), Deactivate) => Ok([]) // idempotent
+  // The one command this state exists to accept.
+  | (Deactivated(_), Reactivate) => Ok([Reactivated])
   }