@reventlessdev/reventless-core 3.0.0-alpha.255 → 3.0.0-alpha.257

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -29,6 +29,8 @@ import * as GraphQL_FragmentGenerator$ReventlessCore from "../../components/Api/
 
 let log = Logger$ReventlessCore.fromEnv();
 
+let declaredTransitionsOnly = Stdlib_Option.isSome(process.env.REVENTLESS_DECLARED_TRANSITIONS_ONLY);
+
 function isLabelShape(_t) {
   while (true) {
     let t = _t;
@@ -342,18 +344,20 @@ function checkDeclaredTransitions(pluginName, writables, lifecycleStatesByView)
       });
       if (known.length === 0) {
         unvalidated.contents = unvalidated.contents + 1 | 0;
-      } else {
-        declared.filter(state => !known.includes(state)).forEach(state => {
-          failures.push(w.name + `.` + cmd.name + ` declares state "` + state + `", which none of its ` + (`linked views declare — ` + w.linkedViews.join(", ") + ` know ` + known.join(", ") + `.`));
-        });
+        return;
       }
+      let match = cmd.allowedStatesSource;
+      let hint = match === "derived" ? " This edge came from the component's own scenarios, so the committed lifecycle model is stale." : "";
+      declared.filter(state => !known.includes(state)).forEach(state => {
+        failures.push(w.name + `.` + cmd.name + ` declares state "` + state + `", which none of its ` + (`linked views declare — ` + w.linkedViews.join(", ") + ` know ` + known.join(", ") + `.` + hint));
+      });
     });
   });
   if (unvalidated.contents > 0) {
     log.warn("Plugin_Structure", undefined, pluginName + `: ` + unvalidated.contents.toString() + ` command(s) declare a transition but no linked view declares a lifecycle to check it against.`);
   }
   if (failures.length !== 0) {
-    return Stdlib_JsError.throwWithMessage(pluginName + `: a declared transition names states that do not exist.\n` + failures.join("\n"));
+    return Stdlib_JsError.throwWithMessage(pluginName + `: a transition names states that do not exist.\n` + failures.join("\n"));
   }
 }
 
@@ -449,14 +453,14 @@ function labelFieldsFromStateSchema(entityName, stateSchema) {
 }
 
 function extractReferences(properties) {
-  return Stdlib_Array.filterMap(Object.entries(properties), param => {
-    let fieldName = param[0];
-    return Stdlib_Option.map(Reference$Reventless.getFieldTarget(param[1]), target => ({
-      fieldName: fieldName,
+  return Object.entries(properties).flatMap(param => Reference$Reventless.collectFieldTargets(param[0], param[1]).map(param => {
+    let target = param[1];
+    return {
+      fieldName: param[0],
       entity: target.entity,
       plugin: target.plugin
-    }));
-  });
+    };
+  }));
 }
 
 function toEventDef(v) {
@@ -464,7 +468,7 @@ function toEventDef(v) {
     let references = extractReferences(properties);
     return {
       name: variantName,
-      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v)),
+      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, v)),
       references: references
     };
   };
@@ -592,7 +596,7 @@ function annotateArgTypes(schema, argTypes) {
   return schema;
 }
 
-function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthorization, commandTransition, v) {
+function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthorization, commandTransition, derivedEdgeFor, v) {
   let mkDef = (variantName, properties) => {
     let match = commandLevelAndId(isAggregate, variantName, properties);
     let references = extractReferences(properties);
@@ -600,8 +604,36 @@ function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthor
         TAG: variantName
       }) : variantName;
     let declared = commandTransition(syntheticCommand);
-    let allowedStates = Transition$Reventless.allowedStates(declared);
-    let targetState = Transition$Reventless.targetState(declared);
+    let derived = derivedEdgeFor(variantName);
+    let unrestricted = Transition$Reventless.isUnrestricted(declared);
+    let match$1 = unrestricted ? undefined : Stdlib_Option.flatMap(derived, d => {
+        if (d.allowedStates.length !== 0) {
+          return d.allowedStates;
+        }
+      });
+    let match$2 = Transition$Reventless.allowedStates(declared);
+    let match$3 = match$1 !== undefined ? [
+        match$1,
+        "derived"
+      ] : (
+        match$2 !== undefined ? [
+            match$2,
+            "declared"
+          ] : [
+            undefined,
+            unrestricted ? "unrestricted" : undefined
+          ]
+      );
+    let observed = Stdlib_Option.flatMap(derived, d => {
+      let match = d.targets;
+      if (match.length !== 1) {
+        return;
+      } else {
+        return match[0];
+      }
+    });
+    let targetState = observed !== undefined ? observed : Transition$Reventless.targetState(declared);
+    let level = Stdlib_Option.getOr(Stdlib_Option.flatMap(derived, d => d.level), match[0]);
     let apiExposed = false;
     if (!ApiNoApiHelpers$ReventlessCore.isNoApi(parentSchema)) {
       let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
@@ -609,17 +641,18 @@ function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthor
     }
     let requiredAccess = accessKeysFor(commandAuthorization(syntheticCommand));
     let mutationField = apiExposed ? mutationFieldFor(variantName) : "";
-    let jsonSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v);
+    let jsonSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(apiExposed, mutationField, v);
     let annotatedSchema = apiExposed ? Stdlib_Option.mapOr(GraphQL_FragmentGenerator$ReventlessCore.mutationArgTypes(mutationField, v), jsonSchema, __x => annotateArgTypes(jsonSchema, __x)) : jsonSchema;
     return {
       name: variantName,
       schema: JSON.stringify(annotatedSchema),
-      level: match[0],
+      level: level,
       aggregateIdField: match[1],
       mutationField: mutationField,
       references: references,
-      allowedStates: allowedStates,
+      allowedStates: match$3[0],
       targetState: targetState,
+      allowedStatesSource: match$3[1],
       apiExposed: apiExposed,
       requiredAccess: requiredAccess,
       ownerField: Owner$Reventless.fieldNamesOfProperties(properties)[0]
@@ -649,11 +682,12 @@ function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthor
   }
 }
 
-function extractCommandDefs(isAggregate, mutationFieldFor, commandAuthorization, commandTransition, commandSchema) {
+function extractCommandDefs(isAggregate, mutationFieldFor, commandAuthorization, commandTransition, derivedEdgeForOpt, commandSchema) {
+  let derivedEdgeFor = derivedEdgeForOpt !== undefined ? derivedEdgeForOpt : param => {};
   if (commandSchema.type === "anyOf") {
-    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, v));
+    return Stdlib_Array.filterMap(commandSchema.anyOf, v => toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, v));
   } else {
-    return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, commandSchema), [], def => [def]);
+    return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandAuthorization, commandTransition, derivedEdgeFor, commandSchema), [], def => [def]);
   }
 }
 
@@ -675,7 +709,7 @@ function queryableDefFromSpec(plugin, name, stateSchema, authorization, visibili
   return {
     name: name,
     queryField: qf.listFieldName,
-    schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(stateSchema)),
+    schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, stateSchema)),
     consumedEventTypes: consumedEventTypes,
     linkedWriteSide: linkedWriteSide,
     labelField: label.field,
@@ -695,7 +729,7 @@ function queryableDefFromSpec(plugin, name, stateSchema, authorization, visibili
   };
 }
 
-function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt) {
+function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt, lifecycleModelOpt) {
   let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
   let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
   let stateViewSlices = stateViewSlicesOpt !== undefined ? stateViewSlicesOpt : [];
@@ -706,6 +740,15 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
   let extensions = extensionsOpt !== undefined ? extensionsOpt : [];
   let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];
   let componentChapters = componentChaptersOpt !== undefined ? componentChaptersOpt : ({});
+  let lifecycleModel = lifecycleModelOpt !== undefined ? lifecycleModelOpt : [];
+  let model = declaredTransitionsOnly ? [] : lifecycleModel;
+  let derivedEdgeFor = (component, command) => model.find(e => {
+    if (e.component === component) {
+      return e.command === command;
+    } else {
+      return false;
+    }
+  });
   let qualify = (prefix, names) => names.map(n => prefix + "." + n);
   let scsProduced = stateChangeSlices.map(SCS => [
     SCS.Spec.name,
@@ -975,7 +1018,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     return {
       name: R.Spec.name,
       queryField: qf.listFieldName,
-      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(stateSchema)),
+      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, stateSchema)),
       consumedEventTypes: consumed,
       linkedWriteSide: linkedWriteSideFor(consumed),
       labelField: label.field,
@@ -1007,7 +1050,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     return {
       name: SVS.Spec.name,
       queryField: qf.listFieldName,
-      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(stateSchema)),
+      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, stateSchema)),
       consumedEventTypes: consumed,
       linkedWriteSide: linkedWriteSideFor(consumed),
       labelField: label.field,
@@ -1033,7 +1076,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let consumed = match$1[1];
     return {
       name: SCS.Spec.name,
-      commands: extractCommandDefs(false, variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), SCS.Spec.commandAuthorization, SCS.Spec.commandTransition, SCS.Spec.commandSchema),
+      commands: extractCommandDefs(false, variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), SCS.Spec.commandAuthorization, SCS.Spec.commandTransition, extra => derivedEdgeFor(SCS.Spec.name, extra), SCS.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: consumed,
       linkedViews: linkedSvsFor(produced),
@@ -1048,7 +1091,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let produced = match[1];
     return {
       name: A.Spec.name,
-      commands: extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandAuthorization, A.Spec.commandTransition, A.Spec.commandSchema),
+      commands: extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), A.Spec.commandAuthorization, A.Spec.commandTransition, extra => derivedEdgeFor(A.Spec.name, extra), A.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: [],
       linkedViews: linkedSvsFor(produced).concat(linkedReadModelsFor(A.Spec.name)),
@@ -1342,6 +1385,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
 
 export {
   log,
+  declaredTransitionsOnly,
   isLabelShape,
   isLifecycleShape,
   conventionalLabelNames,

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -71,7 +71,7 @@ type state = {
   // Admin's manageSubscriptions uses this to wire cross-plugin SNS subscriptions
   // from this plugin's DCB topic → peer EventCollectors (and vice-versa). None
   // for pure-aggregate plugins or for plugins persisted before Phase 4.
-  dcbEventLog: @s.matches(Reventless.Plugin.dcbEventLogOptionSchema) option<Reventless.Plugin.dcbEventLogDefinition>,
+  dcbEventLog: option<Reventless.Plugin.dcbEventLogDefinition>,
   // Business role of the plugin (from pluginDefinition.kind). Lets the admin Plugins
   // view segregate PlatformInfrastructure / Commercial / Marketplace from Domain.
   // @scan opts the field into server-side equality filtering so the connection gains

package/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs

@@ -26,7 +26,7 @@ let stateSchema = Sury.$schema(s => ({
   apiSchemaFragment: s.m(Sury.$option(Sury.json)),
   apiTarget: s.m(Sury.$option(Sury.string)),
   structure: s.m(Sury.$option(Sury.json)),
-  dcbEventLog: s.m(Plugin$Reventless.dcbEventLogOptionSchema),
+  dcbEventLog: s.m(Sury.$option(Plugin$Reventless.dcbEventLogDefinitionSchema)),
   kind: s.m(Sury.$option(Plugin$Reventless.pluginKindSchema)),
   otherConnectedVersions: s.m(Sury.array(Plugin$Reventless.versionSchema))
 }));

package/src/util/Validation.res

@@ -31,7 +31,7 @@ let merge: (t<'a, 'b>, t<'a, 'b>) => t<'a, 'b> = (v1, v2) => {
 }
 
 let defaultErrorHandler = err => {
-  EffectLogger.logError(~comp=__MODULE__, err->JSON.stringifyAny->Option.getOr("unknown"))->Effect.runSync
+  EffectLogger.logError(~comp=__MODULE__, err->Reventless.Util_Sury.exnMessage)->Effect.runSync
   Failure("Couldn't resolve promise.")
 }
 

package/src/util/Validation.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as EffectLogger$ReventlessCore from "./EffectLogger.res.mjs";
 
 function merge(v1, v2) {
@@ -105,7 +105,7 @@ function merge(v1, v2) {
 }
 
 function defaultErrorHandler(err) {
-  Effect.runSync(EffectLogger$ReventlessCore.logError("Validation-ReventlessCore", undefined, Stdlib_Option.getOr(JSON.stringify(err), "unknown")));
+  Effect.runSync(EffectLogger$ReventlessCore.logError("Validation-ReventlessCore", undefined, Util_Sury$Reventless.exnMessage(err, undefined)));
   return {
     TAG: "Failure",
     _0: "Couldn't resolve promise."

package/tests/adapter/MonitoringTest.res

@@ -6,10 +6,49 @@ open JestGlobals
 let stubResource: ReventlessInfra.Adapter.resource = %raw(`{}`)
 
 describe("Monitoring", () => {
-  testSync("Noop default: notify is silent and does not throw", () => {
-    // No backend registered — the default Noop backend swallows the call.
+  testSync("no backend registered: notify is silent and does not throw", () => {
     Monitoring.notify(~kind=CommandHandler, ~name="before", ~component=stubResource)
     expect(true)->toBe(true)
+    Monitoring.reset()
+  })
+
+  // The case the dead-letter sink is: a module that provisions at import time announces
+  // itself before any statement of the deploy program has run, so it is *always* earlier
+  // than the `use` call. Dropping those announcements made that one unit unmonitorable no
+  // matter what a backend did.
+  testSync("an announcement made before any backend is registered reaches the first one", () => {
+    let recorded: array<(Monitoring.unitKind, string, option<string>)> = []
+    module Late: Monitoring.Backend = {
+      let onProvisioned = (~kind, ~name, ~component as _, ~plugin, ~platform as _, ~logLocator as _) =>
+        recorded->Array.push((kind, name, plugin))
+    }
+
+    // Provisioned at import time, inside a construct scope that is long gone by the time
+    // anyone registers — so the owner must be captured now, not at delivery.
+    let prev = ResourceAttribution.enter(~platform="online-shop", ~plugin="Ordering")
+    Monitoring.notify(~kind=DeadLetterSink, ~name="DeadLetterQueue", ~component=stubResource)
+    ResourceAttribution.restore(prev)
+    Monitoring.notify(~kind=Scheduler, ~name="Heartbeat", ~component=stubResource)
+
+    expect(recorded)->toEqual([])
+
+    Monitoring.use(module(Late: Monitoring.Backend))
+
+    expect(recorded)->toEqual([
+      (Monitoring.DeadLetterSink, "DeadLetterQueue", Some("Ordering")),
+      (Monitoring.Scheduler, "Heartbeat", None),
+    ])
+
+    // Drained: a second registration does not receive them again.
+    let second: array<string> = []
+    module Other: Monitoring.Backend = {
+      let onProvisioned = (~kind as _, ~name, ~component as _, ~plugin as _, ~platform as _, ~logLocator as _) =>
+        second->Array.push(name)
+    }
+    Monitoring.use(module(Other: Monitoring.Backend))
+    expect(second)->toEqual([])
+
+    Monitoring.reset()
   })
 
   testSync("use registers a backend that receives every notify, role and name", () => {
@@ -32,8 +71,8 @@ describe("Monitoring", () => {
       (Monitoring.Other("Counter"), "ProductCounter"),
     ])
 
-    // Restore the default so registry state doesn't leak to other cases.
-    Monitoring.use(module(Monitoring.Noop))
+    // Restore the initial state so registry and buffer don't leak to other cases.
+    Monitoring.reset()
   })
 
   testSync("notify forwards the static name and component resource to the backend", () => {
@@ -50,7 +89,7 @@ describe("Monitoring", () => {
     | None => expect("no notify received")->toBe("a notify")
     }
 
-    Monitoring.use(module(Monitoring.Noop))
+    Monitoring.reset()
   })
 
   testSync("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
@@ -78,7 +117,7 @@ describe("Monitoring", () => {
       (None, None),
     ])
 
-    Monitoring.use(module(Monitoring.Noop))
+    Monitoring.reset()
   })
 
   // Unlike the owner, the locator is not ambient — the seam only forwards what the provisioning
@@ -105,6 +144,6 @@ describe("Monitoring", () => {
 
     expect(seen)->toEqual([true, false])
 
-    Monitoring.use(module(Monitoring.Noop))
+    Monitoring.reset()
   })
 })

package/tests/adapter/MonitoringTest.res.mjs

@@ -7,9 +7,51 @@ import * as ResourceAttribution$ReventlessCore from "../../src/ResourceAttributi
 let stubResource = {};
 
 globalThis.describe("Monitoring", () => {
-  globalThis.test("Noop default: notify is silent and does not throw", () => {
+  globalThis.test("no backend registered: notify is silent and does not throw", () => {
     Monitoring$ReventlessCore.notify("CommandHandler", "before", stubResource, undefined);
     globalThis.expect(true).toBe(true);
+    Monitoring$ReventlessCore.reset();
+  });
+  globalThis.test("an announcement made before any backend is registered reaches the first one", () => {
+    let recorded = [];
+    let onProvisioned = (kind, name, param, plugin, param$1, param$2) => {
+      recorded.push([
+        kind,
+        name,
+        plugin
+      ]);
+    };
+    let Late = {
+      onProvisioned: onProvisioned
+    };
+    let prev = ResourceAttribution$ReventlessCore.enter("online-shop", "Ordering");
+    Monitoring$ReventlessCore.notify("DeadLetterSink", "DeadLetterQueue", stubResource, undefined);
+    ResourceAttribution$ReventlessCore.restore(prev);
+    Monitoring$ReventlessCore.notify("Scheduler", "Heartbeat", stubResource, undefined);
+    globalThis.expect(recorded).toEqual([]);
+    Monitoring$ReventlessCore.use(Late);
+    globalThis.expect(recorded).toEqual([
+      [
+        "DeadLetterSink",
+        "DeadLetterQueue",
+        "Ordering"
+      ],
+      [
+        "Scheduler",
+        "Heartbeat",
+        undefined
+      ]
+    ]);
+    let second = [];
+    let onProvisioned$1 = (param, name, param$1, param$2, param$3, param$4) => {
+      second.push(name);
+    };
+    let Other = {
+      onProvisioned: onProvisioned$1
+    };
+    Monitoring$ReventlessCore.use(Other);
+    globalThis.expect(second).toEqual([]);
+    Monitoring$ReventlessCore.reset();
   });
   globalThis.test("use registers a backend that receives every notify, role and name", () => {
     let recorded = [];
@@ -51,7 +93,7 @@ globalThis.describe("Monitoring", () => {
         "ProductCounter"
       ]
     ]);
-    Monitoring$ReventlessCore.use(Monitoring$ReventlessCore.Noop);
+    Monitoring$ReventlessCore.reset();
   });
   globalThis.test("notify forwards the static name and component resource to the backend", () => {
     let seen = {
@@ -74,7 +116,7 @@ globalThis.describe("Monitoring", () => {
     } else {
       globalThis.expect("no notify received").toBe("a notify");
     }
-    Monitoring$ReventlessCore.use(Monitoring$ReventlessCore.Noop);
+    Monitoring$ReventlessCore.reset();
   });
   globalThis.test("notify delivers the ambient plugin/platform inside a construct scope, None outside", () => {
     let seen = [];
@@ -107,7 +149,7 @@ globalThis.describe("Monitoring", () => {
         undefined
       ]
     ]);
-    Monitoring$ReventlessCore.use(Monitoring$ReventlessCore.Noop);
+    Monitoring$ReventlessCore.reset();
   });
   globalThis.test("notify forwards the log locator when given one, None when omitted", () => {
     let stubLocator = {};
@@ -125,7 +167,7 @@ globalThis.describe("Monitoring", () => {
       true,
       false
     ]);
-    Monitoring$ReventlessCore.use(Monitoring$ReventlessCore.Noop);
+    Monitoring$ReventlessCore.reset();
   });
 });
 

package/tests/admin/AdminApiSchemaDriftTest.res

@@ -71,6 +71,7 @@ let cmd: commandDef = {
   references: [fieldRef],
   allowedStates: Some(["Draft"]),
   targetState: Some("Active"),
+  allowedStatesSource: "declared",
   apiExposed: Some(true),
   requiredAccess: Some(["catalog.write"]),
   ownerField: Some("ownerId"),

package/tests/admin/AdminApiSchemaDriftTest.res.mjs

@@ -61,6 +61,8 @@ let cmd_allowedStates = ["Draft"];
 
 let cmd_targetState = "Active";
 
+let cmd_allowedStatesSource = "declared";
+
 let cmd_apiExposed = true;
 
 let cmd_requiredAccess = ["catalog.write"];
@@ -76,6 +78,7 @@ let cmd = {
   references: cmd_references,
   allowedStates: cmd_allowedStates,
   targetState: cmd_targetState,
+  allowedStatesSource: cmd_allowedStatesSource,
   apiExposed: cmd_apiExposed,
   requiredAccess: cmd_requiredAccess,
   ownerField: cmd_ownerField

package/tests/admin/Platform_Admin_StructureTest.res.mjs

@@ -63,21 +63,9 @@ globalThis.describe("the admin structure's declared transitions are checked", ()
     globalThis.expect(raises([Platform_Admin_Structure$ReventlessCore.pluginAggregate])).toEqual(false);
   });
   globalThis.test("and a state the view does not declare is caught", () => {
-    let init = commandNamed("Activate");
+    let newrecord = {...commandNamed("Activate")};
     let bogus_name = Platform_Admin_Structure$ReventlessCore.pluginAggregate.name;
-    let bogus_commands = [{
-        name: init.name,
-        schema: init.schema,
-        level: init.level,
-        aggregateIdField: init.aggregateIdField,
-        mutationField: init.mutationField,
-        references: init.references,
-        allowedStates: init.allowedStates,
-        targetState: "Conected",
-        apiExposed: init.apiExposed,
-        requiredAccess: init.requiredAccess,
-        ownerField: init.ownerField
-      }];
+    let bogus_commands = [(newrecord.targetState = "Conected", newrecord)];
     let bogus_producedEventTypes = Platform_Admin_Structure$ReventlessCore.pluginAggregate.producedEventTypes;
     let bogus_consumedEventTypes = Platform_Admin_Structure$ReventlessCore.pluginAggregate.consumedEventTypes;
     let bogus_linkedViews = Platform_Admin_Structure$ReventlessCore.pluginAggregate.linkedViews;

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -355,6 +355,7 @@ describe("allowedStates + lifecycleField populated", () => {
     references: [],
     allowedStates: Some(["Inactive"]),
     targetState: Some("Active"),
+    allowedStatesSource: "declared",
     apiExposed: Some(true),
     requiredAccess: None,
       ownerField: None,

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -410,6 +410,7 @@ globalThis.describe("allowedStates + lifecycleField populated", () => {
   let cmdWithStates_references = [];
   let cmdWithStates_allowedStates = ["Inactive"];
   let cmdWithStates_targetState = "Active";
+  let cmdWithStates_allowedStatesSource = "declared";
   let cmdWithStates_apiExposed = true;
   let cmdWithStates = {
     name: "Activate",
@@ -420,6 +421,7 @@ globalThis.describe("allowedStates + lifecycleField populated", () => {
     references: cmdWithStates_references,
     allowedStates: cmdWithStates_allowedStates,
     targetState: cmdWithStates_targetState,
+    allowedStatesSource: cmdWithStates_allowedStatesSource,
     apiExposed: cmdWithStates_apiExposed,
     requiredAccess: undefined,
     ownerField: undefined

package/tests/admin/Platform_PluginStructuresApiTest.res

@@ -187,29 +187,23 @@ describe("absent optional collections", () => {
   // The case the frozen corpus cannot reach: every fixture in it carries
   // `"outboundTranslationSlices":[]`, so no stored payload has an outbound slice
   // to be missing a field. A structure written before `consumedSources` existed
-  // has no such key, and the schema alone refuses it — `S.nullAsOption` is
-  // `T | null`, and the variant that also accepts `undefined` fails sury's
-  // jsonable validation inside a union payload, which is where a structure
-  // travels. `parseJsonTolerant` is what makes the absence survivable, and it is
-  // the path the Plugin aggregate replays through.
+  // has no such key. `parseJsonTolerant` is what makes the absence survivable,
+  // and it is the path the Plugin aggregate replays through.
   testSync("an outbound slice stored before consumedSources existed still replays", () =>
     expect(
-      (
-        `{"name":"ToShipper","consumedEventTypes":[],"inboundCommandTypes":[],` ++
-        `"targetName":null,"externalSystem":null,"chapter":null}`
-      )
+      `{"name":"ToShipper","consumedEventTypes":[],"inboundCommandTypes":[]}`
       ->JSON.parseOrThrow
       ->Reventless.Message.parseJsonTolerant(outboundTranslationSliceDefSchema)
       ->(slice => slice.consumedSources),
     )->toEqual(None)
   )
 
-  testSync("an explicit null decodes as None", () =>
+  // Absent needs no healer: an omitted key IS the optional encoding, so strict
+  // decode takes it. `parseJsonTolerant` above is for the fields a stale payload
+  // is missing that are NOT optional.
+  testSync("an omitted optional decodes as None on the strict path", () =>
     expect(
-      (
-        `{"name":"ToShipper","consumedEventTypes":[],"inboundCommandTypes":[],` ++
-        `"targetName":null,"externalSystem":null,"chapter":null,"consumedSources":null}`
-      )
+      `{"name":"ToShipper","consumedEventTypes":[],"inboundCommandTypes":[]}`
       ->JSON.parseOrThrow
       ->Reventless.Util_Sury.fromJson(outboundTranslationSliceDefSchema)
       ->(slice => slice.consumedSources),

package/tests/admin/Platform_PluginStructuresApiTest.res.mjs

@@ -241,10 +241,10 @@ globalThis.describe("absent optional collections", () => {
     globalThis.expect(bareJson.includes("\"requiredStores\":null")).toEqual(true);
   });
   globalThis.test("an outbound slice stored before consumedSources existed still replays", () => {
-    globalThis.expect(Message$Reventless.parseJsonTolerant(JSON.parse(`{"name":"ToShipper","consumedEventTypes":[],"inboundCommandTypes":[],"targetName":null,"externalSystem":null,"chapter":null}`), Plugin$Reventless.outboundTranslationSliceDefSchema).consumedSources).toEqual(undefined);
+    globalThis.expect(Message$Reventless.parseJsonTolerant(JSON.parse(`{"name":"ToShipper","consumedEventTypes":[],"inboundCommandTypes":[]}`), Plugin$Reventless.outboundTranslationSliceDefSchema).consumedSources).toEqual(undefined);
   });
-  globalThis.test("an explicit null decodes as None", () => {
-    globalThis.expect(Util_Sury$Reventless.fromJson(JSON.parse(`{"name":"ToShipper","consumedEventTypes":[],"inboundCommandTypes":[],"targetName":null,"externalSystem":null,"chapter":null,"consumedSources":null}`), Plugin$Reventless.outboundTranslationSliceDefSchema).consumedSources).toEqual(undefined);
+  globalThis.test("an omitted optional decodes as None on the strict path", () => {
+    globalThis.expect(Util_Sury$Reventless.fromJson(JSON.parse(`{"name":"ToShipper","consumedEventTypes":[],"inboundCommandTypes":[]}`), Plugin$Reventless.outboundTranslationSliceDefSchema).consumedSources).toEqual(undefined);
   });
 });
 

package/tests/aggregate/AggregateCacheTest.res.mjs

@@ -38,7 +38,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/tests/aggregate/AggregateConflictTest.res.mjs

@@ -27,7 +27,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/tests/aggregate/AggregateFixtures.res.mjs

@@ -41,7 +41,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/tests/aggregate/AggregateSnapshotTest.res.mjs

@@ -33,7 +33,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/tests/api/GraphQL_FragmentGeneratorTest.res

@@ -357,11 +357,13 @@ describe("GraphQL_FragmentGenerator.mutationArgTypes", () => {
     expect((typeOf("tip"), typeOf("total")))->toEqual((Some("MoneyInput"), Some("MoneyInput!")))
   )
 
-  // Both of these differ from what the JSON-Schema type alone suggests —
-  // `orderId` is a plain string there and `itemCount` an integer — which is the
-  // narrower reason a client cannot derive even the scalars itself.
+  // `orderId` differs from what the JSON-Schema type alone suggests — a plain
+  // string there, an `ID!` here — which is the narrower reason a client cannot
+  // derive even the scalars itself. `itemCount` is an `Int!` on both sides: sury
+  // carries the whole-number format and the walk now keeps it, so a quantity is
+  // no longer a field a client could legally send `2.5` in.
   testSync("reports the scalar the server chose, not the JSON-Schema one", () =>
-    expect((typeOf("orderId"), typeOf("itemCount")))->toEqual((Some("ID!"), Some("Float!")))
+    expect((typeOf("orderId"), typeOf("itemCount")))->toEqual((Some("ID!"), Some("Int!")))
   )
 
   // The property that makes publishing worth more than re-deriving downstream: