@reventlessdev/reventless-core 3.0.0-alpha.235 → 3.0.0-alpha.237

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -48,6 +48,60 @@ let toRelativePath = (function toRelativePath(moduleUrl) {
   }
 });
 
+function variantTag(variant) {
+  switch (variant.type) {
+    case "string" :
+      let tag = variant.const;
+      if (tag !== undefined) {
+        return tag;
+      } else {
+        return;
+      }
+    case "object" :
+      let match = variant.properties["TAG"];
+      if (match === undefined) {
+        return;
+      }
+      if (match.type !== "string") {
+        return;
+      }
+      let tag$1 = match.const;
+      if (tag$1 !== undefined) {
+        return tag$1;
+      } else {
+        return;
+      }
+    default:
+      return;
+  }
+}
+
+function mergedEventSchema(schemas) {
+  if (schemas.length === 1) {
+    return schemas[0];
+  }
+  let seen = new Set();
+  return S.union(schemas.flatMap(schema => {
+    if (schema.type === "union") {
+      return schema.anyOf;
+    } else {
+      return [schema];
+    }
+  }).filter(arm => {
+    let tag = variantTag(arm);
+    if (tag !== undefined) {
+      if (seen.has(tag)) {
+        return false;
+      } else {
+        seen.add(tag);
+        return true;
+      }
+    } else {
+      return true;
+    }
+  }));
+}
+
 let emptyResult_stateChangeSlicesOutputs = {};
 
 let emptyResult_stateViewSlicesOutputs = {};
@@ -583,7 +637,7 @@ function Make(DcbEventLogStorage) {
         eventLogEntries: allProducedSchemas.length !== 0 ? [{
               busKey: name + "DcbEventLog",
               displayName: name,
-              eventSchema: allProducedSchemas[0]
+              eventSchema: mergedEventSchema(allProducedSchemas)
             }] : []
       };
     };
@@ -596,6 +650,8 @@ function Make(DcbEventLogStorage) {
 export {
   log,
   toRelativePath,
+  variantTag,
+  mergedEventSchema,
   emptyResult,
   Make,
 }

package/src/plugin/component/Plugin_Structure.res

@@ -26,13 +26,13 @@ let rec isLabelShape = (t: SchemaType.schemaType): bool =>
   | _ => false
   }
 
-// Whether a field can hold a lifecycle status: a closed set of values, or an
-// optional one. A free-text `status: string` is not a lifecycle — filtering a
-// command menu against `allowedStates` needs states to compare with.
-let rec isStatusShape = (t: SchemaType.schemaType): bool =>
+// Whether a field can hold a lifecycle: a closed set of values, or an optional
+// one. A free-text `lifecycle: string` is not a lifecycle — filtering a command
+// menu against `allowedStates` needs states to compare with.
+let rec isLifecycleShape = (t: SchemaType.schemaType): bool =>
   switch t {
   | Enum(_, _) => true
-  | Nullable(inner) => isStatusShape(inner)
+  | Nullable(inner) => isLifecycleShape(inner)
   | _ => false
   }
 
@@ -44,18 +44,25 @@ let conventionalLabelNames = ["name", "title", "label", "displayname"]
 let shapeOfItem = (~entityName: string, item: S.item): SchemaType.schemaType =>
   SchemaType.fromSury(~parentName=entityName, ~fieldName=item.location, item.schema)
 
-// Resolve the field that holds the entity's lifecycle status, used to filter a
-// per-row command menu against each command's `allowedStates`. Resolution order:
-//   1. Field annotated `@status` (PPX-emitted; see StateAnnotations).
-//   2. Field literally named `"status"` whose IR shape is an enum (convention;
+// Resolve the field that holds the entity's lifecycle, used to filter a per-row
+// command menu against each command's `allowedStates`. Resolution order:
+//   1. Field annotated `@lifecycle` (PPX-emitted; see StateAnnotations).
+//   2. Field literally named `"lifecycle"` whose IR shape is an enum (convention;
 //      mirrors how labelField falls back to a conventionally-named field).
 //   3. None — filter is inert for this read model.
-let statusFieldFromStateSchema = (
+//
+// The convention rung is keyed on `lifecycle` rather than `status` deliberately:
+// `status` is a promiscuous name — geocoding progress, todo-queue progress and
+// translation audit outcome all wear it — so a convention keyed on it guesses,
+// and guesses often. `lifecycle` is a word nobody types by accident, so matching
+// it is closer to a declaration written in the field name. A record whose field
+// is honestly called something else annotates instead.
+let lifecycleFieldFromStateSchema = (
   ~entityName: string,
   stateSchema: S.t<unknown>,
 ): option<string> => {
   let annotated = switch Reventless.StateAnnotations.getSpec(stateSchema) {
-  | Some(spec) => spec.status
+  | Some(spec) => spec.lifecycle
   | None => None
   }
   switch annotated {
@@ -65,7 +72,7 @@ let statusFieldFromStateSchema = (
     | Object({items}) =>
       items
       ->Array.find(item =>
-        item.location == "status" && isStatusShape(shapeOfItem(~entityName, item))
+        item.location == "lifecycle" && isLifecycleShape(shapeOfItem(~entityName, item))
       )
       ->Option.map(item => item.location)
     | _ => None
@@ -73,6 +80,90 @@ let statusFieldFromStateSchema = (
   }
 }
 
+// The field whose truth withdraws a row from ordinary reads. Annotation-only:
+// there is no convention rung here, and its absence is the point. `lifecycleField`
+// may fall back to a field literally named "lifecycle" because guessing wrong makes
+// a command menu filter oddly; guessing wrong here makes rows vanish for every
+// caller who is not elevated, so a boolean named `archived` that nobody annotated
+// stays exactly as visible as it was.
+let retiredFromStateSchema = (
+  stateSchema: S.t<unknown>,
+): option<Reventless.StateAnnotations.retiredSpec> =>
+  switch Reventless.StateAnnotations.getSpec(stateSchema) {
+  | Some(spec) => spec.retired
+  | None => None
+  }
+
+let retiredFieldFromStateSchema = (stateSchema: S.t<unknown>): option<string> =>
+  retiredFromStateSchema(stateSchema)->Option.map(r => r.field)
+
+// The states a row is retired *in*, for the enum form. `None` is the boolean
+// form, where the value is always `true` and naming it would be a parameter that
+// can only hold one thing. A set, because a lifecycle may be withdrawn by more
+// than one state, and a one-member set is the ordinary case.
+//
+// Published beside `retiredField` rather than left for a consumer to dig out of
+// the schema: a client that has the def in hand has the whole predicate, and two
+// places deriving one comparison is how they come to disagree about it.
+let retiredValuesFromStateSchema = (stateSchema: S.t<unknown>): option<array<string>> =>
+  retiredFromStateSchema(stateSchema)->Option.flatMap(r => r.values)
+
+// The check the PPX cannot make, in the one place that can: the payload is a
+// constructor reference the PPX only ever sees as a name, and whether that name
+// is a case of the field's enum needs the schema.
+//
+// Two rules, and the second is the one the form exists for. A `value` on a field
+// that is not the record's lifecycle would keep the read narrowing while silently
+// losing the command filtering that motivates it — `@allowedStates` is written in
+// terms of the lifecycle field, so a retirement state anywhere else is a state no
+// command can name.
+let checkRetiredValue = (~entityName: string, stateSchema: S.t<unknown>): unit =>
+  switch retiredFromStateSchema(stateSchema) {
+  | Some({field, values: Some(values)}) =>
+    let named = values->Array.joinWith(", ")
+    let lifecycle = lifecycleFieldFromStateSchema(~entityName, stateSchema)
+    if lifecycle != Some(field) {
+      log.warn(
+        ~comp="Plugin_Structure",
+        `${entityName}: @retired(${named}) is on "${field}", which is not this record's lifecycle field${lifecycle
+          ->Option.map(f => ` (that is "${f}")`)
+          ->Option.getOr(
+            " (it declares none)",
+          )}. A retirement state no command's @allowedStates can name loses the command filtering the state form exists for.`,
+      )
+    }
+    let declared = switch stateSchema {
+    | Object({items}) =>
+      items
+      ->Array.find(item => item.location == field)
+      ->Option.map(item =>
+        switch shapeOfItem(~entityName, item) {
+        | Enum(_, values) => values
+        | Nullable(Enum(_, values)) => values
+        | _ => []
+        }
+      )
+      ->Option.getOr([])
+    | _ => []
+    }
+    // Reported per state rather than as a set: one wrong entry among three still
+    // narrows something, so the symptom is a subset of rows leaking rather than
+    // all of them — which is harder to spot than the single-value case was.
+    if Array.length(declared) > 0 {
+      values
+      ->Array.filter(v => !(declared->Array.includes(v)))
+      ->Array.forEach(v =>
+        log.warn(
+          ~comp="Plugin_Structure",
+          `${entityName}: @retired(${v}) names a state "${field}" does not declare — known values: ${declared->Array.joinWith(
+              ", ",
+            )}.`,
+        )
+      )
+    }
+  | _ => ()
+  }
+
 // Which rung of the ladder below produced the label. Published on `queryableDef`
 // as `labelFieldSource`, because the four rungs are not equally believable and a
 // consumer with a name rule of its own has to rank the declaration against it:
@@ -752,6 +843,7 @@ let make = (
       // edges for any event reaching the read model via a DCB-log-sourced mapping (a classic
       // aggregate→view link is also drawn from the producer's linkedViews, deduped downstream).
       let consumed = qualify(~prefix=name, R.consumedEventNames)
+      checkRetiredValue(~entityName=R.Spec.name, stateSchema)
       ({
         Reventless.Plugin.name: R.Spec.name,
         queryField: qf.listFieldName,
@@ -761,10 +853,12 @@ let make = (
         labelField: label.field,
         searchableFields: label.searchableFields,
         labelFieldSource: Some(labelFieldSourceToString(label.source)),
-        statusField: statusFieldFromStateSchema(~entityName=R.Spec.name, stateSchema),
-        // Same schema `statusField` reads, so the two cannot disagree about which
+        lifecycleField: lifecycleFieldFromStateSchema(~entityName=R.Spec.name, stateSchema),
+        // Same schema `lifecycleField` reads, so the two cannot disagree about which
         // fields this view has.
         ownerField: Reventless.Owner.fieldNames(stateSchema)->Array.get(0),
+        retiredField: retiredFieldFromStateSchema(stateSchema),
+        retiredValues: retiredValuesFromStateSchema(stateSchema),
         visibility: visibilityTag(R.Spec.visibility),
         chapter: chapterOf(R.Spec.name),
         // Taken from the `qf` record, never re-derived: `Api_Naming` is the only
@@ -787,6 +881,7 @@ let make = (
         ~entityName=SVS.Spec.name,
         stateSchema,
       )
+      checkRetiredValue(~entityName=SVS.Spec.name, stateSchema)
       ({
         Reventless.Plugin.name: SVS.Spec.name,
         queryField: qf.listFieldName,
@@ -796,8 +891,10 @@ let make = (
         labelField: label.field,
         searchableFields: label.searchableFields,
         labelFieldSource: Some(labelFieldSourceToString(label.source)),
-        statusField: statusFieldFromStateSchema(~entityName=SVS.Spec.name, stateSchema),
+        lifecycleField: lifecycleFieldFromStateSchema(~entityName=SVS.Spec.name, stateSchema),
         ownerField: Reventless.Owner.fieldNames(stateSchema)->Array.get(0),
+        retiredField: retiredFieldFromStateSchema(stateSchema),
+        retiredValues: retiredValuesFromStateSchema(stateSchema),
         visibility: visibilityTag(SVS.Spec.visibility),
         chapter: chapterOf(SVS.Spec.name),
         singleQueryField: Some(qf.singleFieldName),

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

@@ -39,7 +39,7 @@ function isLabelShape(_t) {
   };
 }
 
-function isStatusShape(_t) {
+function isLifecycleShape(_t) {
   while (true) {
     let t = _t;
     if (typeof t !== "object") {
@@ -68,15 +68,15 @@ function shapeOfItem(entityName, item) {
   return SchemaType$ReventlessCore.fromSury(entityName, item.location, item.schema);
 }
 
-function statusFieldFromStateSchema(entityName, stateSchema) {
+function lifecycleFieldFromStateSchema(entityName, stateSchema) {
   let spec = StateAnnotations$Reventless.getSpec(stateSchema);
-  let annotated = spec !== undefined ? spec.status : undefined;
+  let annotated = spec !== undefined ? spec.lifecycle : undefined;
   if (annotated !== undefined) {
     return annotated;
   } else if (stateSchema.type === "object") {
     return Stdlib_Option.map(stateSchema.items.find(item => {
-      if (item.location === "status") {
-        return isStatusShape(shapeOfItem(entityName, item));
+      if (item.location === "lifecycle") {
+        return isLifecycleShape(shapeOfItem(entityName, item));
       } else {
         return false;
       }
@@ -86,6 +86,64 @@ function statusFieldFromStateSchema(entityName, stateSchema) {
   }
 }
 
+function retiredFromStateSchema(stateSchema) {
+  let spec = StateAnnotations$Reventless.getSpec(stateSchema);
+  if (spec !== undefined) {
+    return spec.retired;
+  }
+}
+
+function retiredFieldFromStateSchema(stateSchema) {
+  return Stdlib_Option.map(retiredFromStateSchema(stateSchema), r => r.field);
+}
+
+function retiredValuesFromStateSchema(stateSchema) {
+  return Stdlib_Option.flatMap(retiredFromStateSchema(stateSchema), r => r.values);
+}
+
+function checkRetiredValue(entityName, stateSchema) {
+  let match = retiredFromStateSchema(stateSchema);
+  if (match === undefined) {
+    return;
+  }
+  let values = match.values;
+  if (values === undefined) {
+    return;
+  }
+  let field = match.field;
+  let named = values.join(", ");
+  let lifecycle = lifecycleFieldFromStateSchema(entityName, stateSchema);
+  if (Primitive_object.notequal(lifecycle, field)) {
+    log.warn("Plugin_Structure", undefined, entityName + `: @retired(` + named + `) is on "` + field + `", which is not this record's lifecycle field` + Stdlib_Option.getOr(Stdlib_Option.map(lifecycle, f => ` (that is "` + f + `")`), " (it declares none)") + `. A retirement state no command's @allowedStates can name loses the command filtering the state form exists for.`);
+  }
+  let declared;
+  declared = stateSchema.type === "object" ? Stdlib_Option.getOr(Stdlib_Option.map(stateSchema.items.find(item => item.location === field), item => {
+      let match = shapeOfItem(entityName, item);
+      if (typeof match !== "object") {
+        return [];
+      }
+      switch (match.TAG) {
+        case "Nullable" :
+          let match$1 = match._0;
+          if (typeof match$1 !== "object") {
+            return [];
+          } else if (match$1.TAG === "Enum") {
+            return match$1._1;
+          } else {
+            return [];
+          }
+        case "Enum" :
+          return match._1;
+        default:
+          return [];
+      }
+    }), []) : [];
+  if (declared.length !== 0) {
+    values.filter(v => !declared.includes(v)).forEach(v => log.warn("Plugin_Structure", undefined, entityName + `: @retired(` + v + `) names a state "` + field + `" does not declare — known values: ` + declared.join(", ") + `.`));
+    return;
+  }
+}
+
 function labelFieldSourceToString(s) {
   switch (s) {
     case "Annotation" :
@@ -535,6 +593,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let label = labelFieldsFromStateSchema(R.Spec.name, stateSchema);
     let keyField = GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField(R.Spec.name, stateSchema);
     let consumed = qualify(name, R.consumedEventNames);
+    checkRetiredValue(R.Spec.name, stateSchema);
     return {
       name: R.Spec.name,
       queryField: qf.listFieldName,
@@ -544,8 +603,10 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       labelField: label.field,
       searchableFields: label.searchableFields,
       labelFieldSource: labelFieldSourceToString(label.source),
-      statusField: statusFieldFromStateSchema(R.Spec.name, stateSchema),
+      lifecycleField: lifecycleFieldFromStateSchema(R.Spec.name, stateSchema),
       ownerField: Owner$Reventless.fieldNames(stateSchema)[0],
+      retiredField: retiredFieldFromStateSchema(stateSchema),
+      retiredValues: retiredValuesFromStateSchema(stateSchema),
       visibility: visibilityTag(R.Spec.visibility),
       chapter: componentChapters[R.Spec.name],
       singleQueryField: qf.singleFieldName,
@@ -561,6 +622,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let stateSchema = SVS.Spec.stateSchema;
     let label = labelFieldsFromStateSchema(SVS.Spec.name, stateSchema);
     let keyField = GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField(SVS.Spec.name, stateSchema);
+    checkRetiredValue(SVS.Spec.name, stateSchema);
     return {
       name: SVS.Spec.name,
       queryField: qf.listFieldName,
@@ -570,8 +632,10 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       labelField: label.field,
       searchableFields: label.searchableFields,
       labelFieldSource: labelFieldSourceToString(label.source),
-      statusField: statusFieldFromStateSchema(SVS.Spec.name, stateSchema),
+      lifecycleField: lifecycleFieldFromStateSchema(SVS.Spec.name, stateSchema),
       ownerField: Owner$Reventless.fieldNames(stateSchema)[0],
+      retiredField: retiredFieldFromStateSchema(stateSchema),
+      retiredValues: retiredValuesFromStateSchema(stateSchema),
       visibility: visibilityTag(SVS.Spec.visibility),
       chapter: componentChapters[SVS.Spec.name],
       singleQueryField: qf.singleFieldName,
@@ -689,10 +753,14 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
 export {
   log,
   isLabelShape,
-  isStatusShape,
+  isLifecycleShape,
   conventionalLabelNames,
   shapeOfItem,
-  statusFieldFromStateSchema,
+  lifecycleFieldFromStateSchema,
+  retiredFromStateSchema,
+  retiredFieldFromStateSchema,
+  retiredValuesFromStateSchema,
+  checkRetiredValue,
   labelFieldSourceToString,
   labelFieldsFromStateSchema,
   extractReferences,

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

@@ -48,10 +48,11 @@ let stateSchema$1 = S.Metadata.set(stateSchema, StateAnnotations$Reventless.stat
   scanSort: [],
   semantic: [],
   metric: [],
-  status: undefined,
+  lifecycle: undefined,
   groupBy: "kind",
   visibility: undefined,
-  live: undefined
+  live: undefined,
+  retired: undefined
 });
 
 let name = "Plugins";

package/tests/admin/Platform_Admin_StructureTest.res

@@ -0,0 +1,49 @@
+// The platform's own admin components, as `Platform_ComponentDefinitions` serves
+// them. The Plugins read model is a framework-generated queryable: its field names
+// are chosen here and read by every client, so the rule that applies to it is the
+// opposite of the one that applies to an authored record.
+//
+// An authored record may follow the convention — name the field `lifecycle` and
+// write no annotation. A generated row cannot, because its field name is a
+// published wire name: `status` in the SDL, in stored QueryDb rows, and in any
+// client selecting it. Renaming it to satisfy a convention would move the
+// contract, break selecting clients and require re-projection. So it declares
+// instead, and the declaration is what this asserts — the failure mode otherwise
+// is silent (a board loses its columns, a command menu stops filtering, and
+// nothing fails to compile).
+
+open JestGlobals
+open Reventless.Plugin
+
+describe("the Plugins read model declares its lifecycle", () => {
+  let rm: queryableDef = Platform_Admin_Structure.pluginReadModel
+
+  testSync("names the field commands branch on", () =>
+    expect(rm.lifecycleField)->toEqual(Some("status"))
+  )
+
+  testSync("and the published wire name is unchanged by the rename", () => {
+    // Stated as its own assertion rather than folded into the one above: the two
+    // say different things. That the field is declared is the fix; that it is
+    // still called `status` is the constraint the fix had to respect.
+    let sdlDeclaresStatus =
+      rm.lifecycleField->Option.mapOr(false, f => f == "status") &&
+        rm.queryField->String.startsWith("Platform_")
+    expect(sdlDeclaresStatus)->toEqual(true)
+  })
+
+  testSync("is served on the encoded def under the new key", () => {
+    let json =
+      rm->Platform_ComponentDefinitionsApi.encodeQueryableDef->JSON.stringify
+    expect(json->String.includes(`"lifecycleField":"status"`))->toEqual(true)
+  })
+
+  testSync("and never under the old one", () =>
+    expect(
+      rm
+      ->Platform_ComponentDefinitionsApi.encodeQueryableDef
+      ->JSON.stringify
+      ->String.includes(`"statusField"`),
+    )->toEqual(false)
+  )
+})

package/tests/admin/Platform_Admin_StructureTest.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+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";
+
+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");
+  });
+  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_");
+    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));
+    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);
+  });
+});
+
+/*  Not a pure module */

package/tests/admin/Platform_BakedManifestTest.res

@@ -15,7 +15,7 @@ let queryable = (~name, ~visibility=?, ~ownerField=?, ()): queryableDef => {
   labelField: "displayName",
   searchableFields: ["displayName"],
   labelFieldSource: None,
-  statusField: None,
+  lifecycleField: None,
   visibility,
   chapter: None,
   singleQueryField: Some(`Ordering_${name}Single`),
@@ -23,6 +23,8 @@ let queryable = (~name, ~visibility=?, ~ownerField=?, ()): queryableDef => {
   idFieldSource: Some("convention"),
   requiredAccess: None,
   ownerField,
+  retiredField: None,
+  retiredValues: None,
 }
 
 let command = (~name, ~references=[], ~ownerField=?, ()): commandDef => {

package/tests/admin/Platform_BakedManifestTest.res.mjs

@@ -18,8 +18,10 @@ function queryable(name, visibility, ownerField, param) {
     labelField: "displayName",
     searchableFields: ["displayName"],
     labelFieldSource: undefined,
-    statusField: undefined,
+    lifecycleField: undefined,
     ownerField: ownerField,
+    retiredField: undefined,
+    retiredValues: undefined,
     visibility: visibility,
     chapter: undefined,
     singleQueryField: `Ordering_` + name + `Single`,

package/tests/admin/Platform_ComponentDefinitionsApiTest.res

@@ -30,7 +30,7 @@ let qbl: queryableDef = {
   labelField: "displayName",
   searchableFields: ["displayName"],
   labelFieldSource: Some("annotation"),
-  statusField: None,
+  lifecycleField: None,
   visibility: None,
   chapter: None,
   singleQueryField: Some("Catalog_Product"),
@@ -38,6 +38,8 @@ let qbl: queryableDef = {
   idFieldSource: Some("convention"),
   requiredAccess: None,
   ownerField: None,
+  retiredField: None,
+  retiredValues: None,
 }
 
 let wbl: writableDef = {
@@ -162,8 +164,8 @@ describe("encodePluginStructureEntry", () => {
     expect(json->String.includes("\"apiExposed\":true"))->toEqual(true)
   )
 
-  testSync("encodes None statusField as null", () =>
-    expect(json->String.includes("\"statusField\":null"))->toEqual(true)
+  testSync("encodes None lifecycleField as null", () =>
+    expect(json->String.includes("\"lifecycleField\":null"))->toEqual(true)
   )
 
   // Phase 6.3: write-side emitted-event field schemas.
@@ -256,7 +258,7 @@ describe("visibility filtering (deployed AutoUI hides Internal)", () => {
     labelField: "name",
     searchableFields: ["name"],
     labelFieldSource: Some("convention"),
-    statusField: None,
+    lifecycleField: None,
     visibility: Some("Internal"),
     chapter: None,
     singleQueryField: Some("Ordering_AvailableProduct"),
@@ -264,6 +266,8 @@ describe("visibility filtering (deployed AutoUI hides Internal)", () => {
     idFieldSource: Some("sole"),
     requiredAccess: None,
       ownerField: None,
+      retiredField: None,
+      retiredValues: 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`.
@@ -329,7 +333,7 @@ describe("visibility filtering (deployed AutoUI hides Internal)", () => {
   })
 })
 
-describe("allowedStates + statusField populated", () => {
+describe("allowedStates + lifecycleField populated", () => {
   let cmdWithStates: commandDef = {
     name: "Activate",
     schema: "{}",
@@ -353,7 +357,7 @@ describe("allowedStates + statusField populated", () => {
     labelField: "name",
     searchableFields: ["name"],
     labelFieldSource: Some("convention"),
-    statusField: Some("status"),
+    lifecycleField: Some("status"),
     visibility: None,
     chapter: None,
     singleQueryField: Some("Platform_Plugin"),
@@ -361,6 +365,8 @@ describe("allowedStates + statusField populated", () => {
     idFieldSource: None,
     requiredAccess: None,
       ownerField: None,
+      retiredField: None,
+      retiredValues: None,
   }
 
   let wblWithStates: writableDef = {
@@ -402,8 +408,8 @@ describe("allowedStates + statusField populated", () => {
     expect(json->String.includes("\"targetState\":\"Active\""))->toEqual(true)
   )
 
-  testSync("encodes populated statusField as the field name string", () =>
-    expect(json->String.includes("\"statusField\":\"status\""))->toEqual(true)
+  testSync("encodes populated lifecycleField as the field name string", () =>
+    expect(json->String.includes("\"lifecycleField\":\"status\""))->toEqual(true)
   )
 
   // "declares no errors" is an empty list, never null — the SDL types `errors` as