@reventlessdev/reventless-core 3.0.0-alpha.285 → 3.0.0-alpha.286

package/src/plugin/component/Plugin_Structure.res

@@ -793,15 +793,32 @@ let commandLevelAndId = (
   }
 
 // The server's rule as keys a client checks against `identity.groups ++
-// config.accessTiers`; an any-of, since `isAllowed` is `some`. The rules asking
-// for nothing checkable — and `DenyAll` — publish no keys rather than an
+// config.accessTiers`; an any-of, since `isAllowed` is `some`. Mapped groups, not
+// role names: a key no token carries would gate the surface shut. The rules
+// asking for nothing checkable — and `DenyAll` — publish no keys rather than an
 // unsatisfiable one.
 let accessKeysFor = (rule: Reventless.Authorization.permission): option<array<string>> =>
-  switch rule {
-  | AllowGroups(groups) if groups->Array.length > 0 => Some(groups)
-  | AllowGroups(_) | AllowAuthenticated | AllowAnonymous | DenyAll => None
+  switch Reventless.Authorization.groupsOf(rule) {
+  | [] => None
+  | groups => Some(groups)
   }
 
+let nonEmpty = (xs: array<string>): option<array<string>> => xs->Array.length > 0 ? Some(xs) : None
+
+// The same rule's roles before mapping, which the deploy check compares with what
+// the platform provides.
+let rolesFor = (rule: Reventless.Authorization.permission): option<array<string>> =>
+  rule->Reventless.Authorization.rolesOf->Array.map(role => (role :> string))->nonEmpty
+
+// A stand-in for one constructor, the same shape the resolver builds at call time:
+// a payload-bearing variant compiles to `{TAG, ...}`, a payload-less one to a bare
+// string. Enough for the per-command switches the PPX generates, which match on
+// the constructor alone.
+let syntheticCommand = (~schema: S.t<unknown>, variantName: string): 'command =>
+  Reventless.DcbTag.isVariantPayloadBearing(schema, variantName)
+    ? {"TAG": variantName}->Obj.magic
+    : variantName->Obj.magic
+
 // Each mutation argument's GraphQL type onto its property, so a consumer declares
 // the variable the server expects. Mutates the freshly derived schema in place.
 let annotateArgTypes = (schema: JSON.t, argTypes: dict<string>): JSON.t => {
@@ -860,15 +877,8 @@ let toCommandDef = (
       ~variantName,
       properties,
     )
-    // Evaluated against a synthetic value per constructor, the same shape the
-    // resolver builds at call time: a payload-bearing variant compiles to
-    // `{TAG, ...}`, a payload-less one to a bare string.
-    let syntheticCommand: unknown = Reventless.DcbTag.isVariantPayloadBearing(
-      parentSchema,
-      variantName,
-    )
-      ? {"TAG": variantName}->Obj.magic
-      : variantName->Obj.magic
+    // Evaluated against a synthetic value per constructor; see `syntheticCommand`.
+    let syntheticCommand: unknown = syntheticCommand(~schema=parentSchema, variantName)
     // The spec's own switch, which is exhaustive — so it also speaks for a
     // constructor the host did not declare but spliced from a trait.
     //
@@ -937,7 +947,8 @@ let toCommandDef = (
       | Some(excluded) => !(excluded->Set.has(variantName))
       | None => true
       }
-    let requiredAccess = accessKeysFor(commandAuthorization(syntheticCommand))
+    let rule = commandAuthorization(syntheticCommand)
+    let requiredAccess = accessKeysFor(rule)
     // See the note on the record's `mutationField` for why a non-exposed
     // variant gets the empty sentinel. It has no callable field, and the
     // argument type names are composed *from* that field name, so there is
@@ -975,6 +986,7 @@ let toCommandDef = (
         ?allowedStatesSource,
         apiExposed: Some(apiExposed),
         requiredAccess,
+        requiredRoles: ?rolesFor(rule),
         // Resolved from this constructor's own properties, not the union's: two
         // commands in one slice can disagree about whether they record an owner,
         // and the write path stamps per constructor for the same reason.
@@ -1094,6 +1106,7 @@ let queryableDefFromSpec = (
     idField: keyField->Option.map(((f, _)) => f),
     idFieldSource: keyField->Option.map(((_, rung)) => rung),
     requiredAccess: accessKeysFor(authorization),
+    requiredRoles: ?rolesFor(authorization),
   }
 }
 
@@ -1550,7 +1563,8 @@ let make = (
         singleQueryField: Some(qf.singleFieldName),
         idField: keyField->Option.map(((f, _)) => f),
         idFieldSource: keyField->Option.map(((_, rung)) => rung),
-        requiredAccess: accessKeysFor(R.Spec.authorization),
+        requiredAccess: accessKeysFor(R.Spec.authorization->Reventless.Authorization.named),
+        requiredRoles: ?rolesFor(R.Spec.authorization->Reventless.Authorization.named),
       }: Reventless.Plugin.queryableDef
     )
   })
@@ -1590,7 +1604,8 @@ let make = (
           singleQueryField: Some(qf.singleFieldName),
           idField: keyField->Option.map(((f, _)) => f),
           idFieldSource: keyField->Option.map(((_, rung)) => rung),
-          requiredAccess: accessKeysFor(SVS.Spec.authorization),
+          requiredAccess: accessKeysFor(SVS.Spec.authorization->Reventless.Authorization.named),
+          requiredRoles: ?rolesFor(SVS.Spec.authorization->Reventless.Authorization.named),
         }: Reventless.Plugin.queryableDef
       )
     })
@@ -1690,7 +1705,8 @@ let make = (
                 ~commandSchema=SCS.Spec.commandSchema->S.castToUnknown,
                 ~variant=variantName,
               ),
-            ~commandAuthorization=SCS.Spec.commandAuthorization->Obj.magic,
+            ~commandAuthorization=command =>
+              SCS.Spec.commandAuthorization(command->Obj.magic)->Reventless.Authorization.named,
             ~commandTransition=SCS.Spec.commandTransition->Obj.magic,
             ~derivedEdgeFor=derivedEdgeFor(~component=SCS.Spec.name, ...),
             SCS.Spec.commandSchema->S.castToUnknown,
@@ -1724,7 +1740,8 @@ let make = (
               ~aggregate=A.Spec.name,
               ~command=variantName,
             ),
-          ~commandAuthorization=A.Spec.commandAuthorization->Obj.magic,
+          ~commandAuthorization=command =>
+            A.Spec.commandAuthorization(command->Obj.magic)->Reventless.Authorization.named,
           ~commandTransition=A.Spec.commandTransition->Obj.magic,
           ~derivedEdgeFor=derivedEdgeFor(~component=A.Spec.name, ...),
           A.Spec.commandSchema->S.castToUnknown,
@@ -1798,6 +1815,22 @@ let make = (
       targetName: ITS.Spec.targetName,
       externalSystem: ITS.Spec.externalSystem,
       chapter: chapterOf(ITS.Spec.name),
+      // Per command, as the resolver evaluates the rule, then joined: the slice
+      // publishes no command defs to carry them.
+      requiredRoles: ?(
+        Reventless.DcbTag.extractAllVariantNames(ITS.Spec.commandSchema)
+        ->Array.flatMap(variantName =>
+          syntheticCommand(~schema=ITS.Spec.commandSchema->S.castToUnknown, variantName)
+          ->ITS.Spec.commandAuthorization
+          ->Reventless.Authorization.named
+          ->Reventless.Authorization.rolesOf
+          ->Array.map(role => (role :> string))
+        )
+        ->Set.fromArray
+        ->Set.values
+        ->Array.fromIterator
+        ->nonEmpty
+      ),
     })
 
   // ── Extensions ───────────────────────────────────────────────────────────

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

@@ -21,6 +21,7 @@ import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
 import * as Transition$Reventless from "@reventlessdev/reventless-spec/src/types/Transition.res.mjs";
 import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
+import * as Authorization$Reventless from "@reventlessdev/reventless-spec/src/types/Authorization.res.mjs";
 import * as Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.mjs";
 import * as CapabilityNeed$Reventless from "@reventlessdev/reventless-spec/src/semantic/CapabilityNeed.res.mjs";
 import * as SchemaType$ReventlessCore from "../../components/Api/SchemaType.res.mjs";
@@ -617,15 +618,32 @@ function commandLevelAndId(isAggregate, partitionKey, variantName, properties) {
 }
 
 function accessKeysFor(rule) {
-  if (typeof rule !== "object") {
-    return;
-  }
-  let groups = rule._0;
+  let groups = Authorization$Reventless.groupsOf(rule);
   if (groups.length !== 0) {
     return groups;
   }
 }
 
+function nonEmpty(xs) {
+  if (xs.length !== 0) {
+    return xs;
+  }
+}
+
+function rolesFor(rule) {
+  return nonEmpty(Authorization$Reventless.rolesOf(rule).map(role => role));
+}
+
+function syntheticCommand(schema, variantName) {
+  if (DcbTag$Reventless.isVariantPayloadBearing(schema, variantName)) {
+    return {
+      TAG: variantName
+    };
+  } else {
+    return variantName;
+  }
+}
+
 function annotateArgTypes(schema, argTypes) {
   Stdlib_Option.forEach(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(schema), o => o["properties"]), Stdlib_JSON.Decode.object), props => {
     Object.entries(props).forEach(param => {
@@ -644,10 +662,8 @@ function toCommandDef(identityViews, isAggregate, partitionKey, mutationFieldFor
   let mkDef = (variantName, properties) => {
     let match = commandLevelAndId(isAggregate, partitionKey, variantName, properties);
     let aggregateIdField = match[1];
-    let syntheticCommand = DcbTag$Reventless.isVariantPayloadBearing(parentSchema, variantName) ? ({
-        TAG: variantName
-      }) : variantName;
-    let declared = commandTransition(syntheticCommand);
+    let syntheticCommand$1 = syntheticCommand(parentSchema, variantName);
+    let declared = commandTransition(syntheticCommand$1);
     let derived = derivedEdgeFor(variantName);
     let unrestricted = Transition$Reventless.isUnrestricted(declared);
     let match$1 = unrestricted ? undefined : Stdlib_Option.flatMap(derived, d => {
@@ -684,7 +700,8 @@ function toCommandDef(identityViews, isAggregate, partitionKey, mutationFieldFor
       let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
       apiExposed = excluded !== undefined ? !excluded.has(variantName) : true;
     }
-    let requiredAccess = accessKeysFor(commandAuthorization(syntheticCommand));
+    let rule = commandAuthorization(syntheticCommand$1);
+    let requiredAccess = accessKeysFor(rule);
     let mutationField = apiExposed ? mutationFieldFor(variantName) : "";
     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;
@@ -700,6 +717,7 @@ function toCommandDef(identityViews, isAggregate, partitionKey, mutationFieldFor
       allowedStatesSource: match$3[1],
       apiExposed: apiExposed,
       requiredAccess: requiredAccess,
+      requiredRoles: rolesFor(rule),
       ownerField: Owner$Reventless.fieldNamesOfProperties(properties)[0]
     };
   };
@@ -770,7 +788,8 @@ function queryableDefFromSpec(plugin, name, stateSchema, authorization, visibili
     singleQueryField: qf.singleFieldName,
     idField: Stdlib_Option.map(keyField, param => param[0]),
     idFieldSource: Stdlib_Option.map(keyField, param => param[1]),
-    requiredAccess: accessKeysFor(authorization)
+    requiredAccess: accessKeysFor(authorization),
+    requiredRoles: rolesFor(authorization)
   };
 }
 
@@ -1080,7 +1099,8 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       singleQueryField: qf.singleFieldName,
       idField: Stdlib_Option.map(keyField, param => param[0]),
       idFieldSource: Stdlib_Option.map(keyField, param => param[1]),
-      requiredAccess: accessKeysFor(R.Spec.authorization)
+      requiredAccess: accessKeysFor(Authorization$Reventless.named(R.Spec.authorization)),
+      requiredRoles: rolesFor(Authorization$Reventless.named(R.Spec.authorization))
     };
   });
   let stateViewDefs = stateViewSlices.map((SVS, i) => {
@@ -1112,7 +1132,8 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       singleQueryField: qf.singleFieldName,
       idField: Stdlib_Option.map(keyField, param => param[0]),
       idFieldSource: Stdlib_Option.map(keyField, param => param[1]),
-      requiredAccess: accessKeysFor(SVS.Spec.authorization)
+      requiredAccess: accessKeysFor(Authorization$Reventless.named(SVS.Spec.authorization)),
+      requiredRoles: rolesFor(Authorization$Reventless.named(SVS.Spec.authorization))
     };
   });
   let dcbSliceSchemas = stateChangeSlices.map(SCS => ({
@@ -1197,7 +1218,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let consumed = match$1[1];
     return {
       name: SCS.Spec.name,
-      commands: extractCommandDefs(identityViews, false, partitionBySlice[SCS.Spec.name], 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),
+      commands: extractCommandDefs(identityViews, false, partitionBySlice[SCS.Spec.name], variantName => Api_Naming$ReventlessCore.sliceMutationFieldFor(name, SCS.Spec.name, SCS.Spec.commandSchema, variantName), command => Authorization$Reventless.named(SCS.Spec.commandAuthorization(command)), SCS.Spec.commandTransition, extra => derivedEdgeFor(SCS.Spec.name, extra), SCS.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: consumed,
       linkedViews: linkedSvsFor(produced),
@@ -1212,7 +1233,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let produced = match[1];
     return {
       name: A.Spec.name,
-      commands: extractCommandDefs(identityViews, true, undefined, 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),
+      commands: extractCommandDefs(identityViews, true, undefined, variantName => Api_Naming$ReventlessCore.aggregateMutationField(name, A.Spec.name, variantName), command => Authorization$Reventless.named(A.Spec.commandAuthorization(command)), A.Spec.commandTransition, extra => derivedEdgeFor(A.Spec.name, extra), A.Spec.commandSchema),
       producedEventTypes: produced,
       consumedEventTypes: [],
       linkedViews: linkedSvsFor(produced).concat(linkedReadModelsFor(A.Spec.name)),
@@ -1246,7 +1267,8 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     commandTypes: qualify(name, DcbTag$Reventless.extractAllVariantNames(ITS.Spec.commandSchema)),
     targetName: ITS.Spec.targetName,
     externalSystem: ITS.Spec.externalSystem,
-    chapter: componentChapters[ITS.Spec.name]
+    chapter: componentChapters[ITS.Spec.name],
+    requiredRoles: nonEmpty(Array.from(new Set(DcbTag$Reventless.extractAllVariantNames(ITS.Spec.commandSchema).flatMap(variantName => Authorization$Reventless.rolesOf(Authorization$Reventless.named(ITS.Spec.commandAuthorization(syntheticCommand(ITS.Spec.commandSchema, variantName)))).map(role => role))).values()))
   }));
   let tableFailures = [];
   let tableWarnings = [];
@@ -1549,6 +1571,9 @@ export {
   isCreateCommandName,
   commandLevelAndId,
   accessKeysFor,
+  nonEmpty,
+  rolesFor,
+  syntheticCommand,
   annotateArgTypes,
   toCommandDef,
   extractCommandDefs,

package/src/plugin/lifecycle/PluginsReadModelSpec.res

@@ -10,7 +10,7 @@
 // this (spec-level `permission` outranks the legacy `{tableName, group}` pair),
 // and so does the `requiredAccess` the platform publishes — so a shell can gate
 // the Plugins view up front instead of offering it and meeting a refusal.
-@@reventless.authorize(AllowGroups(["Admin"]))
+@@reventless.authorize(AllowRoles([Admin]))
 
 // Current view — one row per plugin **name**, holding the currently-active
 // version's definition. Keyed by the aggregate id (= plugin name). The status

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

@@ -64,7 +64,7 @@ let stateSchema$1 = Sury.$Metadata_set(stateSchema, StateAnnotations$Reventless.
 });
 
 let authorization = {
-  TAG: "AllowGroups",
+  TAG: "AllowRoles",
   _0: ["Admin"]
 };
 

package/tests/admin/AdminApiSchemaDriftTest.res

@@ -254,7 +254,9 @@ let guards: array<guard> = [
     recordFields: schemaKeys(commandDefSchema),
     wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeCommandDef(cmd)),
     wireOnly: [],
-    recordOnly: [],
+    // The roles behind `requiredAccess`, read by the deploy check in-process.
+    // A client gates on the mapped groups and has no use for role names.
+    recordOnly: ["requiredRoles"],
   },
   {
     gqlType: "Platform_EventDef",
@@ -286,7 +288,9 @@ let guards: array<guard> = [
     recordFields: schemaKeys(queryableDefSchema),
     wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeQueryableDef(queryable)),
     wireOnly: [],
-    recordOnly: [],
+    // The roles behind `requiredAccess`, read by the deploy check in-process.
+    // A client gates on the mapped groups and has no use for role names.
+    recordOnly: ["requiredRoles"],
   },
   {
     gqlType: "Platform_AutomationSliceDef",
@@ -314,7 +318,9 @@ let guards: array<guard> = [
       Platform_ComponentDefinitionsApi.encodeInboundTranslationSliceDef(inbound),
     ),
     wireOnly: [],
-    recordOnly: [],
+    // The roles behind `requiredAccess`, read by the deploy check in-process.
+    // A client gates on the mapped groups and has no use for role names.
+    recordOnly: ["requiredRoles"],
   },
   {
     gqlType: "Platform_ExtensionDef",

package/tests/admin/AdminApiSchemaDriftTest.res.mjs

@@ -390,7 +390,7 @@ let guards = [
     recordFields: schemaKeys(Plugin$Reventless.commandDefSchema),
     wireFields: jsonKeys(Platform_ComponentDefinitionsApi$ReventlessCore.encodeCommandDef(cmd)),
     wireOnly: [],
-    recordOnly: []
+    recordOnly: ["requiredRoles"]
   },
   {
     gqlType: "Platform_EventDef",
@@ -422,7 +422,7 @@ let guards = [
     recordFields: schemaKeys(Plugin$Reventless.queryableDefSchema),
     wireFields: jsonKeys(Platform_ComponentDefinitionsApi$ReventlessCore.encodeQueryableDef(queryable)),
     wireOnly: [],
-    recordOnly: []
+    recordOnly: ["requiredRoles"]
   },
   {
     gqlType: "Platform_AutomationSliceDef",
@@ -446,7 +446,7 @@ let guards = [
     recordFields: schemaKeys(Plugin$Reventless.inboundTranslationSliceDefSchema),
     wireFields: jsonKeys(Platform_ComponentDefinitionsApi$ReventlessCore.encodeInboundTranslationSliceDef(inbound)),
     wireOnly: [],
-    recordOnly: []
+    recordOnly: ["requiredRoles"]
   },
   {
     gqlType: "Platform_ExtensionDef",

package/tests/admin/Platform_Admin_StructureTest.res

@@ -27,7 +27,7 @@ let commandNamed = (name: string): commandDef =>
 let activate = () => commandNamed("Activate")
 
 describe("the Plugins read model declares its lifecycle", () => {
-  let rm: queryableDef = Platform_Admin_Structure.pluginReadModel
+  let rm: queryableDef = Platform_Admin_Structure.pluginReadModel()
 
   testSync("names the field commands branch on", () =>
     expect(rm.lifecycleField)->toEqual(Some("status"))
@@ -206,25 +206,28 @@ describe("the internal commands declare the edges they move rows along", () => {
 // 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", () => {
-  // 🚨 **This is also the only check `Reventless.AdminGroup.name` can carry.** A
-  // PPX annotation takes a literal, so `@@reventless.authorize(AllowGroups(
-  // ["Admin"]))` above cannot reference the constant — the constant's job is to
-  // make everything *else* agree with the annotation, and nothing in the compiler
-  // spans that gap. The actual side here comes from the expanded annotation and
-  // the expected side from the constant, so the two are compared rather than
-  // restated. Writing the literal on both sides would pass while they diverged.
-  testSync("the spec declares the group, and it is the one the constant names", () =>
+  // The annotation names the role, so a renamed administrator group follows it
+  // without anyone editing the spec.
+  testSync("the spec declares the administrator role", () =>
     expect(PluginsReadModelSpec.authorization)->toEqual(
-      Reventless.Authorization.AllowGroups([Reventless.AdminGroup.name]),
+      Reventless.Authorization.AllowRoles([Reventless.Role.admin]),
     )
   )
 
-  testSync("and the published access keys are derived from it", () =>
-    expect(Platform_Admin_Structure.pluginReadModel.requiredAccess)->toEqual(
-      Some([Reventless.AdminGroup.name]),
+  testSync("and the published access keys are the group it maps to", () =>
+    expect(Platform_Admin_Structure.pluginReadModel().requiredAccess)->toEqual(
+      Some([Reventless.Role.adminGroup()]),
     )
   )
 
+  testSync("a renamed administrator group reaches the access keys", () => {
+    Reventless.Role.clearGroups()
+    Reventless.Role.setGroups([(Reventless.Role.admin, "ops")])
+    let keys = Platform_Admin_Structure.pluginReadModel().requiredAccess
+    Reventless.Role.clearGroups()
+    expect(keys)->toEqual(Some(["ops"]))
+  })
+
   // 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", () => {
@@ -243,7 +246,7 @@ describe("the Plugins view publishes the rule the server enforces", () => {
 // 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
+  let rm: queryableDef = Platform_Admin_Structure.pluginReadModel()
 
   testSync("the field names are the generic ones", () =>
     expect((rm.queryField, rm.singleQueryField))->toEqual((

package/tests/admin/Platform_Admin_StructureTest.res.mjs

@@ -2,8 +2,8 @@
 
 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 Role$Reventless from "@reventlessdev/reventless-spec/src/types/Role.res.mjs";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
-import * as AdminGroup$Reventless from "@reventlessdev/reventless-spec/src/types/AdminGroup.res.mjs";
 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";
@@ -19,19 +19,20 @@ function activate() {
 }
 
 globalThis.describe("the Plugins read model declares its lifecycle", () => {
+  let rm = Platform_Admin_Structure$ReventlessCore.pluginReadModel();
   globalThis.test("names the field commands branch on", () => {
-    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel.lifecycleField).toEqual("status");
+    globalThis.expect(rm.lifecycleField).toEqual("status");
   });
   globalThis.test("and the published wire name is unchanged by the rename", () => {
-    let sdlDeclaresStatus = Stdlib_Option.mapOr(Platform_Admin_Structure$ReventlessCore.pluginReadModel.lifecycleField, false, f => f === "status") && Platform_Admin_Structure$ReventlessCore.pluginReadModel.queryField.startsWith("Platform_");
+    let sdlDeclaresStatus = Stdlib_Option.mapOr(rm.lifecycleField, false, f => f === "status") && rm.queryField.startsWith("Platform_");
     globalThis.expect(sdlDeclaresStatus).toEqual(true);
   });
   globalThis.test("is served on the encoded def under the new key", () => {
-    let json = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodeQueryableDef(Platform_Admin_Structure$ReventlessCore.pluginReadModel));
+    let json = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodeQueryableDef(rm));
     globalThis.expect(json.includes(`"lifecycleField":"status"`)).toEqual(true);
   });
   globalThis.test("and never under the old one", () => {
-    globalThis.expect(JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodeQueryableDef(Platform_Admin_Structure$ReventlessCore.pluginReadModel)).includes(`"statusField"`)).toEqual(false);
+    globalThis.expect(JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodeQueryableDef(rm)).includes(`"statusField"`)).toEqual(false);
   });
 });
 
@@ -155,14 +156,24 @@ globalThis.describe("the internal commands declare the edges they move rows alon
 });
 
 globalThis.describe("the Plugins view publishes the rule the server enforces", () => {
-  globalThis.test("the spec declares the group, and it is the one the constant names", () => {
+  globalThis.test("the spec declares the administrator role", () => {
     globalThis.expect(PluginsReadModelSpec$ReventlessCore.authorization).toEqual({
-      TAG: "AllowGroups",
-      _0: [AdminGroup$Reventless.name]
+      TAG: "AllowRoles",
+      _0: [Role$Reventless.admin]
     });
   });
-  globalThis.test("and the published access keys are derived from it", () => {
-    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel.requiredAccess).toEqual([AdminGroup$Reventless.name]);
+  globalThis.test("and the published access keys are the group it maps to", () => {
+    globalThis.expect(Platform_Admin_Structure$ReventlessCore.pluginReadModel().requiredAccess).toEqual([Role$Reventless.adminGroup()]);
+  });
+  globalThis.test("a renamed administrator group reaches the access keys", () => {
+    Role$Reventless.clearGroups();
+    Role$Reventless.setGroups([[
+        Role$Reventless.admin,
+        "ops"
+      ]]);
+    let keys = Platform_Admin_Structure$ReventlessCore.pluginReadModel().requiredAccess;
+    Role$Reventless.clearGroups();
+    globalThis.expect(keys).toEqual(["ops"]);
   });
   globalThis.test("the query entry carries the spec's rule and no hand-written pair", () => {
     let entry = PluginBaseFragment$ReventlessCore.queryEntries[0];
@@ -177,10 +188,11 @@ globalThis.describe("the Plugins view publishes the rule the server enforces", (
 });
 
 globalThis.describe("the Plugins queryableDef is what the generic helpers produce", () => {
+  let rm = Platform_Admin_Structure$ReventlessCore.pluginReadModel();
   globalThis.test("the field names are the generic ones", () => {
     globalThis.expect([
-      Platform_Admin_Structure$ReventlessCore.pluginReadModel.queryField,
-      Platform_Admin_Structure$ReventlessCore.pluginReadModel.singleQueryField
+      rm.queryField,
+      rm.singleQueryField
     ]).toEqual([
       "Platform_Plugins",
       "Platform_Plugin"
@@ -188,9 +200,9 @@ globalThis.describe("the Plugins queryableDef is what the generic helpers produc
   });
   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
+      rm.labelField,
+      rm.labelFieldSource,
+      rm.searchableFields
     ]).toEqual([
       "name",
       "convention",
@@ -199,15 +211,15 @@ globalThis.describe("the Plugins queryableDef is what the generic helpers produc
   });
   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
+      rm.idField,
+      rm.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 props = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(rm.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"),
@@ -218,7 +230,7 @@ globalThis.describe("the Plugins queryableDef is what the generic helpers produc
     ]);
   });
   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));
+    let props = Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(rm.schema)), o => o["properties"]), Stdlib_JSON.Decode.object), [], prim => Object.keys(prim));
     globalThis.expect([
       props.includes("eventCollector"),
       props.includes("extensionNames"),

package/tests/admin/Platform_ComponentDefinitionsApiTest.res.mjs

@@ -311,40 +311,14 @@ globalThis.describe("visibility filtering (deployed AutoUI hides Internal)", ()
     idFieldSource: internalQbl_idFieldSource,
     requiredAccess: undefined
   };
-  let internalSlice_consumedEventTypes = internalQbl_consumedEventTypes;
-  let internalSlice_linkedWriteSide = internalQbl_linkedWriteSide;
-  let internalSlice_searchableFields = internalQbl_searchableFields;
-  let internalSlice_labelFieldSource = "convention";
-  let internalSlice_visibility = "Internal";
-  let internalSlice_singleQueryField = "Ordering_AvailableProduct";
-  let internalSlice_idField = "productId";
-  let internalSlice_idFieldSource = "sole";
-  let internalSlice = {
-    name: "PendingShipments",
-    queryField: "Ordering_PendingShipments",
-    schema: "{}",
-    consumedEventTypes: internalSlice_consumedEventTypes,
-    linkedWriteSide: internalSlice_linkedWriteSide,
-    labelField: "name",
-    searchableFields: internalSlice_searchableFields,
-    labelFieldSource: internalSlice_labelFieldSource,
-    lifecycleField: undefined,
-    ownerField: undefined,
-    retiredField: undefined,
-    retiredValues: undefined,
-    namedWhenRetired: undefined,
-    visibility: internalSlice_visibility,
-    chapter: undefined,
-    singleQueryField: internalSlice_singleQueryField,
-    idField: internalSlice_idField,
-    idFieldSource: internalSlice_idFieldSource,
-    requiredAccess: undefined
-  };
+  let newrecord = {...internalQbl};
+  newrecord.queryField = "Ordering_PendingShipments";
+  newrecord.name = "PendingShipments";
   let mixed_readModels = [
     qbl,
     internalQbl
   ];
-  let mixed_stateViewSlices = [internalSlice];
+  let mixed_stateViewSlices = [newrecord];
   let mixed_stateChangeSlices = structure_stateChangeSlices;
   let mixed_aggregates = structure_aggregates;
   let mixed_automationSlices = structure_automationSlices;
@@ -515,28 +489,9 @@ globalThis.describe("singleQueryField reaches the caller", () => {
     globalThis.expect(json.includes("\"singleQueryField\":\"Catalog_Product\"")).toEqual(true);
   });
   globalThis.test("encodes an unstated singular as null", () => {
+    let newrecord = {...qbl};
     let unstated = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", undefined, {
-      readModels: [{
-          name: "Products",
-          queryField: "Catalog_Products",
-          schema: "{}",
-          consumedEventTypes: qbl_consumedEventTypes,
-          linkedWriteSide: qbl_linkedWriteSide,
-          labelField: "displayName",
-          searchableFields: qbl_searchableFields,
-          labelFieldSource: "annotation",
-          lifecycleField: undefined,
-          ownerField: undefined,
-          retiredField: undefined,
-          retiredValues: undefined,
-          namedWhenRetired: undefined,
-          visibility: undefined,
-          chapter: undefined,
-          singleQueryField: undefined,
-          idField: "productId",
-          idFieldSource: "convention",
-          requiredAccess: undefined
-        }],
+      readModels: [(newrecord.singleQueryField = undefined, newrecord)],
       stateViewSlices: structure_stateViewSlices,
       stateChangeSlices: structure_stateChangeSlices,
       aggregates: structure_aggregates,
@@ -565,28 +520,9 @@ globalThis.describe("idField / idFieldSource reach the caller", () => {
     globalThis.expect(json.includes("\"idFieldSource\":\"convention\"")).toEqual(true);
   });
   globalThis.test("encodes an unresolved key as null on both fields", () => {
+    let newrecord = {...qbl};
     let unresolved = JSON.stringify(Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry("Catalog", undefined, {
-      readModels: [{
-          name: "Products",
-          queryField: "Catalog_Products",
-          schema: "{}",
-          consumedEventTypes: qbl_consumedEventTypes,
-          linkedWriteSide: qbl_linkedWriteSide,
-          labelField: "displayName",
-          searchableFields: qbl_searchableFields,
-          labelFieldSource: "annotation",
-          lifecycleField: undefined,
-          ownerField: undefined,
-          retiredField: undefined,
-          retiredValues: undefined,
-          namedWhenRetired: undefined,
-          visibility: undefined,
-          chapter: undefined,
-          singleQueryField: "Catalog_Product",
-          idField: undefined,
-          idFieldSource: undefined,
-          requiredAccess: undefined
-        }],
+      readModels: [(newrecord.idFieldSource = undefined, newrecord.idField = undefined, newrecord)],
       stateViewSlices: structure_stateViewSlices,
       stateChangeSlices: structure_stateChangeSlices,
       aggregates: structure_aggregates,