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

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.224 (2026-08-11)
+
+### Bug Fixes
+
+* **api:** one id contract across the read-side query doors ([c52fac2](https://github.com/ReventlessDev/reventless-core/commit/c52fac2bee87b3dd1fa33b4970a74f3cd3866280))
+* feat(core)!: name semantic composites once instead of once per field ([09536ba](https://github.com/ReventlessDev/reventless-core/commit/09536badf338f898b24d749270acd5c7df851ddb))
+### Features
+
+* **api:** infer a queryable's key field and publish its provenance ([c835a42](https://github.com/ReventlessDev/reventless-core/commit/c835a42a0da07cdc4a3f010212e1f340a4a0ca27))
+* **plugin:** publish singleQueryField on queryableDef ([a724ab5](https://github.com/ReventlessDev/reventless-core/commit/a724ab573614792c0615d68b6486b94da14f9f82))
+
+### BREAKING CHANGES
+
+* generated GraphQL type names change. A price field is now
+`MoneyInput!` in a command and `Money!` in a read model, where it was named
+after the field that carried it (`Catalog_AddProductPriceCurrency`,
+`Ordering_SyncNewProductPriceCurrency`, …). AutoUI builds its queries at
+runtime from the component-definitions manifest and adapts on its own; a client
+naming the old types in a hand-written query does not.
+
+
+
 # 3.0.0-alpha.223 (2026-08-10)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.223",
+  "version": "3.0.0-alpha.224",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -29,16 +29,16 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.3",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.4",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.3",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.3",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.4",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.4",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.133",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.107"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.134",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.108",
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin_Structure.res

@@ -121,6 +121,16 @@ let pluginReadModel: queryableDef = {
   statusField: Some("status"),
   visibility: None,
   chapter: None,
+  // The admin fragment hand-declares its query names rather than deriving them from
+  // the read-model name, so the singular is taken from the same call
+  // `PluginBaseFragment.queryNames.singleFieldName` makes — not singularised here.
+  singleQueryField: Some(Api_Naming.adminField(~name="Plugin")),
+  // No key field to name: the row id is `name@version` (`Plugin.makeId`), and the
+  // state carries the two halves separately rather than the composed key. `None`
+  // is the honest answer — the same one the resolver ladder reaches for a state
+  // with no `*Id` field.
+  idField: None,
+  idFieldSource: None,
 }
 
 let structure: pluginStructure = {

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -135,6 +135,8 @@ let pluginReadModel_labelFieldSource = "convention";
 
 let pluginReadModel_statusField = "status";
 
+let pluginReadModel_singleQueryField = Api_Naming$ReventlessCore.adminField("Plugin");
+
 let pluginReadModel = {
   name: "Plugins",
   queryField: pluginReadModel_queryField,
@@ -146,7 +148,10 @@ let pluginReadModel = {
   labelFieldSource: pluginReadModel_labelFieldSource,
   statusField: pluginReadModel_statusField,
   visibility: undefined,
-  chapter: undefined
+  chapter: undefined,
+  singleQueryField: pluginReadModel_singleQueryField,
+  idField: undefined,
+  idFieldSource: undefined
 };
 
 let structure_readModels = [pluginReadModel];

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -25,7 +25,11 @@ let sdlTypes: array<string> = [
   // with, and the two lists must stay independently evolvable.
   `type Platform_ErrorDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_WriteSideDef {\n  name: String!\n  commands: [Platform_CommandDef!]!\n  linkedViews: [String!]!\n  consistencyRead: String\n  producedEventTypes: [String!]!\n  consumedEventTypes: [String!]!\n  events: [Platform_EventDef!]!\n  errors: [Platform_ErrorDef!]!\n  chapter: String\n}`,
-  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  statusField: String\n  visibility: String\n  chapter: String\n}`,
+  // `singleQueryField` / `idField` / `idFieldSource` are nullable, not `String!`:
+  // structures persisted before the fields existed decode as `None`, a hand-rolled
+  // def may decline to state them, and a state whose key cannot be resolved has no
+  // `idField` to report.
+  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  statusField: String\n  visibility: String\n  chapter: String\n  singleQueryField: String\n  idField: String\n  idFieldSource: String\n}`,
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
@@ -111,6 +115,12 @@ let encodeQueryableDef = (r: queryableDef): JSON.t =>
     // survives the filter anyway.
     ("visibility", r.visibility->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
     ("chapter", r.chapter->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    (
+      "singleQueryField",
+      r.singleQueryField->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+    ),
+    ("idField", r.idField->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    ("idFieldSource", r.idFieldSource->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
 let encodeEventDef = (e: eventDef): JSON.t =>

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -10,7 +10,7 @@ let sdlTypes = [
   `type Platform_EventDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_ErrorDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_WriteSideDef {\n  name: String!\n  commands: [Platform_CommandDef!]!\n  linkedViews: [String!]!\n  consistencyRead: String\n  producedEventTypes: [String!]!\n  consumedEventTypes: [String!]!\n  events: [Platform_EventDef!]!\n  errors: [Platform_ErrorDef!]!\n  chapter: String\n}`,
-  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  statusField: String\n  visibility: String\n  chapter: String\n}`,
+  `type Platform_ReadSideDef {\n  name: String!\n  queryField: String!\n  schema: String!\n  consumedEventTypes: [String!]!\n  linkedWriteSide: [String!]!\n  labelField: String!\n  searchableFields: [String!]!\n  labelFieldSource: String\n  statusField: String\n  visibility: String\n  chapter: String\n  singleQueryField: String\n  idField: String\n  idFieldSource: String\n}`,
   `type Platform_AutomationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  producedCommandTypes: [String!]!\n  targetName: String\n  chapter: String\n}`,
   `type Platform_OutboundTranslationSliceDef {\n  name: String!\n  consumedEventTypes: [String!]!\n  inboundCommandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
   `type Platform_InboundTranslationSliceDef {\n  name: String!\n  commandTypes: [String!]!\n  targetName: String\n  externalSystem: String\n  chapter: String\n}`,
@@ -132,6 +132,18 @@ function encodeQueryableDef(r) {
     [
       "chapter",
       Stdlib_Option.mapOr(r.chapter, null, prim => prim)
+    ],
+    [
+      "singleQueryField",
+      Stdlib_Option.mapOr(r.singleQueryField, null, prim => prim)
+    ],
+    [
+      "idField",
+      Stdlib_Option.mapOr(r.idField, null, prim => prim)
+    ],
+    [
+      "idFieldSource",
+      Stdlib_Option.mapOr(r.idFieldSource, null, prim => prim)
     ]
   ]);
 }

package/src/components/Api/Api_Ids.res

@@ -0,0 +1,63 @@
+/**
+The one place that knows how a row's GraphQL `id` relates to its storage key.
+
+A read-side row is reachable through several id-accepting doors — the typed
+`X(id: ID!)` query, `XsByIds(ids:)`, the list `filter.ids`, and Relay's
+`node(id:)`. They used to disagree about which form they took, so the obvious
+client call `X(id: row.id)` silently returned `null`: the door took the storage
+key while the row advertised the Relay global id. The rule below is what
+`QueryDbListQuery.passIds` already applied to `filter.ids` — lifted out so every
+door applies it, and so provider adapters share one definition rather than three.
+
+Provider-neutral on purpose: the contract belongs to neither the local platform
+nor AWS.
+*/
+
+@val external btoa: string => string = "btoa"
+@val external atob: string => string = "atob"
+
+/** `btoa("<TypeName>:<localId>")` — the Relay global id for a row. */
+let encode = (~typeName: string, ~localId: string): string => btoa(`${typeName}:${localId}`)
+
+/**
+The `(typeName, localId)` pair inside a global id, or `None` when the string is
+not one. `atob` throws on non-base64 input; a decoded value with no `:` (or a
+leading one, which would mean an empty type name) is not a global id either.
+*/
+let decode = (globalId: string): option<(string, string)> =>
+  try {
+    let decoded = atob(globalId)
+    let idx = decoded->String.indexOf(":")
+    if idx > 0 {
+      Some((
+        decoded->String.slice(~start=0, ~end=idx),
+        decoded->String.slice(~start=idx + 1, ~end=decoded->String.length),
+      ))
+    } else {
+      None
+    }
+  } catch {
+  | _ => None
+  }
+
+/**
+The storage key a global id wraps, or `None` if the string is not one.
+
+Deliberately NOT a `string => string` that "normalises" an id: a raw key that
+happens to be valid base64 would be silently rewritten into something that
+matches nothing. Callers look the raw id up first and fall back to this — see
+`alternateKey`.
+*/
+let toLocalId = (id: string): option<string> => decode(id)->Option.map(((_, localId)) => localId)
+
+/**
+The other key worth trying when a lookup by `id` found nothing: the storage key
+inside it, if it was a global id. Ordering matters — the raw id is always tried
+first, so a key that merely looks like base64 keeps resolving to its own row and
+this only ever runs on a miss.
+*/
+let alternateKey = (id: string): option<string> =>
+  switch toLocalId(id) {
+  | Some(localId) if localId != id => Some(localId)
+  | _ => None
+  }

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

@@ -0,0 +1,43 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function encode(typeName, localId) {
+  return btoa(typeName + `:` + localId);
+}
+
+function decode(globalId) {
+  try {
+    let decoded = atob(globalId);
+    let idx = decoded.indexOf(":");
+    if (idx > 0) {
+      return [
+        decoded.slice(0, idx),
+        decoded.slice(idx + 1 | 0, decoded.length)
+      ];
+    } else {
+      return;
+    }
+  } catch (exn) {
+    return;
+  }
+}
+
+function toLocalId(id) {
+  return Stdlib_Option.map(decode(id), param => param[1]);
+}
+
+function alternateKey(id) {
+  let localId = toLocalId(id);
+  if (localId !== undefined && localId !== id) {
+    return localId;
+  }
+}
+
+export {
+  encode,
+  decode,
+  toLocalId,
+  alternateKey,
+}
+/* No side effect */

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -62,10 +62,28 @@ let rec fromSchemaType = (
       collectedTypes->Array.push(`enum ${name} {\n  ${valuesStr}\n}`)
     }
     `${name}${bang}`
-  // GraphQL carries the value's shape, not its meaning: a storage ref is a
-  // String on the wire exactly as it is in the event log. The semantic reaches
-  // the UI through the field's JSON Schema, which is the channel that can
-  // express it.
+  // A semantic composite is one named type rather than one per field that uses
+  // it. The name comes from the semantic rather than the field path, so every
+  // plugin emits a byte-identical definition — which is what lets AppSync union
+  // the copies from each source API back into one, the way it already does for
+  // the `Node` / `PageInfo` / `SortOrder` base types.
+  //
+  // GraphQL forbids one name serving as both an object and an input, so the
+  // input position takes an `Input` suffix. Only these types are suffixed:
+  // positionally-named objects can't collide, since their names already carry
+  // the command or read model they belong to.
+  | Semantic({id}, ObjectRef(name, fields)) if SchemaType.canonicalName(id)->Option.isSome =>
+    let typeName = asInput ? name ++ "Input" : name
+    if !(seenTypes->Set.has(typeName)) {
+      seenTypes->Set.add(typeName)
+      let typeDef = objectRefToGraphQL(~asInput, typeName, fields, collectedTypes, seenTypes)
+      collectedTypes->Array.push(typeDef)
+    }
+    `${typeName}${bang}`
+  // Every other semantic carries the value's shape, not its meaning: a storage
+  // ref is a String on the wire exactly as it is in the event log. The semantic
+  // reaches the UI through the field's JSON Schema, which is the channel that
+  // can express it.
   | Semantic(_, inner) => fromSchemaType(~required, ~asInput, inner, collectedTypes, seenTypes)
   | Unknown => `String${bang}`
   }
@@ -187,30 +205,93 @@ let rec scalarOfSchemaType = (st: SchemaType.schemaType): string =>
   | _ => "String"
   }
 
-let deriveServerCapability = (schema: S.t<unknown>): serverCapability => {
+// A `*Id`-suffixed field name, case-sensitively. Deliberately NOT
+// `SchemaType.isIdFieldName`, which lowercases before testing the suffix and so
+// accepts `paid` and `valid` — harmless where it is used, but here it would
+// nominate an ordinary word as a row's key.
+let isKeyFieldName = (name: string): bool =>
+  name->String.length > 2 && name->String.endsWith("Id")
+
+/**
+The field that identifies a row, and which rung answered:
+
+- `"annotation"` — the state declares `@id`. Nothing outranks it.
+- `"convention"` — a field named `<singular entity name>Id` exists
+  (`Products` → `productId`). A guess, but one that can only fire on a field
+  that is actually there.
+- `"sole"` — the state has exactly one `*Id` field, so there is nothing else it
+  could be (`AvailableProducts` → `productId`).
+
+`None` is the honest answer for a state with several `*Id` fields and no name
+match (`ProductDemand`: `productId` + `categoryId`), or with none at all — those
+need `@id`. Convention outranks sole so a view carrying one foreign key and no
+key of its own is not keyed by the foreign key.
+*/
+let resolveKeyField = (~entityName: string, schema: S.t<unknown>): option<(string, string)> => {
+  let declared = switch Reventless.StateAnnotations.getSpec(schema) {
+  | Some({ids}) => ids->Array.get(0)
+  | None => None
+  }
+  switch declared {
+  | Some(field) => Some((field, "annotation"))
+  | None =>
+    let candidates =
+      SchemaType.fromSuryObject(~typeName="", schema)
+      ->Option.getOr(Dict.make())
+      ->Dict.keysToArray
+      ->Array.filter(isKeyFieldName)
+    let singular = entityName->Api_Naming.stripViewSuffix->Api_Naming.singularize
+    let conventional =
+      singular->String.slice(~start=0, ~end=1)->String.toLowerCase ++
+      singular->String.slice(~start=1, ~end=singular->String.length) ++ "Id"
+    if candidates->Array.includes(conventional) {
+      Some((conventional, "convention"))
+    } else if candidates->Array.length == 1 {
+      Some((candidates->Array.getUnsafe(0), "sole"))
+    } else {
+      None
+    }
+  }
+}
+
+// The component name the key-field convention is read against. `specName` is the
+// read model's own `Spec.name`; without it, `returnTypeName` minus its plugin
+// prefix is the same string (`Catalog_Product` → `Product`).
+let entityNameOf = (entry: ReventlessInfra.Api.querySchemaEntry): string =>
+  switch entry.specName {
+  | Some(n) => n
+  | None =>
+    switch entry.returnTypeName->String.lastIndexOf("_") {
+    | -1 => entry.returnTypeName
+    | i =>
+      entry.returnTypeName->String.slice(~start=i + 1, ~end=entry.returnTypeName->String.length)
+    }
+  }
+
+let deriveServerCapability = (~entityName: string, schema: S.t<unknown>): serverCapability => {
+  let fieldTypes = SchemaType.fromSuryObject(~typeName="", schema)->Option.getOr(Dict.make())
+  let scalarOf = (fieldName: string): string =>
+    fieldTypes->Dict.get(fieldName)->Option.mapOr("String", scalarOfSchemaType)
+
+  let filterFields: array<filterField> = []
+  let sortFields: array<string> = []
+  let seenFilter: Set.t<string> = Set.make()
+  let seenSort: Set.t<string> = Set.make()
+
+  let pushFilter = (name, ~range) =>
+    if !(seenFilter->Set.has(name)) {
+      seenFilter->Set.add(name)
+      filterFields->Array.push({name, gqlType: scalarOf(name), range})
+    }
+  let pushSort = name =>
+    if !(seenSort->Set.has(name)) {
+      seenSort->Set.add(name)
+      sortFields->Array.push(name)
+    }
+
   switch Reventless.StateAnnotations.getSpec(schema) {
-  | None => emptyCapability
+  | None => ()
   | Some(spec) =>
-    let fieldTypes = SchemaType.fromSuryObject(~typeName="", schema)->Option.getOr(Dict.make())
-    let scalarOf = (fieldName: string): string =>
-      fieldTypes->Dict.get(fieldName)->Option.mapOr("String", scalarOfSchemaType)
-
-    let filterFields: array<filterField> = []
-    let sortFields: array<string> = []
-    let seenFilter: Set.t<string> = Set.make()
-    let seenSort: Set.t<string> = Set.make()
-
-    let pushFilter = (name, ~range) =>
-      if !(seenFilter->Set.has(name)) {
-        seenFilter->Set.add(name)
-        filterFields->Array.push({name, gqlType: scalarOf(name), range})
-      }
-    let pushSort = name =>
-      if !(seenSort->Set.has(name)) {
-        seenSort->Set.add(name)
-        sortFields->Array.push(name)
-      }
-
     spec.ids->Array.forEach(name => {
       pushFilter(name, ~range=false)
       pushSort(name)
@@ -234,9 +315,21 @@ let deriveServerCapability = (schema: S.t<unknown>): serverCapability => {
     // path is needed here.
     spec.scan->Array.forEach(name => pushFilter(name, ~range=false))
     spec.scanSort->Array.forEach(name => pushSort(name))
+  }
 
-    {filterFields, sortFields}
+  // A state that declares nothing structural used to land here with an empty
+  // capability — no per-field filter and no order-by at all, so every narrowing
+  // a client asked for happened client-side over one page. Its key is knowable
+  // without the annotation in the common cases; take it. Pushed last, and both
+  // pushes dedupe, so a declared `@id` keeps its position and this is a no-op.
+  switch resolveKeyField(~entityName, schema) {
+  | Some((field, _rung)) =>
+    pushFilter(field, ~range=false)
+    pushSort(field)
+  | None => ()
   }
+
+  {filterFields, sortFields}
 }
 
 // Returns one warning per `@scanSort` field that is NOT also a sort key of the
@@ -564,7 +657,7 @@ let generate = (
         deriveConnectionTypes(~singularTypeName=entry.returnTypeName)
         ->Array.forEach(t => types->Array.push(t))
       }
-      let capability = deriveServerCapability(entry.stateSchema)
+      let capability = deriveServerCapability(~entityName=entityNameOf(entry), entry.stateSchema)
       let connectionFilterTypeName = entry.returnTypeName ++ "Filter"
       if !(seenTypes->Set.has(connectionFilterTypeName)) {
         seenTypes->Set.add(connectionFilterTypeName)

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))