@reventlessdev/reventless-core 3.0.0-alpha.238 → 3.0.0-alpha.240

package/tests/admin/Platform_Admin_StructureTest.res

@@ -15,6 +15,17 @@
 open JestGlobals
 open Reventless.Plugin
 
+// The commands are derived from `PluginSpec.command` rather than hand-written, so
+// a test names one by looking it up. Raises rather than defaulting: a missing
+// variant is the failure these tests exist to catch, and a placeholder would let
+// the assertions below pass against nothing.
+let commandNamed = (name: string): commandDef =>
+  Platform_Admin_Structure.pluginCommands
+  ->Array.find(c => c.name == name)
+  ->Option.getOrThrow(~message=`Platform_Admin_Structure publishes no "${name}" command`)
+
+let activate = () => commandNamed("Activate")
+
 describe("the Plugins read model declares its lifecycle", () => {
   let rm: queryableDef = Platform_Admin_Structure.pluginReadModel
 
@@ -47,3 +58,246 @@ describe("the Plugins read model declares its lifecycle", () => {
     )->toEqual(false)
   )
 })
+
+// `Plugin_Structure.make` never sees the platform's own components, so the checks it
+// runs over every ordinary plugin do not run here. A test rather than a startup call:
+// both sides are compile-time constants in this package, so nothing varies at runtime.
+describe("the admin structure's declared transitions are checked", () => {
+  let states = Plugin_Structure.lifecycleStatesFromStateSchema(
+    ~entityName=PluginsReadModelSpec.name,
+    PluginsReadModelSpec.stateSchema->S.castToUnknown,
+  )
+
+  let statesByView = () => {
+    let d = Dict.make()
+    states->Option.forEach(s => d->Dict.set(PluginsReadModelSpec.name, s))
+    d
+  }
+
+  let raises = writables =>
+    switch Plugin_Structure.checkDeclaredTransitions(
+      ~pluginName="Platform",
+      ~writables,
+      ~lifecycleStatesByView=statesByView(),
+    ) {
+    | () => false
+    | exception _ => true
+    }
+
+  // The precondition the rest of the block is worthless without: with no states the
+  // check counts the commands as unvalidated and passes.
+  testSync("the linked view yields its lifecycle states", () =>
+    expect(states)->toEqual(Some(["Connected", "Disconnected", "Inactive", "Retired"]))
+  )
+
+  testSync("every state the Plugin commands name is one the view declares", () =>
+    expect(raises([Platform_Admin_Structure.pluginAggregate]))->toEqual(false)
+  )
+
+  // A check that cannot fail is indistinguishable from one that is not running.
+  testSync("and a state the view does not declare is caught", () => {
+    let bogus: Reventless.Plugin.writableDef = {
+      ...Platform_Admin_Structure.pluginAggregate,
+      commands: [
+        {
+          ...activate(),
+          targetState: Some("Conected"),
+        },
+      ],
+    }
+    expect(raises([bogus]))->toEqual(true)
+  })
+})
+
+// The drift that made deriving these defs worth doing rather than tidy. The
+// hand-written arg schema described only `id`, while the SDL generated off the
+// same `commandSchema` declares `Platform_Plugin_Activate(_0: String!, id: ID!)`.
+// AutoUI builds its mutation document from the published schema, so it sent a
+// document missing a required argument and every admin row action was rejected at
+// GraphQL validation, before the aggregate saw it.
+describe("the Plugin command defs carry every argument the SDL requires", () => {
+  testSync("the version argument is published", () =>
+    expect(activate().schema->String.includes(`"_0"`))->toEqual(true)
+  )
+
+  testSync("and so is the aggregate id", () => {
+    // `id` is not in the command schema — it is the aggregate instance, injected
+    // by the auto-resolver flow. What the def has to get right is naming it, so
+    // the consumer declares the variable rather than guessing.
+    expect(activate().aggregateIdField)->toEqual(None)
+  })
+
+  testSync("the exposed commands name the field PluginBaseFragment generates", () =>
+    expect(
+      Platform_Admin_Structure.pluginCommands
+      ->Array.filter(c => c.apiExposed != Some(false))
+      ->Array.map(c => c.mutationField),
+    )->toEqual([
+      "Platform_Plugin_Activate",
+      "Platform_Plugin_Deactivate",
+      "Platform_Plugin_Retire",
+    ])
+  )
+
+  // The `@noApi` protocol variants come back from the same walk. They belong on
+  // the event graph — `Disconnect` is the only edge into `Disconnected` — but
+  // `Connect` carries a whole plugin definition, so publishing metadata about
+  // them must not publish a way to call them.
+  testSync("the internal commands are published as uncallable", () => {
+    let internal =
+      Platform_Admin_Structure.pluginCommands->Array.filter(c => c.apiExposed == Some(false))
+    expect(internal->Array.map(c => c.name))->toEqual([
+      "Connect",
+      "ReportIncompatibility",
+      "Heartbeat",
+      "Redetect",
+      "Disconnect",
+    ])
+    expect(internal->Array.every(c => c.mutationField == ""))->toEqual(true)
+  })
+})
+
+// A heartbeat timing out is the only way a row reaches `Disconnected`, and the
+// command that does it carries `@noApi`. Until it declared its edge the topology
+// check reported the state unreachable and was right to: nothing in the
+// declarations said how a row got there.
+describe("the internal commands declare the edges they move rows along", () => {
+  let states = Plugin_Structure.lifecycleStatesFromStateSchema(
+    ~entityName=PluginsReadModelSpec.name,
+    PluginsReadModelSpec.stateSchema->S.castToUnknown,
+  )
+
+  let statesByView = () => {
+    let d = Dict.make()
+    states->Option.forEach(s => d->Dict.set(PluginsReadModelSpec.name, s))
+    d
+  }
+
+  testSync("the only edge into Disconnected is declared", () =>
+    expect((commandNamed("Disconnect").allowedStates, commandNamed("Disconnect").targetState))
+    ->toEqual((Some(["Connected"]), Some("Disconnected")))
+  )
+
+  // The creating form's claim: a target and no from-set. `Connect` brings the
+  // version's row into being, so there is no state it runs from — and an empty
+  // `allowedStates` would say the opposite, that it is legal in none.
+  testSync("the handshake declares a target and no from-set", () =>
+    expect((commandNamed("Connect").allowedStates, commandNamed("Connect").targetState))
+    ->toEqual((None, Some("Connected")))
+  )
+
+  testSync("and no state is left unreachable", () =>
+    expect(
+      Plugin_Structure.lifecycleTopologyFindings(
+        ~writables=[Platform_Admin_Structure.pluginAggregate],
+        ~lifecycleStatesByView=statesByView(),
+      ),
+    )->toEqual([])
+  )
+})
+
+// One rule, read on both sides of the wire. `PluginBaseFragment` hand-wrote an
+// `Admin` Cognito gate while the spec defaulted to `AllowAuthenticated`, and the
+// published `requiredAccess` said `None` — so a shell was told the Plugins view
+// was open to everyone and the server refused anyone outside `Admin`. The
+// mismatch is invisible until a non-admin clicks the page.
+describe("the Plugins view publishes the rule the server enforces", () => {
+  testSync("the spec declares the group", () =>
+    expect(PluginsReadModelSpec.authorization)->toEqual(
+      Reventless.Authorization.AllowGroups(["Admin"]),
+    )
+  )
+
+  testSync("and the published access keys are derived from it", () =>
+    expect(Platform_Admin_Structure.pluginReadModel.requiredAccess)->toEqual(Some(["Admin"]))
+  )
+
+  // The API entry reads the same binding rather than restating it, so the two
+  // cannot be edited apart.
+  testSync("the query entry carries the spec's rule and no hand-written pair", () => {
+    let entry = PluginBaseFragment.queryEntries->Array.getUnsafe(0)
+    expect((entry.permission, entry.authorization))->toEqual((
+      Some(PluginsReadModelSpec.authorization),
+      None,
+    ))
+  })
+})
+
+// The `queryableDef` is derived from the spec, not hand-written. The analysis
+// that preceded this expected the admin's naming to be bespoke and it is not:
+// `Api_Naming.queryFieldNamesForReadModel` returns byte-identical names, because
+// `singularize` already handles the plural-spec-name / singular-type shape that
+// looked special. Asserted rather than assumed — the whole case for deriving
+// rests on the generic helpers reaching the same answers.
+describe("the Plugins queryableDef is what the generic helpers produce", () => {
+  let rm: queryableDef = Platform_Admin_Structure.pluginReadModel
+
+  testSync("the field names are the generic ones", () =>
+    expect((rm.queryField, rm.singleQueryField))->toEqual((
+      "Platform_Plugins",
+      Some("Platform_Plugin"),
+    ))
+  )
+
+  testSync("the label ladder reaches the same field, by convention", () =>
+    expect((rm.labelField, rm.labelFieldSource, rm.searchableFields))->toEqual((
+      "name",
+      Some("convention"),
+      ["name"],
+    ))
+  )
+
+  // The row id is `name@version` and the state carries the two halves
+  // separately, never the composed key — so `None` is the honest answer, and it
+  // is the one the resolver ladder reaches on its own.
+  testSync("the key ladder finds no id field, as the hand-written def claimed", () =>
+    expect((rm.idField, rm.idFieldSource))->toEqual((None, None))
+  )
+
+  // `apiSchemaFragment` and `structure` are on the API — the shell fetches them
+  // through dedicated resolver paths — but each is a multi-kilobyte JSON blob
+  // that a generated list view must not name. They used to be cut out of the
+  // published schema by a hand-written list; they now carry `@hidden`, so they
+  // are described and the consumer decides.
+  //
+  // This is the difference between the two markers, asserted side by side: a
+  // `@hidden` field is present and flagged, an `@internal` one is not there at
+  // all. Cutting a hidden field out here would leave a consumer unable to tell
+  // "not for you" from "does not exist".
+  testSync("the blob fields are published, and marked hidden", () => {
+    // Read as property NAMES, not as substrings of the JSON: the schema carries
+    // nested object types whose own fields would match a naive `includes`.
+    let props =
+      rm.schema
+      ->JSON.parseExn
+      ->JSON.Decode.object
+      ->Option.flatMap(o => o->Dict.get("properties"))
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.getOr(Dict.make())
+    let isHidden = key =>
+      props
+      ->Dict.get(key)
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.flatMap(o => o->Dict.get("x-reventless-hidden"))
+      ->Option.flatMap(JSON.Decode.bool)
+    expect((isHidden("apiSchemaFragment"), isHidden("structure")))->toEqual((
+      Some(true),
+      Some(true),
+    ))
+  })
+
+  testSync("while the internal fields are not published at all", () => {
+    let props =
+      rm.schema
+      ->JSON.parseExn
+      ->JSON.Decode.object
+      ->Option.flatMap(o => o->Dict.get("properties"))
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.mapOr([], Dict.keysToArray)
+    expect((
+      props->Array.includes("eventCollector"),
+      props->Array.includes("extensionNames"),
+      props->Array.includes("statusChange"),
+    ))->toEqual((false, false, true))
+  })
+})

package/tests/admin/Platform_Admin_StructureTest.res.mjs

@@ -1,9 +1,22 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
+import * as PluginBaseFragment$ReventlessCore from "../../src/plugin/api/PluginBaseFragment.res.mjs";
+import * as PluginsReadModelSpec$ReventlessCore from "../../src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
 import * as Platform_Admin_Structure$ReventlessCore from "../../src/admin/Platform_Admin_Structure.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "../../src/admin/Platform_ComponentDefinitionsApi.res.mjs";
 
+function commandNamed(name) {
+  return Stdlib_Option.getOrThrow(Platform_Admin_Structure$ReventlessCore.pluginCommands.find(c => c.name === name), `Platform_Admin_Structure publishes no "` + name + `" command`);
+}
+
+function activate() {
+  return commandNamed("Activate");
+}
+
 globalThis.describe("the Plugins read model declares its lifecycle", () => {
   globalThis.test("names the field commands branch on", () => {
     globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel.lifecycleField).toEqual("status");
@@ -21,4 +34,210 @@ globalThis.describe("the Plugins read model declares its lifecycle", () => {
   });
 });
 
+globalThis.describe("the admin structure's declared transitions are checked", () => {
+  let states = Plugin_Structure$ReventlessCore.lifecycleStatesFromStateSchema(PluginsReadModelSpec$ReventlessCore.name, PluginsReadModelSpec$ReventlessCore.stateSchema);
+  let statesByView = () => {
+    let d = {};
+    Stdlib_Option.forEach(states, s => {
+      d[PluginsReadModelSpec$ReventlessCore.name] = s;
+    });
+    return d;
+  };
+  let raises = writables => {
+    try {
+      Plugin_Structure$ReventlessCore.checkDeclaredTransitions("Platform", writables, statesByView());
+      return false;
+    } catch (exn) {
+      return true;
+    }
+  };
+  globalThis.test("the linked view yields its lifecycle states", () => {
+    globalThis.expect(states).toEqual([
+      "Connected",
+      "Disconnected",
+      "Inactive",
+      "Retired"
+    ]);
+  });
+  globalThis.test("every state the Plugin commands name is one the view declares", () => {
+    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 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_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;
+    let bogus_consistencyRead = Platform_Admin_Structure$ReventlessCore.pluginAggregate.consistencyRead;
+    let bogus_events = Platform_Admin_Structure$ReventlessCore.pluginAggregate.events;
+    let bogus_errors = Platform_Admin_Structure$ReventlessCore.pluginAggregate.errors;
+    let bogus_chapter = Platform_Admin_Structure$ReventlessCore.pluginAggregate.chapter;
+    let bogus = {
+      name: bogus_name,
+      commands: bogus_commands,
+      producedEventTypes: bogus_producedEventTypes,
+      consumedEventTypes: bogus_consumedEventTypes,
+      linkedViews: bogus_linkedViews,
+      consistencyRead: bogus_consistencyRead,
+      events: bogus_events,
+      errors: bogus_errors,
+      chapter: bogus_chapter
+    };
+    globalThis.expect(raises([bogus])).toEqual(true);
+  });
+});
+
+globalThis.describe("the Plugin command defs carry every argument the SDL requires", () => {
+  globalThis.test("the version argument is published", () => {
+    globalThis.expect(commandNamed("Activate").schema.includes(`"_0"`)).toEqual(true);
+  });
+  globalThis.test("and so is the aggregate id", () => {
+    globalThis.expect(commandNamed("Activate").aggregateIdField).toEqual(undefined);
+  });
+  globalThis.test("the exposed commands name the field PluginBaseFragment generates", () => {
+    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginCommands.filter(c => Primitive_object.notequal(c.apiExposed, false)).map(c => c.mutationField)).toEqual([
+      "Platform_Plugin_Activate",
+      "Platform_Plugin_Deactivate",
+      "Platform_Plugin_Retire"
+    ]);
+  });
+  globalThis.test("the internal commands are published as uncallable", () => {
+    let internal = Platform_Admin_Structure$ReventlessCore.pluginCommands.filter(c => Primitive_object.equal(c.apiExposed, false));
+    globalThis.expect(internal.map(c => c.name)).toEqual([
+      "Connect",
+      "ReportIncompatibility",
+      "Heartbeat",
+      "Redetect",
+      "Disconnect"
+    ]);
+    globalThis.expect(internal.every(c => c.mutationField === "")).toEqual(true);
+  });
+});
+
+globalThis.describe("the internal commands declare the edges they move rows along", () => {
+  let states = Plugin_Structure$ReventlessCore.lifecycleStatesFromStateSchema(PluginsReadModelSpec$ReventlessCore.name, PluginsReadModelSpec$ReventlessCore.stateSchema);
+  let statesByView = () => {
+    let d = {};
+    Stdlib_Option.forEach(states, s => {
+      d[PluginsReadModelSpec$ReventlessCore.name] = s;
+    });
+    return d;
+  };
+  globalThis.test("the only edge into Disconnected is declared", () => {
+    globalThis.expect([
+      commandNamed("Disconnect").allowedStates,
+      commandNamed("Disconnect").targetState
+    ]).toEqual([
+      ["Connected"],
+      "Disconnected"
+    ]);
+  });
+  globalThis.test("the handshake declares a target and no from-set", () => {
+    globalThis.expect([
+      commandNamed("Connect").allowedStates,
+      commandNamed("Connect").targetState
+    ]).toEqual([
+      undefined,
+      "Connected"
+    ]);
+  });
+  globalThis.test("and no state is left unreachable", () => {
+    globalThis.expect(Plugin_Structure$ReventlessCore.lifecycleTopologyFindings([Platform_Admin_Structure$ReventlessCore.pluginAggregate], statesByView())).toEqual([]);
+  });
+});
+
+globalThis.describe("the Plugins view publishes the rule the server enforces", () => {
+  globalThis.test("the spec declares the group", () => {
+    globalThis.expect(PluginsReadModelSpec$ReventlessCore.authorization).toEqual({
+      TAG: "AllowGroups",
+      _0: ["Admin"]
+    });
+  });
+  globalThis.test("and the published access keys are derived from it", () => {
+    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel.requiredAccess).toEqual(["Admin"]);
+  });
+  globalThis.test("the query entry carries the spec's rule and no hand-written pair", () => {
+    let entry = PluginBaseFragment$ReventlessCore.queryEntries[0];
+    globalThis.expect([
+      entry.permission,
+      entry.authorization
+    ]).toEqual([
+      PluginsReadModelSpec$ReventlessCore.authorization,
+      undefined
+    ]);
+  });
+});
+
+globalThis.describe("the Plugins queryableDef is what the generic helpers produce", () => {
+  globalThis.test("the field names are the generic ones", () => {
+    globalThis.expect([
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.queryField,
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.singleQueryField
+    ]).toEqual([
+      "Platform_Plugins",
+      "Platform_Plugin"
+    ]);
+  });
+  globalThis.test("the label ladder reaches the same field, by convention", () => {
+    globalThis.expect([
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.labelField,
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.labelFieldSource,
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.searchableFields
+    ]).toEqual([
+      "name",
+      "convention",
+      ["name"]
+    ]);
+  });
+  globalThis.test("the key ladder finds no id field, as the hand-written def claimed", () => {
+    globalThis.expect([
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.idField,
+      Platform_Admin_Structure$ReventlessCore.pluginReadModel.idFieldSource
+    ]).toEqual([
+      undefined,
+      undefined
+    ]);
+  });
+  globalThis.test("the blob fields are published, and marked hidden", () => {
+    let props = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Platform_Admin_Structure$ReventlessCore.pluginReadModel.schema)), o => o["properties"]), Stdlib_JSON.Decode.object), {});
+    let isHidden = key => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(props[key], Stdlib_JSON.Decode.object), o => o["x-reventless-hidden"]), Stdlib_JSON.Decode.bool);
+    globalThis.expect([
+      isHidden("apiSchemaFragment"),
+      isHidden("structure")
+    ]).toEqual([
+      true,
+      true
+    ]);
+  });
+  globalThis.test("while the internal fields are not published at all", () => {
+    let props = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Platform_Admin_Structure$ReventlessCore.pluginReadModel.schema)), o => o["properties"]), Stdlib_JSON.Decode.object), [], prim => Object.keys(prim));
+    globalThis.expect([
+      props.includes("eventCollector"),
+      props.includes("extensionNames"),
+      props.includes("statusChange")
+    ]).toEqual([
+      false,
+      false,
+      true
+    ]);
+  });
+});
+
+export {
+  commandNamed,
+  activate,
+}
 /*  Not a pure module */

package/tests/admin/Platform_BakedManifestTest.res

@@ -25,6 +25,7 @@ let queryable = (~name, ~visibility=?, ~ownerField=?, ()): queryableDef => {
   ownerField,
   retiredField: None,
   retiredValues: None,
+  namedWhenRetired: None,
 }
 
 let command = (~name, ~references=[], ~ownerField=?, ()): commandDef => {

package/tests/admin/Platform_BakedManifestTest.res.mjs

@@ -22,6 +22,7 @@ function queryable(name, visibility, ownerField, param) {
     ownerField: ownerField,
     retiredField: undefined,
     retiredValues: undefined,
+    namedWhenRetired: undefined,
     visibility: visibility,
     chapter: undefined,
     singleQueryField: `Ordering_` + name + `Single`,

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -40,6 +40,7 @@ let qbl: queryableDef = {
   ownerField: None,
   retiredField: None,
   retiredValues: None,
+  namedWhenRetired: None,
 }
 
 let wbl: writableDef = {
@@ -268,6 +269,7 @@ describe("visibility filtering (deployed AutoUI hides Internal)", () => {
       ownerField: None,
       retiredField: None,
       retiredValues: None,
+      namedWhenRetired: None,
   }
   // A distinct name per source array: the complement has to be fed by both, and
   // reusing one def would hide a version that only walks `readModels`.
@@ -367,6 +369,7 @@ describe("allowedStates + lifecycleField populated", () => {
       ownerField: None,
       retiredField: None,
       retiredValues: None,
+      namedWhenRetired: None,
   }
 
   let wblWithStates: writableDef = {

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -55,6 +55,7 @@ let qbl = {
   ownerField: undefined,
   retiredField: undefined,
   retiredValues: undefined,
+  namedWhenRetired: undefined,
   visibility: undefined,
   chapter: undefined,
   singleQueryField: qbl_singleQueryField,
@@ -288,6 +289,7 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
     ownerField: undefined,
     retiredField: undefined,
     retiredValues: undefined,
+    namedWhenRetired: undefined,
     visibility: internalQbl_visibility,
     chapter: undefined,
     singleQueryField: internalQbl_singleQueryField,
@@ -316,6 +318,7 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
     ownerField: undefined,
     retiredField: undefined,
     retiredValues: undefined,
+    namedWhenRetired: undefined,
     visibility: internalSlice_visibility,
     chapter: undefined,
     singleQueryField: internalSlice_singleQueryField,
@@ -422,6 +425,7 @@ globalThis.describe("allowedStates + lifecycleField populated", () => {
     ownerField: undefined,
     retiredField: undefined,
     retiredValues: undefined,
+    namedWhenRetired: undefined,
     visibility: undefined,
     chapter: undefined,
     singleQueryField: qblWithStatus_singleQueryField,
@@ -503,6 +507,7 @@ globalThis.describe("singleQueryField reaches the caller", () => {
           ownerField: undefined,
           retiredField: undefined,
           retiredValues: undefined,
+          namedWhenRetired: undefined,
           visibility: undefined,
           chapter: undefined,
           singleQueryField: undefined,
@@ -550,6 +555,7 @@ globalThis.describe("idField / idFieldSource reach the caller", () => {
           ownerField: undefined,
           retiredField: undefined,
           retiredValues: undefined,
+          namedWhenRetired: undefined,
           visibility: undefined,
           chapter: undefined,
           singleQueryField: "Catalog_Product",

package/tests/admin/Platform_PluginStructuresApiTest.res

@@ -26,6 +26,7 @@ let publicRm: queryableDef = {
   ownerField: None,
   retiredField: None,
   retiredValues: None,
+  namedWhenRetired: None,
 }
 
 // The component `Platform_ComponentDefinitions` drops and this query must keep.

package/tests/admin/Platform_PluginStructuresApiTest.res.mjs

@@ -35,6 +35,7 @@ let publicRm = {
   ownerField: undefined,
   retiredField: undefined,
   retiredValues: undefined,
+  namedWhenRetired: undefined,
   visibility: undefined,
   chapter: publicRm_chapter,
   singleQueryField: publicRm_singleQueryField,
@@ -74,6 +75,7 @@ let internalRm = {
   ownerField: undefined,
   retiredField: undefined,
   retiredValues: undefined,
+  namedWhenRetired: undefined,
   visibility: internalRm_visibility,
   chapter: internalRm_chapter,
   singleQueryField: internalRm_singleQueryField,

package/tests/aggregate/AggregateCacheTest.res

@@ -12,7 +12,6 @@
 
 open JestGlobals
 
-S.enableJson()
 
 module AggSpec = {
   module Id = Reventless.Id.StringPure

package/tests/aggregate/AggregateCacheTest.res.mjs

@@ -1,37 +1,35 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Aggregate_Callback$ReventlessCore from "../../src/components/Aggregate/Aggregate_Callback.res.mjs";
 
-S.enableJson();
-
 let name = "CacheTestAggregate";
 
-let commandSchema = S.union([
-  S.schema(s => ({
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Add",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   })),
-  S.literal("Checkpoint"),
-  S.literal("Noop")
+  Sury.literal("Checkpoint"),
+  Sury.literal("Noop")
 ]);
 
-let eventSchema = S.union([
-  S.schema(s => ({
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "Added",
-    name: s.m(S.string)
+    name: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "CheckpointTaken",
-    count: s.m(S.int)
+    count: s.m(Sury.int)
   }))
 ]);
 
-let errorSchema = S.literal("Never");
+let errorSchema = Sury.literal("Never");
 
 let moduleUrl = import.meta.url;
 
@@ -430,4 +428,4 @@ export {
   makeTopicItem,
   run,
 }
-/*  Not a pure module */
+/* commandSchema Not a pure module */

package/tests/aggregate/AggregateConflictTest.res

@@ -3,7 +3,6 @@
 
 open JestGlobals
 
-S.enableJson()
 
 module AggSpec = {
   module Id = Reventless.Id.StringPure