@reventlessdev/reventless-spec 3.0.0-alpha.159 → 3.0.0-alpha.161

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.161 (2026-10-10)
+
+### Bug Fixes
+
+* an inbound translation is gated alike on every door, and encodes its commands by schema ([6ec3ce6](https://github.com/ReventlessDev/reventless-core/commit/6ec3ce672e53e2c162c64a90d103be691391be5e))
+### Features
+
+* **gwt:** automation and translation tests take the slice as written, and the sidecars read them ([93a0919](https://github.com/ReventlessDev/reventless-core/commit/93a0919a0d66730cf9bf89144ad8fba3cb025332))
+
+
+# 3.0.0-alpha.160 (2026-10-08)
+
+**Note:** Version bump only for package @reventlessdev/reventless-spec
+
+
+
+
+
 # 3.0.0-alpha.159 (2026-10-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.159",
+  "version": "3.0.0-alpha.161",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -26,7 +26,7 @@
     "sury": "11.0.0",
     "sury-ppx": "11.0.0",
     "yaml": "^2.8.3",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.21"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.22"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/components/InboundTranslationSlice.res

@@ -1,38 +1,10 @@
 /**
-Module types for a DCB inbound translation slice.
+Module types for a DCB inbound translation slice: external input (a webhook, an
+API call) translated into domain commands by an anti-corruption layer, triggered
+through `operations.receive` rather than by events.
 
-An `InboundTranslationSlice` receives external input (webhooks, API calls) and
-translates it into domain commands via an anti-corruption layer.
-
-Unlike outbound slices, inbound slices are triggered externally via
-`operations.receive` rather than by subscribing to domain events.
-
-```
-External Input -> Anti-Corruption Layer (translate) -> Command
-```
-
-Plan 02 splits the merged spec into two module types:
-
-- `Spec` — types, identity, schemas, target name. (No state — translation is
-  a pure function of external input.)
-- `Translation` — the single `translate` function.
-
-@example
-```rescript
-// PaymentWebhook.res
-let name = "PaymentWebhook"
-
-@schema type externalInput = {paymentId: string, orderId: string, status: string}
-@schema type command = ConfirmPayment({orderId: @s.matches(DcbTag.string) string, paymentId: string})
-
-let translate = input => switch input.status {
-  | "completed" => Ok([(input.orderId, ConfirmPayment({orderId: input.orderId, paymentId: input.paymentId}))])
-  | _ => Error("Unknown payment status: " ++ input.status)
-}
-```
-*/
-/**
-The lean Spec for an InboundTranslationSlice — types, identity, schemas.
+`Spec` holds the types, schemas and target; `Translation` the `translate` function.
+The slice moves no lifecycle of its own — its target owns that.
 */
 module type Spec = {
   /** Logical name of this inbound translation slice (used as a component prefix). */
@@ -50,49 +22,25 @@ module type Spec = {
   /** Name of the aggregate or StateChangeSlice that receives the produced command. */
   let targetName: string
 
-  /** Optional display name of the foreign system this anti-corruption slice receives
-      from (e.g. `"SupplierFeed"`). Drives the **external box** drawn outside the plugin
-      in the Event Graph / Context Map.
-      Auto-injected by `@@reventless.spec` defaulting to `None` — set it to name the box. */
+  /** The foreign system this slice receives from (e.g. `"SupplierFeed"`), drawn as a
+      box outside the plugin. Injected as `None` by `@@reventless.spec`. */
   let externalSystem: option<string>
 
   /** The roles this spec's rules name: its plugin's `Roles.t`, which the PPX
       supplies; `Role.name` where the plugin declares none. */
   type role
-  /** Authorization rule evaluated at the GraphQL resolver entry before any
-      external input is translated. Auto-injected by `@@reventless.spec` and
-      on structurally-detected inline spec modules — defaults to
-      `AllowAuthenticated`. */
+  /** Each command's rule. The door admits a caller satisfying any command's
+      rule; each command the input translates into is then checked against its
+      own, and one refused refuses the whole input. Defaults to `AllowAuthenticated`. */
   let commandAuthorization: command => Authorization.rule<role>
-
-  /** The lifecycle enum this component's commands move a row through — the
-      linked view's own, e.g. `type lifecycleState = Customers.accountStatus`.
-      Auto-injected as `unit` alongside the default below; a host that declares
-      `commandTransition` declares this too, and the pair is what makes every
-      edge name one lifecycle. */
-  type lifecycleState
-
-  /** The lifecycle edge each command owns, read while the plugin structure is
-      assembled. Auto-injected as `_ => Unrestricted` by `@@reventless.spec`,
-      so a component whose commands guard nothing needs no line; a host that
-      writes the switch by hand gets an exhaustive one over typed states.
-      See `Transition`. */
-  let commandTransition: command => Transition.t<lifecycleState>
 }
 
-/**
-The Translation — the synchronous translate function.
-*/
+/** The synchronous translate function. */
 module type Translation = {
   module Spec: Spec
 
-  /**
-  Translate: convert external input into domain commands.
-  Returns:
-  - `Ok([(targetId, cmd), ...])` to publish one or more commands
-  - `Ok([])` for idempotent no-ops (nothing to publish)
-  - `Error(msg)` to reject the input
-  */
+  /** External input into `(targetId, command)` pairs; `Ok([])` is an idempotent
+      no-op, `Error(msg)` rejects the input. */
   let translate: Spec.externalInput => result<array<(string, Spec.command)>, string>
 
   /** File URL of this Translation module (`import.meta.url`). */

package/src/lifecycle/CheckLifecycleModel.res

@@ -233,6 +233,10 @@ let elementsOf = (steps: array<dict<JSON.t>>): array<element> =>
 
 let isOpaque = (e: element) => e.opaque == Some(true)
 
+/** A step of a kind the sidecar knows. A `when` of `process`, `sweep` or
+    `exhausted` names no element, and is readable all the same. */
+let readableStep = (e: element) => !isOpaque(e)
+
 let kindOf = (steps: array<dict<JSON.t>>): string =>
   steps->Array.get(0)->Option.flatMap(s => s->getStr("kind"))->Option.getOr("")
 
@@ -263,6 +267,9 @@ let scenarioOf = (j: JSON.t): option<scenario> =>
     }
   })
 
+/** No `when` step of a known kind: the walk has nothing to exercise. */
+let isUnreadable = (s: scenario) => !(s.whenElements->Array.some(readableStep))
+
 let readCorpus = (path: string): option<corpus> =>
   switch path->NodeFs.readFileSync->JSON.parseOrThrow->asObj {
   | None => None
@@ -759,10 +766,10 @@ let deriveCommands = (
     than guessed from names. It needs no lifecycle labelling, so every corpus a
     plugin has is read, though only its command scenarios count.
 
-    An empty `then` is skipped rather than read as "accepted, nothing happened".
-    The PPX currently writes `then: []` for `thenNoEvent`, so an empty `then` is
-    indistinguishable from one the sidecar could not read, and an outcome shown
-    here has to be one a scenario actually states. */
+    An empty `then` is skipped rather than read as "accepted, nothing happened":
+    `thenNoEvent` is written as `noEvent`, so an empty `then` is one the sidecar
+    could not read (or an older sidecar's `noEvent`), and an outcome shown here
+    has to be one a scenario actually states. */
 type shownOutcome = {
   kind: string, // "event" | "error" | "noEvent"
   /** The whole `then`, in order: `thenEvents([A, B])` is one outcome of two
@@ -858,11 +865,11 @@ type finding = {
 
 /** A corpus the walk can only partly read.
 
-    Several DSL verbs record their `given` and nothing else — `thenIssuesCommand`,
-    `whenReacts`, `whenPublishedThrough` and the rest — and so does a readable
-    verb handed a let-bound value rather than a literal, since the sidecar records
-    the constructor application it can see. Either way the scenario reaches here
-    with an empty `when`, and the walk has nothing to exercise.
+    A readable verb handed a let-bound value rather than a literal records it as
+    `opaque`, since the sidecar records the constructor application it can see,
+    and a verb the sidecar has no reading for records nothing. Either way the
+    scenario reaches here with no `when` step of a known kind, and the walk has
+    nothing to exercise.
 
     Counted per component and published, because the distinction a consumer MUST
     keep is "not covered" against "not analysed": a slice with twenty thorough
@@ -1118,7 +1125,7 @@ let runPlugin = async (
     // slices — are exactly the ones that sit outside the view/writable folders
     // below, and they are the ones a coverage UI would otherwise slander.
     corpora->Array.forEach(c => {
-      let unreadable = c.scenarios->Array.filter(s => Array.length(s.whenElements) == 0)
+      let unreadable = c.scenarios->Array.filter(isUnreadable)
       if Array.length(unreadable) > 0 {
         opaque
         ->Array.push({

package/src/lifecycle/CheckLifecycleModel.res.mjs

@@ -132,6 +132,10 @@ function isOpaque(e) {
   return Primitive_object.equal(e.opaque, true);
 }
 
+function readableStep(e) {
+  return !Primitive_object.equal(e.opaque, true);
+}
+
 function kindOf(steps) {
   return Stdlib_Option.getOr(Stdlib_Option.flatMap(steps[0], s => getStr(s, "kind")), "");
 }
@@ -162,6 +166,10 @@ function scenarioOf(j) {
   });
 }
 
+function isUnreadable(s) {
+  return !s.whenElements.some(readableStep);
+}
+
 function readCorpus(path) {
   let d;
   try {
@@ -853,7 +861,7 @@ async function runPlugin(plugin, pluginDir, findings, opaque, outcomes) {
   let corpora = Stdlib_Array.filterMap(filesUnder(Nodepath.join(pluginDir, "tests"), ".gwt.json"), readCorpus);
   outcomes.push(...commandOutcomes(plugin, corpora));
   corpora.forEach(c => {
-    let unreadable = c.scenarios.filter(s => s.whenElements.length === 0);
+    let unreadable = c.scenarios.filter(isUnreadable);
     if (unreadable.length !== 0) {
       opaque.push({
         plugin: plugin,
@@ -1337,9 +1345,11 @@ export {
   valuesOf,
   elementsOf,
   isOpaque,
+  readableStep,
   kindOf,
   thenKindOf,
   scenarioOf,
+  isUnreadable,
   readCorpus,
   filesUnder,
   gwtSources,

package/src/types/Authorization.res

@@ -43,6 +43,21 @@ let admits = (rule: permission, ~signedIn: bool, ~holds: Role.name => bool): boo
   | AllowRoles(roles) => roles->Array.some(holds)
   }
 
+/** The rule a caller satisfies when they satisfy any of `rules`; `None` for none. */
+let anyOf = (rules: array<permission>): option<permission> =>
+  if rules->Array.length == 0 {
+    None
+  } else if rules->Array.some(r => r == AllowAnonymous) {
+    Some(AllowAnonymous)
+  } else if rules->Array.some(r => r == AllowAuthenticated) {
+    Some(AllowAuthenticated)
+  } else {
+    switch rules->Array.flatMap(rolesOf)->Set.fromArray->Set.values->Array.fromIterator {
+    | [] => Some(DenyAll)
+    | roles => Some(AllowRoles(roles))
+    }
+  }
+
 let isAllowed = (rule: permission, identity: Identity.t): bool =>
   admits(rule, ~signedIn=identity.userId !== "anonymous", ~holds=role =>
     identity.groups->Array.includes(Role.groupOf(role))

package/src/types/Authorization.res.mjs

@@ -33,6 +33,27 @@ function admits(rule, signedIn, holds) {
   }
 }
 
+function anyOf(rules) {
+  if (rules.length === 0) {
+    return;
+  }
+  if (rules.some(r => r === "AllowAnonymous")) {
+    return "AllowAnonymous";
+  }
+  if (rules.some(r => r === "AllowAuthenticated")) {
+    return "AllowAuthenticated";
+  }
+  let roles = Array.from(new Set(rules.flatMap(rolesOf)).values());
+  if (roles.length !== 0) {
+    return {
+      TAG: "AllowRoles",
+      _0: roles
+    };
+  } else {
+    return "DenyAll";
+  }
+}
+
 function isAllowed(rule, identity) {
   return admits(rule, identity.userId !== "anonymous", role => identity.groups.includes(Role$Reventless.groupOf(role)));
 }
@@ -42,6 +63,7 @@ export {
   rolesOf,
   groupsOf,
   admits,
+  anyOf,
   isAllowed,
 }
 /* Role-Reventless Not a pure module */