@reventlessdev/reventless-core 3.0.0-alpha.302 → 3.0.0-alpha.303

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 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.303 (2026-10-21)
+
+* feat!: a rejected command says whether the model, the access check or the platform said no ([6a8a6b0](https://github.com/ReventlessDev/reventless-core/commit/6a8a6b0f2f31e766ae26a944c23b0904e51a5865))
+
+### BREAKING CHANGES
+
+* a type error variant with one of those names fails to
+compile; rename it for what the model means, such as AlreadyBooked. On
+AWS, rebuild every plugin against this release before a client selects
+cause: a plugin built earlier answers it with a non-null error.
+
+
+
 # 3.0.0-alpha.302 (2026-10-21)
 
 * feat!: a state view's row key is module Id ([08c9726](https://github.com/ReventlessDev/reventless-core/commit/08c972659a3d689a39fd5e2f2026597155e92210))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.302",
+  "version": "3.0.0-alpha.303",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.15",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.23",
+    "@reventlessdev/rescript-effect": "1.0.0-alpha.1",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.13",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.23",
     "@reventlessdev/rescript-node": "2.0.0-alpha.23",
     "@reventlessdev/rescript-pulumi-pulumi": "3.0.0-alpha.0",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.24",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.1",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.199",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.200",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.24",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.42",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.171"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.172"
   },
   "devDependencies": {
     "rescript": "12.3.1",

package/src/components/Aggregate/Aggregate_Callback.res

@@ -392,7 +392,7 @@ module Make = (
           ~component=Spec.name,
           ~cause=InfrastructureFailure,
           reference,
-          {errorCode: "AppendFailed", errorDetail: appendErrorDetail},
+          {errorCode: Reventless.CommandOutcome.code(AppendFailed), errorDetail: appendErrorDetail},
         )
         Error(reference)
       }

package/src/components/Aggregate/Aggregate_Callback.res.mjs

@@ -15,6 +15,7 @@ import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/U
 import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as CommandOutcome$Reventless from "@reventlessdev/reventless-spec/src/components/CommandOutcome.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 import * as SchemaWalker$ReventlessCore from "../../plugin/component/SchemaWalker.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "../CommandTopic/CommandTopic_Helpers.res.mjs";
@@ -254,7 +255,7 @@ function Make(Spec) {
               };
             } else {
               CommandTopic_Helpers$ReventlessCore.reportRejected(Spec.name, "InfrastructureFailure", reference, {
-                errorCode: "AppendFailed",
+                errorCode: CommandOutcome$Reventless.code("AppendFailed"),
                 errorDetail: appendErrorDetail
               });
               return {

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -12,17 +12,26 @@ let log = Logger.fromEnv()
 // fragments. These SDL declarations are injected into any fragment that emits
 // at least one mutation field; the stitcher dedupes by type name so
 // concatenating across plugin + admin fragments stays safe.
+//
+// `cause` says which no a rejection is: the model's (DOMAIN, `errorCode` is the
+// declared error), the caller's (ACCESS) or the platform's (INFRASTRUCTURE).
 let commandResultSdlTypes: array<string> = [
   `union CommandResult = CommandAccepted | CommandRejected | CommandPending`,
   `type CommandAccepted {
   msgId: ID!
   entityId: ID
   eventCount: Int!
+}`,
+  `enum CommandRejectionCause {
+  DOMAIN
+  ACCESS
+  INFRASTRUCTURE
 }`,
   `type CommandRejected {
   msgId: ID!
   errorCode: String!
   errorDetail: String
+  cause: CommandRejectionCause!
 }`,
   `type CommandPending {
   msgId: ID!

package/src/components/Api/GraphQL_FragmentGenerator.res.mjs

@@ -22,11 +22,17 @@ let commandResultSdlTypes = [
   msgId: ID!
   entityId: ID
   eventCount: Int!
+}`,
+  `enum CommandRejectionCause {
+  DOMAIN
+  ACCESS
+  INFRASTRUCTURE
 }`,
   `type CommandRejected {
   msgId: ID!
   errorCode: String!
   errorDetail: String
+  cause: CommandRejectionCause!
 }`,
   `type CommandPending {
   msgId: ID!

package/src/components/CommandTopic/CommandTopic.res.mjs

@@ -23,6 +23,8 @@ function filter(allCommandTopics, names) {
 
 let componentType = "CommandTopic";
 
+let refusalCauseToGraphQL = CommandTopic_Helpers$ReventlessCore.refusalCauseToGraphQL;
+
 let commandOutcomeHook = CommandTopic_Helpers$ReventlessCore.commandOutcomeHook;
 
 let registerCommandOutcome = CommandTopic_Helpers$ReventlessCore.registerCommandOutcome;
@@ -60,6 +62,7 @@ let getHandlers = CommandTopic_Helpers$ReventlessCore.getHandlers;
 export {
   componentType,
   NotPublishedToChannel,
+  refusalCauseToGraphQL,
   commandOutcomeHook,
   registerCommandOutcome,
   clearCommandOutcome,

package/src/components/CommandTopic/CommandTopic_Helpers.res

@@ -31,6 +31,14 @@ own what the command acts on (`OwnerScope.decideActing`).
 */
 type refusalCause = DomainRejection | InfrastructureFailure | AccessRefusal
 
+/** The `CommandRejectionCause` enum value a client sees for a cause. */
+let refusalCauseToGraphQL = (cause: refusalCause): string =>
+  switch cause {
+  | DomainRejection => "DOMAIN"
+  | AccessRefusal => "ACCESS"
+  | InfrastructureFailure => "INFRASTRUCTURE"
+  }
+
 /**
 What became of one command. Constructors are prefixed to stay clear of `commandOutcome`'s
 `Accepted`/`Rejected` below — that type is the producer-facing result shape (and the GraphQL
@@ -91,10 +99,9 @@ let fireCommandOutcome = (~component: string, ~reference: string, outcome: obser
 // Callback implementations call reportAccepted during inline dispatch.
 let acceptedResultChannel: ref<option<(string, acceptedResult) => unit>> = ref(None)
 
-// Sibling side-channel for domain rejections — populated by callbacks when
-// `Decision.decide` returns `Error`. Read by runInlineAndCollect to build
-// `Rejected` outcomes that carry the real error code and detail.
-let rejectedResultChannel: ref<option<(string, rejectedResult) => unit>> = ref(None)
+// Sibling side-channel for rejections, with their cause. Read by runInlineAndCollect
+// to build `Rejected` outcomes that carry the real error code, detail and cause.
+let rejectedResultChannel: ref<option<(string, rejectedResult, refusalCause) => unit>> = ref(None)
 
 /**
 Turn an `acting` verdict into the refusal a command handler reports, or `None` to let
@@ -112,7 +119,10 @@ let ownershipRefusal = (
   ~command: string,
 ): option<ownershipRefusal> => {
   let refuse = (~isDefect=false, why) => Some({
-    rejected: {errorCode: "Forbidden", errorDetail: `${component}.${command}: ${why}`},
+    rejected: {
+      errorCode: Reventless.CommandOutcome.code(Forbidden),
+      errorDetail: `${component}.${command}: ${why}`,
+    },
     isDefect,
   })
   switch verdict {
@@ -148,7 +158,7 @@ let reportRejected = (
   reference: string,
   result: rejectedResult,
 ) => {
-  rejectedResultChannel.contents->Option.forEach(cb => cb(reference, result))
+  rejectedResultChannel.contents->Option.forEach(cb => cb(reference, result, cause))
   fireCommandOutcome(
     ~component,
     ~reference,
@@ -160,7 +170,7 @@ let reportRejected = (
 // without importing Adapter.res → @pulumi/pulumi. Re-exported by CommandTopic via include.
 type commandOutcome =
   | Accepted({msgId: string, entityId?: string, eventCount: int})
-  | Rejected({msgId: string, errorCode: string, errorDetail: option<string>})
+  | Rejected({msgId: string, errorCode: string, errorDetail: option<string>, cause: refusalCause})
   | Pending({msgId: string})
 
 // Serialise a commandOutcome to the JSON shape the CommandResult GraphQL union
@@ -179,13 +189,14 @@ let commandOutcomeToJson = (outcome: commandOutcome): JSON.t =>
         ("eventCount", JSON.Number(eventCount->Int.toFloat)),
       ]),
     )
-  | Rejected({msgId, errorCode, errorDetail}) =>
+  | Rejected({msgId, errorCode, errorDetail, cause}) =>
     JSON.Object(
       Dict.fromArray([
         ("__typename", JSON.String("CommandRejected")),
         ("msgId", JSON.String(msgId)),
         ("errorCode", JSON.String(errorCode)),
         ("errorDetail", errorDetail->Option.map(s => JSON.String(s))->Option.getOr(JSON.Null)),
+        ("cause", JSON.String(refusalCauseToGraphQL(cause))),
       ]),
     )
   | Pending({msgId}) =>
@@ -222,27 +233,34 @@ let runInlineAndCollect = async (
     item
   })
   let acceptedResults: dict<acceptedResult> = Dict.make()
-  let rejectedResults: dict<rejectedResult> = Dict.make()
+  let rejectedResults: dict<(rejectedResult, refusalCause)> = Dict.make()
   acceptedResultChannel.contents = Some(
     (reference, result) => acceptedResults->Dict.set(reference, result),
   )
   rejectedResultChannel.contents = Some(
-    (reference, result) => rejectedResults->Dict.set(reference, result),
+    (reference, result, cause) => rejectedResults->Dict.set(reference, (result, cause)),
   )
   let results = await handleCmds(Stream.fromIterable(items))->Effect.runPromise
   acceptedResultChannel.contents = None
   rejectedResultChannel.contents = None
   jsons->Array.mapWithIndex((cmdJson, i) => {
     let msgId = cmdJson.meta.msgId
-    // Domain rejection from Decision.decide takes precedence over both Accepted
-    // and the synthesized "Conflict" — it carries the most informative error.
+    // A reported rejection takes precedence over both Accepted and the
+    // synthesized "Conflict" — it carries the most informative error.
     switch rejectedResults->Dict.get(msgId) {
-    | Some({errorCode, errorDetail}) =>
+    | Some(({errorCode, errorDetail}, cause)) =>
       let detail = errorDetail == "" ? None : Some(errorDetail)
-      Rejected({msgId, errorCode, errorDetail: detail})
+      Rejected({msgId, errorCode, errorDetail: detail, cause})
     | None =>
       switch results->Array.get(i) {
-      | Some(Error(msg)) => Rejected({msgId, errorCode: "Conflict", errorDetail: Some(msg)})
+      // The handler failed outright: the platform, not the model.
+      | Some(Error(msg)) =>
+        Rejected({
+          msgId,
+          errorCode: Reventless.CommandOutcome.code(Conflict),
+          errorDetail: Some(msg),
+          cause: InfrastructureFailure,
+        })
       | _ =>
         let ar = acceptedResults->Dict.get(msgId)->Option.getOr({eventCount: 0})
         switch ar.entityId {

package/src/components/CommandTopic/CommandTopic_Helpers.res.mjs

@@ -8,8 +8,20 @@ import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/component
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as CommandOutcome$Reventless from "@reventlessdev/reventless-spec/src/components/CommandOutcome.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 
+function refusalCauseToGraphQL(cause) {
+  switch (cause) {
+    case "DomainRejection" :
+      return "DOMAIN";
+    case "InfrastructureFailure" :
+      return "INFRASTRUCTURE";
+    case "AccessRefusal" :
+      return "ACCESS";
+  }
+}
+
 let commandOutcomeHook = {
   contents: undefined
 };
@@ -51,7 +63,7 @@ function ownershipRefusal(verdict, component, command) {
     let isDefect = isDefectOpt !== undefined ? isDefectOpt : false;
     return {
       rejected: {
-        errorCode: "Forbidden",
+        errorCode: CommandOutcome$Reventless.code("Forbidden"),
         errorDetail: component + `.` + command + `: ` + why
       },
       isDefect: isDefect
@@ -84,7 +96,7 @@ function reportAccepted(component, reference, result) {
 }
 
 function reportRejected(component, cause, reference, result) {
-  Stdlib_Option.forEach(rejectedResultChannel.contents, cb => cb(reference, result));
+  Stdlib_Option.forEach(rejectedResultChannel.contents, cb => cb(reference, result, cause));
   fireCommandOutcome(component, reference, {
     TAG: "OutcomeRejected",
     errorCode: result.errorCode,
@@ -131,6 +143,10 @@ function commandOutcomeToJson(outcome) {
         [
           "errorDetail",
           Stdlib_Option.getOr(Stdlib_Option.map(outcome.errorDetail, s => (s)), null)
+        ],
+        [
+          "cause",
+          refusalCauseToGraphQL(outcome.cause)
         ]
       ]);
     case "Pending" :
@@ -177,8 +193,11 @@ async function runInlineAndCollect(jsons, handleCmds) {
   acceptedResultChannel.contents = (reference, result) => {
     acceptedResults[reference] = result;
   };
-  rejectedResultChannel.contents = (reference, result) => {
-    rejectedResults[reference] = result;
+  rejectedResultChannel.contents = (reference, result, cause) => {
+    rejectedResults[reference] = [
+      result,
+      cause
+    ];
   };
   let results = await Effect.runPromise(handleCmds(Stream.fromIterable(items)));
   acceptedResultChannel.contents = undefined;
@@ -187,22 +206,25 @@ async function runInlineAndCollect(jsons, handleCmds) {
     let msgId = cmdJson.meta.msgId;
     let match = rejectedResults[msgId];
     if (match !== undefined) {
-      let errorDetail = match.errorDetail;
+      let match$1 = match[0];
+      let errorDetail = match$1.errorDetail;
       let detail = errorDetail === "" ? undefined : errorDetail;
       return {
         TAG: "Rejected",
         msgId: msgId,
-        errorCode: match.errorCode,
-        errorDetail: detail
+        errorCode: match$1.errorCode,
+        errorDetail: detail,
+        cause: match[1]
       };
     }
-    let match$1 = results[i];
-    if (match$1 !== undefined && match$1.TAG !== "Ok") {
+    let match$2 = results[i];
+    if (match$2 !== undefined && match$2.TAG !== "Ok") {
       return {
         TAG: "Rejected",
         msgId: msgId,
-        errorCode: "Conflict",
-        errorDetail: match$1._0
+        errorCode: CommandOutcome$Reventless.code("Conflict"),
+        errorDetail: match$2._0,
+        cause: "InfrastructureFailure"
       };
     }
     let ar = Stdlib_Option.getOr(acceptedResults[msgId], {
@@ -249,6 +271,7 @@ function getHandlers(typeName) {
 }
 
 export {
+  refusalCauseToGraphQL,
   commandOutcomeHook,
   registerCommandOutcome,
   clearCommandOutcome,

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res

@@ -19,6 +19,17 @@ type auditRow = {
   door?: ReventlessInfra.InboundTranslationSlice.door,
 }
 
+/** A refused caller is access, a failed publish the platform; anything else is
+    the translation refusing its input. */
+let rejectionCauseOf = (errorCode: string): CommandTopic_Helpers.refusalCause =>
+  if errorCode == Reventless.CommandOutcome.code(Forbidden) {
+    AccessRefusal
+  } else if errorCode == Reventless.CommandOutcome.code(PublishFailed) {
+    InfrastructureFailure
+  } else {
+    DomainRejection
+  }
+
 /** The `CommandResult` a `receive` outcome answers with: the first target as
     `entityId` (omitted when nothing was produced), the fan-out as `eventCount`. */
 let receiveResultToOutcome = (
@@ -31,10 +42,12 @@ let receiveResultToOutcome = (
     | None => Accepted({msgId: requestId, eventCount: commandCount})
     }
   | Error({requestId, error, ?errorCode}) =>
+    let errorCode = errorCode->Option.getOr(Reventless.CommandOutcome.code(TranslationFailed))
     Rejected({
       msgId: requestId,
-      errorCode: errorCode->Option.getOr("TranslationFailed"),
+      errorCode,
       errorDetail: Some(error),
+      cause: rejectionCauseOf(errorCode),
     })
   }
 
@@ -216,7 +229,7 @@ module Make = (
             )
           ) =>
           fail(
-            ~errorCode="Forbidden",
+            ~errorCode=Reventless.CommandOutcome.code(Forbidden),
             `${Spec.name}: the caller is not authorized for every command this input translates into`,
           )
         | Ok([]) => succeed([])
@@ -225,7 +238,11 @@ module Make = (
             await publishJsons(msgs)
             succeed(pairs->Array.map(((targetId, _)) => targetId))
           } catch {
-          | exn => fail(~errorCode="PublishFailed", messageOf(exn, "publish failed"))
+          | exn =>
+            fail(
+              ~errorCode=Reventless.CommandOutcome.code(PublishFailed),
+              messageOf(exn, "publish failed"),
+            )
           }
         }
       }

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs

@@ -16,6 +16,7 @@ import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/U
 import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as Authorization$Reventless from "@reventlessdev/reventless-spec/src/types/Authorization.res.mjs";
+import * as CommandOutcome$Reventless from "@reventlessdev/reventless-spec/src/components/CommandOutcome.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 import * as ApiNoApiHelpers$ReventlessCore from "../Api/ApiNoApiHelpers.res.mjs";
 import * as InboundTranslationSlice$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/InboundTranslationSlice.res.mjs";
@@ -36,6 +37,16 @@ let auditRowSchema = Sury.$schema(s => ({
   door: s.m(Sury.$option(InboundTranslationSlice$ReventlessInfra.doorSchema))
 }));
 
+function rejectionCauseOf(errorCode) {
+  if (errorCode === CommandOutcome$Reventless.code("Forbidden")) {
+    return "AccessRefusal";
+  } else if (errorCode === CommandOutcome$Reventless.code("PublishFailed")) {
+    return "InfrastructureFailure";
+  } else {
+    return "DomainRejection";
+  }
+}
+
 function receiveResultToOutcome(result) {
   if (result.TAG === "Ok") {
     let match = result._0;
@@ -58,11 +69,13 @@ function receiveResultToOutcome(result) {
     }
   }
   let match$1 = result._0;
+  let errorCode = Stdlib_Option.getOr(match$1.errorCode, CommandOutcome$Reventless.code("TranslationFailed"));
   return {
     TAG: "Rejected",
     msgId: match$1.requestId,
-    errorCode: Stdlib_Option.getOr(match$1.errorCode, "TranslationFailed"),
-    errorDetail: match$1.error
+    errorCode: errorCode,
+    errorDetail: match$1.error,
+    cause: rejectionCauseOf(errorCode)
   };
 }
 
@@ -213,7 +226,7 @@ function Make(Spec) {
       }
       let msgs = msg$1._0;
       if (msgs.some(param => !callerAdmits(Authorization$Reventless.named(Spec.authorizationOf(Message$Reventless.variantNameOfJson(param.commandJson))), caller))) {
-        return fail("Forbidden", Spec.name + `: the caller is not authorized for every command this input translates into`);
+        return fail(CommandOutcome$Reventless.code("Forbidden"), Spec.name + `: the caller is not authorized for every command this input translates into`);
       }
       if (msgs.length === 0) {
         return succeed([]);
@@ -223,7 +236,7 @@ function Make(Spec) {
         return succeed(pairs.map(param => param[0]));
       } catch (raw_exn$1) {
         let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
-        return fail("PublishFailed", messageOf(exn$1, "publish failed"));
+        return fail(CommandOutcome$Reventless.code("PublishFailed"), messageOf(exn$1, "publish failed"));
       }
     };
     let refuse = (body, errorCode, error) => failWith(Uuid.v4(), body, "Webhook", errorCode, error);
@@ -241,6 +254,7 @@ function Make(Spec) {
 export {
   auditStatusSchema,
   auditRowSchema,
+  rejectionCauseOf,
   receiveResultToOutcome,
   requestIdOf,
   takeAuditRow,

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -478,10 +478,10 @@ module Make = (
                     // which disagreed with the backends' casing).
                     let (errorCode, errDetail) = switch err {
                     | ReventlessInfra.DcbEventLog.Conflict => (
-                        "Conflict",
+                        Reventless.CommandOutcome.code(Conflict),
                         "conflict: condition check failed",
                       )
-                    | StorageFailure(msg) => ("AppendFailed", msg)
+                    | StorageFailure(msg) => (Reventless.CommandOutcome.code(AppendFailed), msg)
                     }
                     if retries > 0 {
                       // Re-seed from the just-read snapshot so the retry reads only
@@ -504,7 +504,7 @@ module Make = (
                       // A surfaced Conflict means the 3-retry loop could not absorb
                       // the contention — the operator signal for "this slice is hot"
                       // (consider sharding / async — Issue 10, §4 of the analysis).
-                      if errorCode == "Conflict" {
+                      if errorCode == Reventless.CommandOutcome.code(Conflict) {
                         Metrics.emitCount(~metric="AppendConflict", ~slice=Spec.name)
                       }
                       // Both arms here are storage, not the model: a surfaced Conflict is

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -17,6 +17,7 @@ import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as Metrics$ReventlessCore from "../../util/Metrics.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as CommandOutcome$Reventless from "@reventlessdev/reventless-spec/src/components/CommandOutcome.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "../CommandTopic/CommandTopic_Helpers.res.mjs";
 
@@ -311,10 +312,10 @@ function Make(Spec) {
                 let err = appendResult._0;
                 let match;
                 match = typeof err !== "object" ? [
-                    "Conflict",
+                    CommandOutcome$Reventless.code("Conflict"),
                     "conflict: condition check failed"
                   ] : [
-                    "AppendFailed",
+                    CommandOutcome$Reventless.code("AppendFailed"),
                     err._0
                   ];
                 let errDetail = match[1];
@@ -329,7 +330,7 @@ function Make(Spec) {
                   return Effect.flatMap(EffectLogger$ReventlessCore.logWarn(comp, undefined, `append failed (retrying ` + ((3 - retries | 0) + 1 | 0).toString() + `/` + (3).toString() + `): ` + errDetail), () => attempt(retries - 1 | 0));
                 } else {
                   cacheInvalidate();
-                  if (errorCode === "Conflict") {
+                  if (errorCode === CommandOutcome$Reventless.code("Conflict")) {
                     Metrics$ReventlessCore.emitCount("AppendConflict", Spec.name, undefined);
                   }
                   CommandTopic_Helpers$ReventlessCore.reportRejected(Spec.name, "InfrastructureFailure", cmdJson.meta.msgId, {

package/tests/aggregate/AggregateRejectionTest.res

@@ -14,13 +14,18 @@ let _ = beforeEach(() => {
 
 // Captures whatever flows through CommandTopic_Helpers.reportRejected during a test.
 let capturedRejections: ref<array<(string, CommandTopic_Helpers.rejectedResult)>> = ref([])
+let capturedCauses: ref<array<CommandTopic_Helpers.refusalCause>> = ref([])
 let capturedAccepts: ref<array<(string, CommandTopic_Helpers.acceptedResult)>> = ref([])
 
 let installChannels = () => {
   capturedRejections := []
+  capturedCauses := []
   capturedAccepts := []
   CommandTopic_Helpers.rejectedResultChannel.contents = Some(
-    (ref, info) => capturedRejections := capturedRejections.contents->Array.concat([(ref, info)]),
+    (ref, info, cause) => {
+      capturedRejections := capturedRejections.contents->Array.concat([(ref, info)])
+      capturedCauses := capturedCauses.contents->Array.concat([cause])
+    },
   )
   CommandTopic_Helpers.acceptedResultChannel.contents = Some(
     (ref, info) => capturedAccepts := capturedAccepts.contents->Array.concat([(ref, info)]),
@@ -58,6 +63,8 @@ describe("Aggregate decide-rejection propagation:", () => {
         let (ref, info) = capturedRejections.contents->Array.getUnsafe(0)
         expect(ref)->toEqual("ref-1")
         expect(info.errorCode)->toEqual("AlreadyExists")
+        // `decide` said no: the model, not the platform.
+        expect(capturedCauses.contents)->toEqual([CommandTopic_Helpers.DomainRejection])
         // No event was appended.
         expect(mock.getAll()->Array.length)->toBe(1)
       },

package/tests/aggregate/AggregateRejectionTest.res.mjs

@@ -14,18 +14,24 @@ let capturedRejections = {
   contents: []
 };
 
+let capturedCauses = {
+  contents: []
+};
+
 let capturedAccepts = {
   contents: []
 };
 
 function installChannels() {
   capturedRejections.contents = [];
+  capturedCauses.contents = [];
   capturedAccepts.contents = [];
-  CommandTopic_Helpers$ReventlessCore.rejectedResultChannel.contents = (ref, info) => {
+  CommandTopic_Helpers$ReventlessCore.rejectedResultChannel.contents = (ref, info, cause) => {
     capturedRejections.contents = capturedRejections.contents.concat([[
         ref,
         info
       ]]);
+    capturedCauses.contents = capturedCauses.contents.concat([cause]);
   };
   CommandTopic_Helpers$ReventlessCore.acceptedResultChannel.contents = (ref, info) => {
     capturedAccepts.contents = capturedAccepts.contents.concat([[
@@ -61,6 +67,7 @@ globalThis.describe("Aggregate decide-rejection propagation:", () => {
       let match = capturedRejections.contents[0];
       globalThis.expect(match[0]).toEqual("ref-1");
       globalThis.expect(match[1].errorCode).toEqual("AlreadyExists");
+      globalThis.expect(capturedCauses.contents).toEqual(["DomainRejection"]);
       globalThis.expect(AggregateFixtures$ReventlessCore.mock.getAll().length).toBe(1);
     });
   });
@@ -159,6 +166,7 @@ globalThis.describe("Aggregate decide-rejection propagation:", () => {
 
 export {
   capturedRejections,
+  capturedCauses,
   capturedAccepts,
   installChannels,
   uninstallChannels,

package/tests/commandtopic/CommandTopicHelpersRejectionTest.res

@@ -50,10 +50,11 @@ describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
       let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmdJson("msg-1")], handler)
       expect(outcomes->Array.length)->toBe(1)
       switch outcomes->Array.getUnsafe(0) {
-      | Rejected({msgId, errorCode, errorDetail}) =>
+      | Rejected({msgId, errorCode, errorDetail, cause}) =>
         expect(msgId)->toEqual("msg-1")
         expect(errorCode)->toEqual("AlreadyExists")
         expect(errorDetail)->toEqual(None)
+        expect(cause)->toEqual(CommandTopic_Helpers.DomainRejection)
       | Accepted(_) | Pending(_) => expect("expected Rejected")->toEqual("got other")
       }
     },
@@ -99,8 +100,59 @@ describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
 
     let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmdJson("msg-1")], handler)
     switch outcomes->Array.getUnsafe(0) {
-    | Rejected({errorCode}) => expect(errorCode)->toEqual("Conflict")
+    | Rejected({errorCode, cause}) =>
+      expect(errorCode)->toEqual("Conflict")
+      expect(cause)->toEqual(CommandTopic_Helpers.InfrastructureFailure)
     | _ => expect("expected Rejected(Conflict)")->toEqual("got other")
     }
   })
+
+  testPromise("a reported access refusal keeps its cause", async () => {
+    let handler: CommandTopic_Helpers.jsonCommandsHandler = stream =>
+      stream
+      ->Stream.runCollect
+      ->Effect.map(
+        items => {
+          items->Array.forEach(
+            item =>
+              CommandTopic_Helpers.reportRejected(
+                ~component="TestService",
+                ~cause=AccessRefusal,
+                item.reference,
+                {errorCode: "Forbidden", errorDetail: "not the owner"},
+              ),
+          )
+          items->Array.map(item => Ok(item.reference))
+        },
+      )
+
+    let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmdJson("msg-1")], handler)
+    switch outcomes->Array.getUnsafe(0) {
+    | Rejected({errorCode, cause}) =>
+      expect(errorCode)->toEqual("Forbidden")
+      expect(cause)->toEqual(CommandTopic_Helpers.AccessRefusal)
+    | _ => expect("expected Rejected(Forbidden)")->toEqual("got other")
+    }
+  })
+})
+
+describe("CommandTopic_Helpers.commandOutcomeToJson:", () => {
+  let causeOf = (cause: CommandTopic_Helpers.refusalCause) =>
+    CommandTopic_Helpers.commandOutcomeToJson(
+      Rejected({msgId: "m", errorCode: "X", errorDetail: None, cause}),
+    )
+    ->JSON.Decode.object
+    ->Option.flatMap(o => o->Dict.get("cause"))
+    ->Option.flatMap(JSON.Decode.string)
+
+  testSync("a rejection carries its cause as the GraphQL enum value", () => {
+    expect(causeOf(DomainRejection))->toEqual(Some("DOMAIN"))
+    expect(causeOf(AccessRefusal))->toEqual(Some("ACCESS"))
+    expect(causeOf(InfrastructureFailure))->toEqual(Some("INFRASTRUCTURE"))
+  })
+
+  testSync("an accepted outcome carries no cause", () => {
+    let json = CommandTopic_Helpers.commandOutcomeToJson(Accepted({msgId: "m", eventCount: 1}))
+    expect(json->JSON.Decode.object->Option.flatMap(o => o->Dict.get("cause")))->toEqual(None)
+  })
 })

package/tests/commandtopic/CommandTopicHelpersRejectionTest.res.mjs

@@ -1,6 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as CommandTopic_Helpers$ReventlessCore from "../../src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
 
@@ -52,6 +54,7 @@ globalThis.describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
         globalThis.expect(match.msgId).toEqual("msg-1");
         globalThis.expect(match.errorCode).toEqual("AlreadyExists");
         globalThis.expect(match.errorDetail).toEqual(undefined);
+        globalThis.expect(match.cause).toEqual("DomainRejection");
         return;
       case "Accepted" :
       case "Pending" :
@@ -93,6 +96,7 @@ globalThis.describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
     switch (match.TAG) {
       case "Rejected" :
         globalThis.expect(match.errorCode).toEqual("Conflict");
+        globalThis.expect(match.cause).toEqual("InfrastructureFailure");
         return;
       case "Accepted" :
       case "Pending" :
@@ -100,6 +104,53 @@ globalThis.describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
         return;
     }
   });
+  globalThis.test("a reported access refusal keeps its cause", async () => {
+    let handler = stream => Effect.map(Stream.runCollect(stream), items => {
+      items.forEach(item => CommandTopic_Helpers$ReventlessCore.reportRejected("TestService", "AccessRefusal", item.reference, {
+        errorCode: "Forbidden",
+        errorDetail: "not the owner"
+      }));
+      return items.map(item => ({
+        TAG: "Ok",
+        _0: item.reference
+      }));
+    });
+    let outcomes = await CommandTopic_Helpers$ReventlessCore.runInlineAndCollect([cmdJson("msg-1")], handler);
+    let match = outcomes[0];
+    switch (match.TAG) {
+      case "Rejected" :
+        globalThis.expect(match.errorCode).toEqual("Forbidden");
+        globalThis.expect(match.cause).toEqual("AccessRefusal");
+        return;
+      case "Accepted" :
+      case "Pending" :
+        globalThis.expect("expected Rejected(Forbidden)").toEqual("got other");
+        return;
+    }
+  });
+});
+
+globalThis.describe("CommandTopic_Helpers.commandOutcomeToJson:", () => {
+  let causeOf = cause => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(CommandTopic_Helpers$ReventlessCore.commandOutcomeToJson({
+    TAG: "Rejected",
+    msgId: "m",
+    errorCode: "X",
+    errorDetail: undefined,
+    cause: cause
+  })), o => o["cause"]), Stdlib_JSON.Decode.string);
+  globalThis.test("a rejection carries its cause as the GraphQL enum value", () => {
+    globalThis.expect(causeOf("DomainRejection")).toEqual("DOMAIN");
+    globalThis.expect(causeOf("AccessRefusal")).toEqual("ACCESS");
+    globalThis.expect(causeOf("InfrastructureFailure")).toEqual("INFRASTRUCTURE");
+  });
+  globalThis.test("an accepted outcome carries no cause", () => {
+    let json = CommandTopic_Helpers$ReventlessCore.commandOutcomeToJson({
+      TAG: "Accepted",
+      msgId: "m",
+      eventCount: 1
+    });
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), o => o["cause"])).toEqual(undefined);
+  });
 });
 
 export {