@reventlessdev/reventless-core 3.0.0-alpha.222 → 3.0.0-alpha.224

package/src/components/Api/GraphQL_FragmentGenerator.res.mjs

@@ -3,6 +3,7 @@
 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 Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Api_Naming$ReventlessCore from "./Api_Naming.res.mjs";
 import * as SchemaType$ReventlessCore from "./SchemaType.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "./GraphQL_Stitcher.res.mjs";
@@ -72,7 +73,20 @@ function fromSchemaType(_required, _asInputOpt, _st, collectedTypes, seenTypes)
           }
           return name$1 + bang;
         case "Semantic" :
-          _st = st._1;
+          let inner = st._1;
+          if (typeof inner === "object" && inner.TAG === "ObjectRef") {
+            let name$2 = inner._0;
+            if (Stdlib_Option.isSome(SchemaType$ReventlessCore.canonicalName(st._0.id))) {
+              let typeName = asInput ? name$2 + "Input" : name$2;
+              if (!seenTypes.has(typeName)) {
+                seenTypes.add(typeName);
+                let typeDef$1 = objectRefToGraphQL(asInput, typeName, inner._1, collectedTypes, seenTypes);
+                collectedTypes.push(typeDef$1);
+              }
+              return typeName + bang;
+            }
+          }
+          _st = inner;
           _asInputOpt = asInput;
           continue;
       }
@@ -172,11 +186,55 @@ function scalarOfSchemaType(_st) {
   };
 }
 
-function deriveServerCapability(schema) {
-  let spec = StateAnnotations$Reventless.getSpec(schema);
-  if (spec === undefined) {
-    return emptyCapability;
+function isKeyFieldName(name) {
+  if (name.length > 2) {
+    return name.endsWith("Id");
+  } else {
+    return false;
+  }
+}
+
+function resolveKeyField(entityName, schema) {
+  let match = StateAnnotations$Reventless.getSpec(schema);
+  let declared = match !== undefined ? match.ids[0] : undefined;
+  if (declared !== undefined) {
+    return [
+      declared,
+      "annotation"
+    ];
+  }
+  let candidates = Object.keys(Stdlib_Option.getOr(SchemaType$ReventlessCore.fromSuryObject("", schema), {})).filter(isKeyFieldName);
+  let singular = Api_Naming$ReventlessCore.singularize(Api_Naming$ReventlessCore.stripViewSuffix(entityName));
+  let conventional = singular.slice(0, 1).toLowerCase() + singular.slice(1, singular.length) + "Id";
+  if (candidates.includes(conventional)) {
+    return [
+      conventional,
+      "convention"
+    ];
+  } else if (candidates.length === 1) {
+    return [
+      candidates[0],
+      "sole"
+    ];
+  } else {
+    return;
+  }
+}
+
+function entityNameOf(entry) {
+  let n = entry.specName;
+  if (n !== undefined) {
+    return n;
+  }
+  let i = entry.returnTypeName.lastIndexOf("_");
+  if (i !== -1) {
+    return entry.returnTypeName.slice(i + 1 | 0, entry.returnTypeName.length);
+  } else {
+    return entry.returnTypeName;
   }
+}
+
+function deriveServerCapability(entityName, schema) {
   let fieldTypes = Stdlib_Option.getOr(SchemaType$ReventlessCore.fromSuryObject("", schema), {});
   let scalarOf = fieldName => Stdlib_Option.mapOr(fieldTypes[fieldName], "String", scalarOfSchemaType);
   let filterFields = [];
@@ -201,26 +259,35 @@ function deriveServerCapability(schema) {
       return;
     }
   };
-  spec.ids.forEach(name => {
-    pushFilter(name, false);
-    pushSort(name);
-  });
-  spec.compositeIds.forEach(name => pushFilter(name, false));
-  spec.subIds.forEach(name => {
-    pushFilter(name, true);
-    pushSort(name);
-  });
-  spec.compositeSubIds.forEach(name => {
-    pushFilter(name, true);
-    pushSort(name);
-  });
-  spec.indexes.forEach(param => {
-    let name = param[0];
-    pushFilter(name, false);
-    pushSort(name);
-  });
-  spec.scan.forEach(name => pushFilter(name, false));
-  spec.scanSort.forEach(pushSort);
+  let spec = StateAnnotations$Reventless.getSpec(schema);
+  if (spec !== undefined) {
+    spec.ids.forEach(name => {
+      pushFilter(name, false);
+      pushSort(name);
+    });
+    spec.compositeIds.forEach(name => pushFilter(name, false));
+    spec.subIds.forEach(name => {
+      pushFilter(name, true);
+      pushSort(name);
+    });
+    spec.compositeSubIds.forEach(name => {
+      pushFilter(name, true);
+      pushSort(name);
+    });
+    spec.indexes.forEach(param => {
+      let name = param[0];
+      pushFilter(name, false);
+      pushSort(name);
+    });
+    spec.scan.forEach(name => pushFilter(name, false));
+    spec.scanSort.forEach(pushSort);
+  }
+  let match = resolveKeyField(entityName, schema);
+  if (match !== undefined) {
+    let field = match[0];
+    pushFilter(field, false);
+    pushSort(field);
+  }
   return {
     filterFields: filterFields,
     sortFields: sortFields
@@ -435,7 +502,7 @@ function generate(mutationEntries, queryEntries) {
           types.push(t);
         });
       }
-      let capability = deriveServerCapability(entry.stateSchema);
+      let capability = deriveServerCapability(entityNameOf(entry), entry.stateSchema);
       let connectionFilterTypeName = entry.returnTypeName + "Filter";
       if (!seenTypes.has(connectionFilterTypeName)) {
         seenTypes.add(connectionFilterTypeName);
@@ -491,6 +558,9 @@ export {
   deriveSubIdFilterType,
   emptyCapability,
   scalarOfSchemaType,
+  isKeyFieldName,
+  resolveKeyField,
+  entityNameOf,
   deriveServerCapability,
   validateScanSortAlignment,
   deriveConnectionFilterType,
@@ -503,4 +573,4 @@ export {
   deriveMutationFieldFromObject,
   generate,
 }
-/* SchemaType-ReventlessCore Not a pure module */
+/* Api_Naming-ReventlessCore Not a pure module */

package/src/components/Api/QueryDbListQuery.res

@@ -71,15 +71,16 @@ let buildConnection = (
 }
 
 // Compute the Relay connection response (edges + pageInfo) for `items` under the
-// GraphQL args. `decodeLocalId` maps a possibly-Relay-encoded id to its local id
-// (the resolver passes DomainGraphQL_Server.decodeGlobalId); everything else is
-// pure over the item array.
+// GraphQL args. `decodeLocalId` maps a possibly-Relay-encoded id to its local id;
+// it defaults to the shared rule so every caller applies the same one — the AWS
+// Lambda used to pass a no-op here, which silently made `filter.ids` reject a
+// global id on that provider only. Everything else is pure over the item array.
 let run = (
   ~items: array<JSON.t>,
   ~argsDict: Dict.t<JSON.t>,
   ~capability: GraphQL_FragmentGenerator.serverCapability,
   ~labelField: string,
-  ~decodeLocalId: string => option<string>,
+  ~decodeLocalId: string => option<string>=Api_Ids.toLocalId,
 ): JSON.t => {
   let filterDict =
     argsDict->Dict.get("filter")->Option.flatMap(JSON.Decode.object)->Option.getOr(Dict.make())
@@ -145,11 +146,18 @@ let run = (
       getLabel(item)->String.toLowerCase->String.startsWith(p->String.toLowerCase)
     | _ => true
     }
+    // Either id form matches, in both directions: the argument may be a Relay
+    // global id while the row carries its storage key (the normal case — every
+    // door but `node` reports the storage key), and the row may carry a global id
+    // where some caller stamped one. Decoding only the row's id, as this did,
+    // covered just the second.
     let passIds = switch ids {
     | Some(idList) if idList->Array.length > 0 =>
       let itemId = getId(item)
       let itemLocalId = decodeLocalId(itemId)
-      idList->Array.some(i => i == itemId || itemLocalId == Some(i))
+      idList->Array.some(i =>
+        i == itemId || itemLocalId == Some(i) || decodeLocalId(i) == Some(itemId)
+      )
     | _ => true
     }
     let passPerField = perFieldChecks->Array.every(check => check(item))

package/src/components/Api/QueryDbListQuery.res.mjs

@@ -5,6 +5,7 @@ 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 Stdlib_Nullable from "@rescript/runtime/lib/es6/Stdlib_Nullable.js";
 import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Api_Ids$ReventlessCore from "./Api_Ids.res.mjs";
 
 function encodeCursor(value) {
   return btoa(value);
@@ -47,7 +48,8 @@ function buildConnection(pageItems, hasNextPage, hasPreviousPage, cursorValueOf)
   };
 }
 
-function run(items, argsDict, capability, labelField, decodeLocalId) {
+function run(items, argsDict, capability, labelField, decodeLocalIdOpt) {
+  let decodeLocalId = decodeLocalIdOpt !== undefined ? decodeLocalIdOpt : Api_Ids$ReventlessCore.toLocalId;
   let filterDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(argsDict["filter"], Stdlib_JSON.Decode.object), {});
   let search = Stdlib_Option.flatMap(filterDict["search"], Stdlib_JSON.Decode.string);
   let searchPrefix = Stdlib_Option.flatMap(filterDict["searchPrefix"], Stdlib_JSON.Decode.string);
@@ -83,10 +85,10 @@ function run(items, argsDict, capability, labelField, decodeLocalId) {
       let itemId = getId(item);
       let itemLocalId = decodeLocalId(itemId);
       passIds = ids.some(i => {
-        if (i === itemId) {
+        if (i === itemId || Primitive_object.equal(itemLocalId, i)) {
           return true;
         } else {
-          return Primitive_object.equal(itemLocalId, i);
+          return Primitive_object.equal(decodeLocalId(i), itemId);
         }
       });
     } else {

package/src/components/Api/SchemaType.res

@@ -32,8 +32,34 @@ let isIdsFieldName = (name: string): bool => {
   len > 3 && String.endsWith(lower, "ids")
 }
 
+/**
+The GraphQL type name a semantic **composite** is emitted under.
+
+The branded scalars are absent on purpose: they refine a `string` or a number
+without changing its shape, so each is already a `String` or a `Float` in GraphQL
+and has no definition that could be duplicated. Only the semantics that turn a
+field into an object or an enum need a name of their own — without one, the same
+type is emitted once per *field* that uses it, under the field path that reached
+it (`Catalog_AddProductPriceCurrency`, `Ordering_SyncNewProductPriceCurrency`, …
+six copies of ISO 4217 in one example schema).
+
+Naming them is what makes the definitions identical across plugins, which is the
+property merged-API composition needs: AppSync unions same-named types from
+different source APIs, and a union of identical definitions is that definition.
+The `Node` / `PageInfo` / `SortOrder` base types already rely on exactly this.
+*/
+let semanticCompositeNames = [
+  (Reventless.Semantic.Id.money, "Money"),
+  (Reventless.Semantic.Id.dateRange, "DateRange"),
+  (Reventless.Semantic.Id.geoPoint, "GeoPoint"),
+]
+
+let canonicalName = (id: string): option<string> =>
+  semanticCompositeNames
+  ->Array.find(((semanticId, _)) => semanticId == id)
+  ->Option.map(((_, name)) => name)
+
 let rec fromSury = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): schemaType => {
-  let shape = shapeOf(~parentName, ~fieldName, schema)
   // Semantics the IR already has a dedicated shape for keep it: `dateTime` and
   // `reference` are read below via `isDateTime` / `getTarget`, both of which now
   // consult the generic marker, and their `format` output is a published
@@ -42,8 +68,16 @@ let rec fromSury = (~parentName: string, ~fieldName: string, schema: S.t<unknown
   switch Reventless.Semantic.get(schema) {
   | Some({id} as sem)
     if id !== Reventless.Semantic.Id.dateTime && id !== Reventless.Semantic.Id.reference =>
+    // A composite is one type wherever it appears, so its shape is walked under
+    // its own name rather than under the field path that reached it. That
+    // renames what is nested inside it too — `Money`'s currency enum becomes
+    // `MoneyCurrency` for every field, rather than one enum per price field.
+    let shape = switch canonicalName(id) {
+    | Some(name) => shapeOf(~parentName=name, ~fieldName="", schema)
+    | None => shapeOf(~parentName, ~fieldName, schema)
+    }
     Semantic(sem, shape)
-  | _ => shape
+  | _ => shapeOf(~parentName, ~fieldName, schema)
   }
 }
 

package/src/components/Api/SchemaType.res.mjs

@@ -27,22 +27,41 @@ function isIdsFieldName(name) {
   }
 }
 
+let semanticCompositeNames = [
+  [
+    Semantic$Reventless.Id.money,
+    "Money"
+  ],
+  [
+    Semantic$Reventless.Id.dateRange,
+    "DateRange"
+  ],
+  [
+    Semantic$Reventless.Id.geoPoint,
+    "GeoPoint"
+  ]
+];
+
+function canonicalName(id) {
+  return Stdlib_Option.map(semanticCompositeNames.find(param => param[0] === id), param => param[1]);
+}
+
 function fromSury(parentName, fieldName, schema) {
-  let shape = shapeOf(parentName, fieldName, schema);
   let sem = Semantic$Reventless.get(schema);
   if (sem === undefined) {
-    return shape;
+    return shapeOf(parentName, fieldName, schema);
   }
   let id = sem.id;
-  if (id !== Semantic$Reventless.Id.dateTime && id !== Semantic$Reventless.Id.reference) {
-    return {
-      TAG: "Semantic",
-      _0: sem,
-      _1: shape
-    };
-  } else {
-    return shape;
+  if (id === Semantic$Reventless.Id.dateTime || id === Semantic$Reventless.Id.reference) {
+    return shapeOf(parentName, fieldName, schema);
   }
+  let name = canonicalName(id);
+  let shape = name !== undefined ? shapeOf(name, "", schema) : shapeOf(parentName, fieldName, schema);
+  return {
+    TAG: "Semantic",
+    _0: sem,
+    _1: shape
+  };
 }
 
 function shapeOf(parentName, fieldName, schema) {
@@ -195,6 +214,8 @@ export {
   isDateTime,
   isIdFieldName,
   isIdsFieldName,
+  semanticCompositeNames,
+  canonicalName,
   fromSury,
   shapeOf,
   optionalFieldNames,

package/src/plugin/component/Plugin_Structure.res

@@ -164,20 +164,29 @@ let labelFieldsFromStateSchema = (
 // because its components never pass through `make` — has to derive its defs the
 // same way, and a second copy of this walk would be free to drift from this one.
 
+// A variant's declared cross-entity references. Shared by the command and event
+// walks because the two ask the identical question of identical field dicts, and
+// the question is `getFieldTarget` rather than `getTarget`: a reference declared
+// on an `array<string>` field sits on the element schema. Collecting it in one
+// place is what stops one walk from being taught that and the other not.
+let extractReferences = (properties: dict<S.t<unknown>>): array<
+  Reventless.Plugin.fieldReference,
+> =>
+  properties
+  ->Dict.toArray
+  ->Array.filterMap(((fieldName, fieldSchema)) =>
+    Reventless.Reference.getFieldTarget(fieldSchema)->Option.map(target => (
+      {
+        Reventless.Plugin.fieldName,
+        entity: target.entity,
+        plugin: target.plugin,
+      }: Reventless.Plugin.fieldReference
+    ))
+  )
+
 let toEventDef = (v: S.t<unknown>): option<Reventless.Plugin.eventDef> => {
   let mkDef = (~variantName, ~properties) => {
-    let references =
-      properties
-      ->Dict.toArray
-      ->Array.filterMap(((fieldName, fieldSchema)) =>
-        Reventless.Reference.getTarget(fieldSchema)->Option.map(target => (
-          {
-            Reventless.Plugin.fieldName,
-            entity: target.entity,
-            plugin: target.plugin,
-          }: Reventless.Plugin.fieldReference
-        ))
-      )
+    let references = extractReferences(properties)
     ({
       Reventless.Plugin.name: variantName,
       // Derived for the same reason as `commandDef.schema`: an event's field
@@ -301,18 +310,7 @@ let make = (
     // `S.literal("Archive")` string rather than an `{TAG, ...}` object.
     let mkDef = (~variantName, ~properties) => {
       let (level, aggregateIdField) = commandLevelAndId(~isAggregate, ~variantName, properties)
-      let references =
-        properties
-        ->Dict.toArray
-        ->Array.filterMap(((fieldName, fieldSchema)) =>
-          Reventless.Reference.getTarget(fieldSchema)->Option.map(target => (
-            {
-              Reventless.Plugin.fieldName,
-              entity: target.entity,
-              plugin: target.plugin,
-            }: Reventless.Plugin.fieldReference
-          ))
-        )
+      let references = extractReferences(properties)
       // Per-variant `allowedStates` lives on the *parent* command schema
       // (the PPX attaches a single dict<variantName, [|states|]> via
       // markAllowedStates). Look it up by variant name; back-compat
@@ -652,6 +650,12 @@ let make = (
       let qf = Api_Naming.queryFieldNamesForReadModel(~plugin=name, ~name=R.Spec.name)
       let stateSchema = R.Spec.stateSchema->S.castToUnknown
       let label = labelFieldsFromStateSchema(~entityName=R.Spec.name, stateSchema)
+      // The same call the capability deriver makes, so the published key and the
+      // key the generated filter/order-by is built from cannot disagree.
+      let keyField = GraphQL_FragmentGenerator.resolveKeyField(
+        ~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
@@ -669,6 +673,12 @@ let make = (
         statusField: statusFieldFromStateSchema(~entityName=R.Spec.name, stateSchema),
         visibility: visibilityTag(R.Spec.visibility),
         chapter: chapterOf(R.Spec.name),
+        // Taken from the `qf` record, never re-derived: `Api_Naming` is the only
+        // place that decides how `Products`/`Categories` singularise, and the
+        // point of publishing the name is that a consumer stops guessing it.
+        singleQueryField: Some(qf.singleFieldName),
+        idField: keyField->Option.map(((f, _)) => f),
+        idFieldSource: keyField->Option.map(((_, rung)) => rung),
       }: Reventless.Plugin.queryableDef)
     })
 
@@ -678,6 +688,10 @@ let make = (
       let (_, consumed) = svsConsumed->Array.getUnsafe(i)
       let stateSchema = SVS.Spec.stateSchema->S.castToUnknown
       let label = labelFieldsFromStateSchema(~entityName=SVS.Spec.name, stateSchema)
+      let keyField = GraphQL_FragmentGenerator.resolveKeyField(
+        ~entityName=SVS.Spec.name,
+        stateSchema,
+      )
       ({
         Reventless.Plugin.name: SVS.Spec.name,
         queryField: qf.listFieldName,
@@ -690,6 +704,9 @@ let make = (
         statusField: statusFieldFromStateSchema(~entityName=SVS.Spec.name, stateSchema),
         visibility: visibilityTag(SVS.Spec.visibility),
         chapter: chapterOf(SVS.Spec.name),
+        singleQueryField: Some(qf.singleFieldName),
+        idField: keyField->Option.map(((f, _)) => f),
+        idFieldSource: keyField->Option.map(((_, rung)) => rung),
       }: Reventless.Plugin.queryableDef)
     })
 

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

@@ -19,6 +19,7 @@ import * as SuryToJsonSchema$ReventlessCore from "../../components/Api/SuryToJso
 import * as Capability_Inference$ReventlessCore from "./Capability_Inference.res.mjs";
 import * as ApiTargetStateHelpers$ReventlessCore from "../../components/Api/ApiTargetStateHelpers.res.mjs";
 import * as ApiAllowedStatesHelpers$ReventlessCore from "../../components/Api/ApiAllowedStatesHelpers.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "../../components/Api/GraphQL_FragmentGenerator.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
@@ -140,16 +141,20 @@ function labelFieldsFromStateSchema(entityName, stateSchema) {
   };
 }
 
+function extractReferences(properties) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let fieldName = param[0];
+    return Stdlib_Option.map(Reference$Reventless.getFieldTarget(param[1]), target => ({
+      fieldName: fieldName,
+      entity: target.entity,
+      plugin: target.plugin
+    }));
+  });
+}
+
 function toEventDef(v) {
   let mkDef = (variantName, properties) => {
-    let references = Stdlib_Array.filterMap(Object.entries(properties), param => {
-      let fieldName = param[0];
-      return Stdlib_Option.map(Reference$Reventless.getTarget(param[1]), target => ({
-        fieldName: fieldName,
-        entity: target.entity,
-        plugin: target.plugin
-      }));
-    });
+    let references = extractReferences(properties);
     return {
       name: variantName,
       schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v)),
@@ -267,14 +272,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
   let toCommandDef = (isAggregate, mutationFieldFor, parentSchema, v) => {
     let mkDef = (variantName, properties) => {
       let match = commandLevelAndId(isAggregate, variantName, properties);
-      let references = Stdlib_Array.filterMap(Object.entries(properties), param => {
-        let fieldName = param[0];
-        return Stdlib_Option.map(Reference$Reventless.getTarget(param[1]), target => ({
-          fieldName: fieldName,
-          entity: target.entity,
-          plugin: target.plugin
-        }));
-      });
+      let references = extractReferences(properties);
       let allowedStates = ApiAllowedStatesHelpers$ReventlessCore.getAllowedStates(parentSchema, variantName);
       let targetState = ApiTargetStateHelpers$ReventlessCore.getTargetState(parentSchema, variantName);
       let apiExposed = false;
@@ -503,6 +501,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let qf = Api_Naming$ReventlessCore.queryFieldNamesForReadModel(name, R.Spec.name, undefined);
     let stateSchema = R.Spec.stateSchema;
     let label = labelFieldsFromStateSchema(R.Spec.name, stateSchema);
+    let keyField = GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField(R.Spec.name, stateSchema);
     let consumed = qualify(name, R.consumedEventNames);
     return {
       name: R.Spec.name,
@@ -515,7 +514,10 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       labelFieldSource: labelFieldSourceToString(label.source),
       statusField: statusFieldFromStateSchema(R.Spec.name, stateSchema),
       visibility: visibilityTag(R.Spec.visibility),
-      chapter: componentChapters[R.Spec.name]
+      chapter: componentChapters[R.Spec.name],
+      singleQueryField: qf.singleFieldName,
+      idField: Stdlib_Option.map(keyField, param => param[0]),
+      idFieldSource: Stdlib_Option.map(keyField, param => param[1])
     };
   });
   let stateViewDefs = stateViewSlices.map((SVS, i) => {
@@ -524,6 +526,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
     let consumed = match[1];
     let stateSchema = SVS.Spec.stateSchema;
     let label = labelFieldsFromStateSchema(SVS.Spec.name, stateSchema);
+    let keyField = GraphQL_FragmentGenerator$ReventlessCore.resolveKeyField(SVS.Spec.name, stateSchema);
     return {
       name: SVS.Spec.name,
       queryField: qf.listFieldName,
@@ -535,7 +538,10 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       labelFieldSource: labelFieldSourceToString(label.source),
       statusField: statusFieldFromStateSchema(SVS.Spec.name, stateSchema),
       visibility: visibilityTag(SVS.Spec.visibility),
-      chapter: componentChapters[SVS.Spec.name]
+      chapter: componentChapters[SVS.Spec.name],
+      singleQueryField: qf.singleFieldName,
+      idField: Stdlib_Option.map(keyField, param => param[0]),
+      idFieldSource: Stdlib_Option.map(keyField, param => param[1])
     };
   });
   let stateChangeDefs = stateChangeSlices.map((SCS, i) => {
@@ -653,6 +659,7 @@ export {
   statusFieldFromStateSchema,
   labelFieldSourceToString,
   labelFieldsFromStateSchema,
+  extractReferences,
   toEventDef,
   extractEventDefs,
   extractErrorDefs,