@reventlessdev/reventless-core 3.0.0-alpha.190 → 3.0.0-alpha.192

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

@@ -0,0 +1,79 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+
+let refLikeNames = [
+  "file",
+  "attachment",
+  "upload"
+];
+
+let refLikeSuffixes = [
+  "storageref",
+  "fileref",
+  "attachmentref"
+];
+
+let imageLikeNames = [
+  "image",
+  "imageurl",
+  "photo",
+  "photourl",
+  "avatar",
+  "avatarurl",
+  "thumbnail"
+];
+
+function nameMatches(field) {
+  let lower = field.toLowerCase();
+  if (refLikeNames.includes(lower) || imageLikeNames.includes(lower)) {
+    return true;
+  } else {
+    return refLikeSuffixes.some(suffix => lower.endsWith(suffix));
+  }
+}
+
+function warningsFromProperties(component, properties) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let fieldSchema = param[1];
+    let field = param[0];
+    if (fieldSchema.type === "string" && field !== "TAG" && nameMatches(field) && Stdlib_Option.isNone(StorageRef$Reventless.getStore(fieldSchema))) {
+      return {
+        component: component,
+        field: field
+      };
+    }
+  });
+}
+
+function scanSchema(component, schema) {
+  let fromVariant = v => {
+    if (v.type === "object") {
+      return warningsFromProperties(component, v.properties);
+    } else {
+      return [];
+    }
+  };
+  if (schema.type === "union") {
+    return schema.anyOf.flatMap(fromVariant);
+  } else {
+    return fromVariant(schema);
+  }
+}
+
+function message(w) {
+  return w.component + `.` + w.field + ` looks like a stored-object reference but declares no store — annotate it \`@storageRef("<store>")\` so the deployment provisions the store it needs, or rename the field if it holds an external URL. Heuristic matches are never provisioned.`;
+}
+
+export {
+  refLikeNames,
+  refLikeSuffixes,
+  imageLikeNames,
+  nameMatches,
+  warningsFromProperties,
+  scanSchema,
+  message,
+}
+/* StorageRef-Reventless Not a pure module */

package/src/plugin/component/Plugin_Builder.res

@@ -267,13 +267,13 @@ module Make = (
       module(R: ReventlessInfra.ReadModel.T with type api = api and type role = role),
     ) => {
       let qn = Api_Naming.queryFieldNamesForReadModel(~plugin=name, ~name=R.Spec.name)
-      let (labelField, _searchableFields) = Plugin_Structure.labelFieldsFromStateSchema(
+      let label = Plugin_Structure.labelFieldsFromStateSchema(
         ~entityName=R.Spec.name,
         R.Spec.stateSchema->S.castToUnknown,
       )
       let qn = {
         ...qn,
-        labelField,
+        labelField: label.field,
         connectionFilterTypeName: qn.returnTypeName ++ "Filter",
       }
       let qn = switch R.Spec.subIdConfig {

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

@@ -208,13 +208,13 @@ function Make(Spec) {
         let eventLogEntries = eventLogEntriesFromAggregates.concat(dcbResult.eventLogEntries);
         readModels.forEach(R => {
           let qn = Api_Naming$ReventlessCore.queryFieldNamesForReadModel(extra$1, R.Spec.name, undefined);
-          let match = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(R.Spec.name, R.Spec.stateSchema);
+          let label = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(R.Spec.name, R.Spec.stateSchema);
           let newrecord = {...qn};
-          newrecord.labelField = match[0];
+          newrecord.labelField = label.field;
           newrecord.connectionFilterTypeName = qn.returnTypeName + "Filter";
-          let match$1 = R.Spec.subIdConfig;
+          let match = R.Spec.subIdConfig;
           let qn$1;
-          if (match$1 !== undefined) {
+          if (match !== undefined) {
             let newrecord$1 = {...newrecord};
             newrecord$1.itemsFilterTypeName = newrecord.returnTypeName + "ItemsFilter";
             newrecord$1.itemsFieldName = newrecord.singleFieldName + "Items";

package/src/plugin/component/Plugin_Helpers.res

@@ -434,6 +434,8 @@ let createTasks = (
         ~opts=Some(opts),
       ))
     )
+  // Every task is constructed, so every side-effect handler has registered.
+  finishTasks()
   tasksOutputs.contents
 }
 
@@ -1246,23 +1248,32 @@ let serializeTasksOutputs = (pluginOutputs: Plugin.outputs): Pulumi.Output.t<JSO
 // Serialize event mappers from aggregates to JSON array for the "eventMappers" stack export.
 let serializeEventMappersOutputs = (pluginOutputs: Plugin.outputs): Pulumi.Output.t<JSON.t> =>
   pluginOutputs.aggregates->Pulumi.Output.flatMap(aggregates =>
+    // Resolve each `eventMapper` through its own Output before collecting, and only
+    // then drop the absent ones. `Output.all` deeply unwraps the *contents* of its
+    // elements, so collecting first would hand `toResolvedOutputs` a record whose
+    // fields Pulumi has already resolved — see `serializePlainDictExport` above for
+    // the same hazard. Absence is carried as `None` through the collection instead.
     aggregates
     ->Dict.valuesToArray
-    ->Array.filterMap((agg: Aggregate.outputs) =>
-      agg.eventMapper->Option.map(eventMapperOutput =>
-        eventMapperOutput->Pulumi.Output.flatMap(em =>
+    ->Array.map((agg: Aggregate.outputs) =>
+      agg.eventMapper->Pulumi.Output.flatMap(em =>
+        switch em {
+        | Some(em) =>
           em
           ->EventMapper.toResolvedOutputs
           ->Pulumi.Output.apply(resolved =>
-            resolved->S.reverseConvertToJsonOrThrow(
-              ReventlessInterop.EventMapper.resolvedOutputsSchema,
+            Some(
+              resolved->S.reverseConvertToJsonOrThrow(
+                ReventlessInterop.EventMapper.resolvedOutputsSchema,
+              ),
             )
           )
-        )
+        | None => Pulumi.Output.make(None)
+        }
       )
     )
     ->Pulumi.Output.all
-    ->Pulumi.Output.apply(arr => arr->JSON.Encode.array)
+    ->Pulumi.Output.apply(arr => arr->Array.keepSome->JSON.Encode.array)
   )
 
 // Export platform admin component outputs as individual top-level Pulumi stack exports.

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

@@ -248,6 +248,7 @@ function createTasks(tasks, aggregatesOutputs, scheduler, schedulerRoleUrn, publ
     let bucketName = bucketNameOpt !== undefined ? bucketNameOpt : "Bucket";
     return ResourceQueryRuntime$ReventlessCore.bucketNameOfTaskExn(tasksOutputs.contents, taskName, bucketName);
   }, scheduler, schedulerRoleUrn, publishToAggregates, queryEngine, resourceNaming, aggregatesOutputs, componentRuntime[SpecificTask.Spec.name], opts)));
+  Builder_Helpers$ReventlessCore.finishTasks();
   return tasksOutputs.contents;
 }
 
@@ -627,7 +628,13 @@ function serializeTasksOutputs(pluginOutputs) {
 }
 
 function serializeEventMappersOutputs(pluginOutputs) {
-  return Output$Pulumi.flatMap(pluginOutputs.aggregates, aggregates => Pulumi.all(Stdlib_Array.filterMap(Object.values(aggregates), agg => Stdlib_Option.map(agg.eventMapper, eventMapperOutput => Output$Pulumi.flatMap(eventMapperOutput, em => EventMapper$ReventlessCore.toResolvedOutputs(em).apply(resolved => S.reverseConvertToJsonOrThrow(resolved, EventMapper$ReventlessInterop.resolvedOutputsSchema)))))).apply(arr => arr));
+  return Output$Pulumi.flatMap(pluginOutputs.aggregates, aggregates => Pulumi.all(Object.values(aggregates).map(agg => Output$Pulumi.flatMap(agg.eventMapper, em => {
+    if (em !== undefined) {
+      return EventMapper$ReventlessCore.toResolvedOutputs(em).apply(resolved => S.reverseConvertToJsonOrThrow(resolved, EventMapper$ReventlessInterop.resolvedOutputsSchema));
+    } else {
+      return Pulumi.output(undefined);
+    }
+  }))).apply(Stdlib_Array.keepSome));
 }
 
 function exportPlatformOutputs(extensionPointsOutputs, aggregatesOutputs, readModelsOutputs, dcbEventLogOutputs, stateChangeSlicesOutputs, stateViewSlicesOutputs, automationSlicesOutputs, outboundTranslationSlicesOutputs, inboundTranslationSlicesOutputs) {
@@ -913,6 +920,14 @@ let finishAggregates = Builder_Helpers$ReventlessCore.finishAggregates;
 
 let addEventMappers = Builder_Helpers$ReventlessCore.addEventMappers;
 
+let taskSideEffectGates = Builder_Helpers$ReventlessCore.taskSideEffectGates;
+
+let taskSideEffectFinishFns = Builder_Helpers$ReventlessCore.taskSideEffectFinishFns;
+
+let registerTaskSideEffectHandler = Builder_Helpers$ReventlessCore.registerTaskSideEffectHandler;
+
+let finishTasks = Builder_Helpers$ReventlessCore.finishTasks;
+
 let readModelNamesForSourceName = Builder_Helpers$ReventlessCore.readModelNamesForSourceName;
 
 let publishToReadModels = Builder_Helpers$ReventlessCore.publishToReadModels;
@@ -968,6 +983,10 @@ export {
   createAggregatesWithoutEventMappers,
   finishAggregates,
   addEventMappers,
+  taskSideEffectGates,
+  taskSideEffectFinishFns,
+  registerTaskSideEffectHandler,
+  finishTasks,
   readModelNamesForSourceName,
   publishToReadModels,
   finishReadModels,

package/src/plugin/component/Plugin_Structure.res

@@ -5,26 +5,53 @@
 
 let log = Logger.fromEnv()
 
-// Returns (labelField, searchableFields) from a state schema.
-// Source ladder:
-//   1. @displayName spec present → "displayName" + spec.fields (raw underlying fields)
-//   2. First non-id, non-`*Id`/`*Ids`, non-TAG, string-typed field in declaration order
-//   3. "id" fallback with a logged warning (no searchable fields)
-//
-// `*Id` / `*Ids` fields (e.g. `productId`, `customerId`, `orderIds`) are entity
-// references, not human-readable labels — skipping them lets a sibling like
-// `name` win even when it appears later in declaration order.
-let isIdLikeFieldName = (name: string): bool =>
-  name == "id" || name->String.endsWith("Id") || name->String.endsWith("Ids")
-
-// Resolve the field that holds the entity's lifecycle status, used by
-// AutoUI to filter the per-row command menu against each command's
-// `allowedStates`. Resolution order:
+// What a field *is* is `SchemaType`'s question, and it is the IR every other
+// schema consumer here reads. The two predicates below are the only two answers
+// this module needs; both are stated over the IR rather than over sury shapes,
+// so a field that is a date, a reference or an enum is one for the label picker
+// too.
+
+// Whether a field can name a record. `Nullable` unwraps — an optional name is
+// still the entity's name, absent on some rows, which is a rendering question
+// rather than a declaration one. A `Semantic` wrapper is refused: it is the
+// schema saying the string means something other than prose (a storage ref, a
+// URL), and a bucket key is not a name. `DateTime`, `EntityId`, `Enum` and every
+// composite shape fall out of the catch-all without being named — which is the
+// point of reading an IR rather than restating it: the next shape it grows is
+// excluded before it exists.
+let rec isLabelShape = (t: SchemaType.schemaType): bool =>
+  switch t {
+  | ScalarString => true
+  | Nullable(inner) => isLabelShape(inner)
+  | _ => 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 =>
+  switch t {
+  | Enum(_, _) => true
+  | Nullable(inner) => isStatusShape(inner)
+  | _ => false
+  }
+
+// Field names that say "this one is the record's name" in the only way
+// available short of the `@displayName` annotation. Matched case-insensitively
+// and *exactly*: `customerName` holds a customer's name, not this record's.
+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"` (convention; mirrors how
-//      labelField falls back to a conventionally-named string field).
+//   2. Field literally named `"status"` 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 = (
+  ~entityName: string,
   stateSchema: S.t<unknown>,
 ): option<string> => {
   let annotated = switch Reventless.StateAnnotations.getSpec(stateSchema) {
@@ -37,40 +64,96 @@ let statusFieldFromStateSchema = (
     switch stateSchema {
     | Object({items}) =>
       items
-      ->Array.find(item => item.location == "status")
+      ->Array.find(item =>
+        item.location == "status" && isStatusShape(shapeOfItem(~entityName, item))
+      )
       ->Option.map(item => item.location)
     | _ => None
     }
   }
 }
 
+// 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:
+// rung 1 is the author saying which field names the record, rungs 2 and 3 are
+// guesses this repo makes on their behalf, and rung 4 is the admission that
+// there was nothing to guess from. Convention and position are both guesses and
+// nothing here branches on the difference — but a conventional name is the one a
+// client can independently arrive at, while a positional pick is a fact only
+// this side knows.
+type labelFieldSource =
+  | Annotation
+  | Convention
+  | Position
+  | Fallback
+
+let labelFieldSourceToString = (s: labelFieldSource): string =>
+  switch s {
+  | Annotation => "annotation"
+  | Convention => "convention"
+  | Position => "position"
+  | Fallback => "fallback"
+  }
+
+type labelResolution = {
+  field: string,
+  searchableFields: array<string>,
+  source: labelFieldSource,
+}
+
+// Resolves the field a state is named by, from a state schema.
+// Source ladder:
+//   1. @displayName spec present → "displayName" + spec.fields (raw underlying fields)
+//   2. A candidate field named `name`/`title`/`label`/`displayName`
+//   3. The first candidate in declaration order
+//   4. "id" fallback with a logged warning (no searchable fields)
+//
+// A *candidate* is a non-TAG field, not literally named `id`, whose IR shape can
+// name a record (`isLabelShape`). Rungs 2 and 3 are both guesses, and the order
+// between them matters: declaration order alone means a state gains a new name
+// whenever a field is inserted above the old one — a `placedAt` added so date
+// views have something to key off renames every order to a timestamp.
+//
+// `id` is excluded here rather than by the IR because `SchemaType` treats a name
+// that short as an ordinary string; every other reference — `*Id`/`*Ids`, a DCB
+// tag, a `Reference.to` — is already an `EntityId` there.
 let labelFieldsFromStateSchema = (
   ~entityName: string,
   stateSchema: S.t<unknown>,
-): (string, array<string>) =>
+): labelResolution =>
   switch Reventless.DisplayName.getSpec(stateSchema) {
-  | Some(spec) => ("displayName", spec.fields)
+  | Some(spec) => {field: "displayName", searchableFields: spec.fields, source: Annotation}
   | None =>
-    let firstStringItem = switch stateSchema {
+    let candidates = switch stateSchema {
     | Object({items}) =>
-      items->Array.find(item =>
+      items->Array.filter(item =>
         item.location != "TAG" &&
-        !isIdLikeFieldName(item.location) &&
-        switch item.schema {
-        | String(_) => true
-        | _ => false
-        }
+        item.location != "id" &&
+        isLabelShape(shapeOfItem(~entityName, item))
       )
-    | _ => None
+    | _ => []
+    }
+    let conventional = candidates->Array.find(item => {
+      let lower = item.location->String.toLowerCase
+      conventionalLabelNames->Array.some(n => n == lower)
+    })
+    let picked = switch conventional {
+    | Some(item) => Some((item, Convention))
+    | None => candidates->Array.get(0)->Option.map(item => (item, Position))
     }
-    switch firstStringItem {
-    | Some(item) => (item.location, [item.location])
+    switch picked {
+    | Some((item, source)) => {
+        field: item.location,
+        searchableFields: [item.location],
+        source,
+      }
     | None =>
       log.warn(
         ~comp="Plugin_Structure",
         `${entityName}: no @displayName annotation and no suitable string field — labelField falls back to "id"`,
       )
-      ("id", [])
+      {field: "id", searchableFields: [], source: Fallback}
     }
   }
 
@@ -398,23 +481,34 @@ let make = (
   // An unqualified store belongs to the declaring plugin, so every collected
   // entry is qualified to `{plugin}.{store}` — one shape, and the string is
   // directly the store's identity. Many fields legitimately name one store, so
-  // the result is deduplicated.
-
-  let storesFromProperties = (properties: dict<S.t<unknown>>): array<string> =>
+  // the key set is deduplicated.
+  //
+  // Each collected entry keeps its declaration site `(component, field)` as
+  // provenance, and `requiredStores` is derived from the collected entries —
+  // one walk, so the capability manifest's provenance and the deploy's key set
+  // cannot come from different readings of the schemas.
+
+  let storesFromProperties = (~component, properties: dict<S.t<unknown>>): array<
+    Reventless.Plugin.requiredStoreDeclaration,
+  > =>
     properties
     ->Dict.toArray
-    ->Array.filterMap(((_, fieldSchema)) =>
-      Reventless.StorageRef.getStore(fieldSchema)->Option.map(target =>
-        target.plugin->Option.getOr(name) ++ "." ++ target.store
-      )
+    ->Array.filterMap(((field, fieldSchema)) =>
+      Reventless.StorageRef.getStore(fieldSchema)->Option.map(target => {
+        Reventless.Plugin.store: target.plugin->Option.getOr(name) ++ "." ++ target.store,
+        component,
+        field,
+      })
     )
 
   // Commands and events are unions of per-variant objects; state is a single
   // object. Both reduce to "the properties of every object in this schema".
-  let storesFromSchema = (schema: S.t<unknown>): array<string> => {
+  let storesFromSchema = (~component, schema: S.t<unknown>): array<
+    Reventless.Plugin.requiredStoreDeclaration,
+  > => {
     let fromVariant = v =>
       switch v {
-      | S.Object({properties}) => storesFromProperties(properties)
+      | S.Object({properties}) => storesFromProperties(~component, properties)
       | _ => []
       }
     switch schema {
@@ -423,37 +517,82 @@ let make = (
     }
   }
 
-  let requiredStores =
+  let compareDeclarations = (
+    a: Reventless.Plugin.requiredStoreDeclaration,
+    b: Reventless.Plugin.requiredStoreDeclaration,
+  ) => {
+    let byStore = String.compare(a.store, b.store)
+    if byStore != Ordering.equal {
+      byStore
+    } else {
+      let byComponent = String.compare(a.component, b.component)
+      if byComponent != Ordering.equal {
+        byComponent
+      } else {
+        String.compare(a.field, b.field)
+      }
+    }
+  }
+
+  // The (component, schema) sites the store walk reads. One list feeds both the
+  // declared-store collection and the heuristic lint below, so a field is read
+  // exactly once: either its declaration is collected, or its name is eligible
+  // to warn — never a third reading that could disagree with both.
+  let storeDeclarationSites: array<(string, S.t<unknown>)> =
     [
-      aggregates->Array.flatMap((module(A: ReventlessInfra.Aggregate.T with type api = api)) =>
-        Array.concat(
-          storesFromSchema(A.Spec.commandSchema->S.castToUnknown),
-          storesFromSchema(A.Spec.eventSchema->S.castToUnknown),
-        )
-      ),
-      stateChangeSlices->Array.flatMap((module(SCS: ReventlessInfra.StateChangeSlice.T)) =>
-        Array.concat(
-          storesFromSchema(SCS.Spec.commandSchema->S.castToUnknown),
-          storesFromSchema(SCS.Spec.eventSchema->S.castToUnknown),
-        )
-      ),
-      stateViewSlices->Array.flatMap((module(SVS: ReventlessInfra.StateViewSlice.T)) =>
-        storesFromSchema(SVS.Spec.stateSchema->S.castToUnknown)
-      ),
-      readModels->Array.flatMap((
+      aggregates->Array.flatMap((module(A: ReventlessInfra.Aggregate.T with type api = api)) => [
+        (A.Spec.name, A.Spec.commandSchema->S.castToUnknown),
+        (A.Spec.name, A.Spec.eventSchema->S.castToUnknown),
+      ]),
+      stateChangeSlices->Array.flatMap((module(SCS: ReventlessInfra.StateChangeSlice.T)) => [
+        (SCS.Spec.name, SCS.Spec.commandSchema->S.castToUnknown),
+        (SCS.Spec.name, SCS.Spec.eventSchema->S.castToUnknown),
+      ]),
+      stateViewSlices->Array.map((module(SVS: ReventlessInfra.StateViewSlice.T)) => (
+        SVS.Spec.name,
+        SVS.Spec.stateSchema->S.castToUnknown,
+      )),
+      readModels->Array.map((
         module(R: ReventlessInfra.ReadModel.T with type api = api and type role = role),
-      ) => storesFromSchema(R.Spec.stateSchema->S.castToUnknown)),
-      automationSlices->Array.flatMap((module(AS: ReventlessInfra.AutomationSlice.T)) =>
-        storesFromSchema(AS.Spec.commandSchema->S.castToUnknown)
-      ),
-      inboundTranslationSlices->Array.flatMap((
+      ) => (R.Spec.name, R.Spec.stateSchema->S.castToUnknown)),
+      automationSlices->Array.map((module(AS: ReventlessInfra.AutomationSlice.T)) => (
+        AS.Spec.name,
+        AS.Spec.commandSchema->S.castToUnknown,
+      )),
+      inboundTranslationSlices->Array.map((
         module(ITS: ReventlessInfra.InboundTranslationSlice.T),
-      ) => storesFromSchema(ITS.Spec.commandSchema->S.castToUnknown)),
-    ]
-    ->Array.flat
+      ) => (ITS.Spec.name, ITS.Spec.commandSchema->S.castToUnknown)),
+    ]->Array.flat
+
+  // Sorted so the emitted manifest is deterministic; identical triples collapse
+  // (one store named by a component's command field and again by its event
+  // field under the same field name is one declaration site).
+  let requiredStoreDeclarations =
+    storeDeclarationSites
+    ->Array.flatMap(((component, schema)) => storesFromSchema(~component, schema))
+    ->Array.toSorted(compareDeclarations)
+    ->Array.reduce([], (acc, d) =>
+      switch acc->Array.last {
+      | Some(prev) if prev == d => acc
+      | _ => acc->Array.concat([d])
+      }
+    )
+
+  let requiredStores =
+    requiredStoreDeclarations
+    ->Array.map(d => d.store)
     ->Belt.Set.String.fromArray
     ->Belt.Set.String.toArray
 
+  // Heuristic-only matches — a field *named* like a stored-object ref with no
+  // `@storageRef` — warn and provision nothing. Declaration outranks inference;
+  // the warning names the annotation that would settle it.
+  storeDeclarationSites->Array.forEach(((component, schema)) =>
+    Capability_Inference.scanSchema(~component, schema)->Array.forEach(w =>
+      log.warn(~comp="Plugin_Structure", Capability_Inference.message(w))
+    )
+  )
+
   // ── Build queryable defs ───────────────────────────────────────────────────
   //
   // Internal ReadModels and StateViewSlices (marked `@@reventless.visibility(Internal)`)
@@ -475,10 +614,7 @@ let make = (
     ) => {
       let qf = Api_Naming.queryFieldNamesForReadModel(~plugin=name, ~name=R.Spec.name)
       let stateSchema = R.Spec.stateSchema->S.castToUnknown
-      let (labelField, searchableFields) = labelFieldsFromStateSchema(
-        ~entityName=R.Spec.name,
-        stateSchema,
-      )
+      let label = labelFieldsFromStateSchema(~entityName=R.Spec.name, stateSchema)
       // The events this read model projects from, qualified to the plugin's event ids so
       // they match the producers' nodes in the graph. Was empty — which dropped projection
       // edges for any event reaching the read model via a DCB-log-sourced mapping (a classic
@@ -490,9 +626,10 @@ let make = (
         schema: stateSchema->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
         consumedEventTypes: consumed,
         linkedWriteSide: linkedWriteSideFor(consumed),
-        labelField,
-        searchableFields,
-        statusField: statusFieldFromStateSchema(stateSchema),
+        labelField: label.field,
+        searchableFields: label.searchableFields,
+        labelFieldSource: Some(labelFieldSourceToString(label.source)),
+        statusField: statusFieldFromStateSchema(~entityName=R.Spec.name, stateSchema),
         visibility: visibilityTag(R.Spec.visibility),
         chapter: chapterOf(R.Spec.name),
       }: Reventless.Plugin.queryableDef)
@@ -503,19 +640,17 @@ let make = (
       let qf = Api_Naming.queryFieldNamesForStateView(~plugin=name, ~viewName=SVS.Spec.name)
       let (_, consumed) = svsConsumed->Array.getUnsafe(i)
       let stateSchema = SVS.Spec.stateSchema->S.castToUnknown
-      let (labelField, searchableFields) = labelFieldsFromStateSchema(
-        ~entityName=SVS.Spec.name,
-        stateSchema,
-      )
+      let label = labelFieldsFromStateSchema(~entityName=SVS.Spec.name, stateSchema)
       ({
         Reventless.Plugin.name: SVS.Spec.name,
         queryField: qf.listFieldName,
         schema: stateSchema->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
         consumedEventTypes: consumed,
         linkedWriteSide: linkedWriteSideFor(consumed),
-        labelField,
-        searchableFields,
-        statusField: statusFieldFromStateSchema(stateSchema),
+        labelField: label.field,
+        searchableFields: label.searchableFields,
+        labelFieldSource: Some(labelFieldSourceToString(label.source)),
+        statusField: statusFieldFromStateSchema(~entityName=SVS.Spec.name, stateSchema),
         visibility: visibilityTag(SVS.Spec.visibility),
         chapter: chapterOf(SVS.Spec.name),
       }: Reventless.Plugin.queryableDef)
@@ -676,5 +811,6 @@ let make = (
     extensions: extensionDefs,
     extensionPoints: Some(extensionPointDefs),
     requiredStores: Some(requiredStores),
+    requiredStoreDeclarations: Some(requiredStoreDeclarations),
   }
 }