@reventlessdev/reventless-local 3.0.0-alpha.210 → 3.0.0-alpha.212

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 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.212 (2026-08-11)
+
+### Bug Fixes
+
+* **api:** one id contract across the read-side query doors ([c52fac2](https://github.com/ReventlessDev/reventless-core/commit/c52fac2bee87b3dd1fa33b4970a74f3cd3866280))
+### Features
+
+* **api:** infer a queryable's key field and publish its provenance ([c835a42](https://github.com/ReventlessDev/reventless-core/commit/c835a42a0da07cdc4a3f010212e1f340a4a0ca27))
+
+
+# 3.0.0-alpha.211 (2026-08-10)
+
+**Note:** Version bump only for package @reventlessdev/reventless-local
+
+
+
+
+
 # 3.0.0-alpha.210 (2026-08-10)
 
 **Note:** Version bump only for package @reventlessdev/reventless-local

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.210",
+  "version": "3.0.0-alpha.212",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -35,18 +35,18 @@
     "sury": "11.0.0-alpha.4",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.26",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.27",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.3",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.4",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.70",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.222",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.132",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.86",
-    "@reventlessdev/reventless-seed": "1.0.0-alpha.10",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.106",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.169"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.224",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.72",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.171",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.88",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.134",
+    "@reventlessdev/reventless-seed": "1.0.0-alpha.11",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.108"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/DomainGraphQL_Server.res

@@ -257,26 +257,14 @@ type resolverFn = YG.resolverFn
 
 // -- Relay Global ID encoding/decoding -------------------------------------
 
-@val external btoa: string => string = "btoa"
-@val external atob: string => string = "atob"
-
+// The encoding itself lives in `ReventlessCore.Api_Ids` — one definition shared
+// with the AWS adapter and with the doors that accept either id form. Kept as
+// named bindings here because the resolver wiring below and the `relay` record
+// passed to QueryDbResolvers_GraphQL both reference them.
 let encodeGlobalId = (~typeName: string, ~localId: string): string =>
-  btoa(`${typeName}:${localId}`)
+  ReventlessCore.Api_Ids.encode(~typeName, ~localId)
 
-let decodeGlobalId = (globalId: string): option<(string, string)> =>
-  try {
-    let decoded = atob(globalId)
-    let idx = decoded->String.indexOf(":")
-    if idx > 0 {
-      let typeName = decoded->String.slice(~start=0, ~end=idx)
-      let localId = decoded->String.slice(~start=idx + 1, ~end=decoded->String.length)
-      Some((typeName, localId))
-    } else {
-      None
-    }
-  } catch {
-  | _ => None
-  }
+let decodeGlobalId = ReventlessCore.Api_Ids.decode
 
 // -- Scoped registry ---------------------------------------------------------
 // Mirrors the AWS plugin=source-API, platform=merged-API model: every

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -15,6 +15,7 @@ import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Api_Ids$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/Api_Ids.res.mjs";
 import * as LocalAuth$ReventlessLocal from "./Auth/LocalAuth.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_Stitcher.res.mjs";
 import * as LocalObjectStore$ReventlessLocal from "./ObjectStore/LocalObjectStore.res.mjs";
@@ -193,27 +194,7 @@ function _dispatch(req, res, yoga, getSdl) {
   });
 }
 
-function encodeGlobalId(typeName, localId) {
-  return btoa(typeName + `:` + localId);
-}
-
-function decodeGlobalId(globalId) {
-  try {
-    let decoded = atob(globalId);
-    let idx = decoded.indexOf(":");
-    if (idx <= 0) {
-      return;
-    }
-    let typeName = decoded.slice(0, idx);
-    let localId = decoded.slice(idx + 1 | 0, decoded.length);
-    return [
-      typeName,
-      localId
-    ];
-  } catch (exn) {
-    return;
-  }
-}
+let encodeGlobalId = Api_Ids$ReventlessCore.encode;
 
 let platformScope = "platform";
 
@@ -368,7 +349,7 @@ function buildNodeResolver() {
   }
   let resolver = async (_root, args, _ctx) => {
     let id = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d["id"]), Stdlib_JSON.Decode.string), "");
-    let match = decodeGlobalId(id);
+    let match = Api_Ids$ReventlessCore.decode(id);
     if (match === undefined) {
       return null;
     }
@@ -738,6 +719,8 @@ let YG;
 
 let buildAuthContext = Auth_GraphqlContext$ReventlessLocal.buildAuthContext;
 
+let decodeGlobalId = Api_Ids$ReventlessCore.decode;
+
 export {
   YG,
   log,

package/src/adapter/QueryDb/QueryDbResolvers_GraphQL.res

@@ -85,6 +85,13 @@ module Make = (Bus: LocalBus.T) => {
 
     // Register the Relay node resolver callback once per QueryDb (domain only).
     // Scans all QueryDb instances to resolve node(id: ID!) queries.
+    // `node` is the one door that speaks Relay global ids, on both sides: it needs
+    // the `<Type>:` prefix to know which read model to load, so a storage key alone
+    // could not be resolved here. Every other door — the list, `X(id:)`,
+    // `XsByIds`, `filter.ids` — reports the storage key, which is what a client
+    // reads off a row and passes back. Callers that hold a global id are still
+    // served by the typed doors (see `Api_Ids.alternateKey`); the reverse is not
+    // possible, which is why this door is opt-in rather than the default form.
     switch relay {
     | Some(r) =>
       r.registerNodeResolverCallback(async (~typeName, ~localId) => {
@@ -101,7 +108,10 @@ module Make = (Bus: LocalBus.T) => {
             ->Effect.runPromise
           switch items->Array.get(0) {
           | Some(item) =>
-            let obj = item->JSON.Decode.object->Option.getOr(Dict.make())
+            // Copied: `JSON.Decode.object` hands back the stored object itself, so
+            // setting a field here would rewrite the row inside the QueryDb — the
+            // in-memory backend keeps the very object it returns.
+            let obj = item->JSON.Decode.object->Option.mapOr(Dict.make(), Dict.copy)
             obj->Dict.set("__typename", JSON.Encode.string(typeName))
             obj->Dict.set("id", r.encodeGlobalId(~typeName, ~localId)->JSON.Encode.string)
             Some(JSON.Encode.object(obj))
@@ -169,11 +179,6 @@ module Make = (Bus: LocalBus.T) => {
       }
     }
 
-    let encodeId = switch relay {
-    | Some(r) => (~typeName, ~localId) => r.encodeGlobalId(~typeName, ~localId)
-    | None => (~typeName as _, ~localId) => localId
-    }
-
     // -- Main query: getById ---------------------------------------------------
     let byIdSdl = if includeIdParam {
       switch subIdField {
@@ -191,16 +196,34 @@ module Make = (Bus: LocalBus.T) => {
           args->JSON.Decode.object->Option.flatMap(d => d->Dict.get("id"))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
         switch Bus.getQueryDb(name) {
         | Some(ops) =>
-          let items =
-            await ops.loadStream(id)
+          let load = key =>
+            ops.loadStream(key)
             ->Stream.runCollect
             ->Effect.catchAll(_ => Effect.succeed([]))
             ->Effect.runPromise
+          let firstAttempt = await load(id)
+          // The row advertises a Relay global id, so `X(id: row.id)` arrives here
+          // as one. Retried rather than decoded up front: the raw key is what this
+          // door has always taken, and a key that merely looks like base64 must
+          // keep resolving to its own row.
+          let (resolvedKey, items) = switch (
+            firstAttempt->Array.get(0),
+            Api_Ids.alternateKey(id),
+          ) {
+          | (None, Some(localId)) => (localId, await load(localId))
+          | _ => (id, firstAttempt)
+          }
           switch items->Array.get(0) {
           | Some(item) =>
             if includeIdParam {
-              let obj = item->JSON.Decode.object->Option.getOr(Dict.make())
-              obj->Dict.set("id", encodeId(~typeName=returnTypeName, ~localId=id)->JSON.Encode.string)
+              // Copied — `JSON.Decode.object` hands back the stored object itself,
+              // so setting a field here would rewrite the row inside the QueryDb.
+              let obj = item->JSON.Decode.object->Option.mapOr(Dict.make(), Dict.copy)
+              // The storage key, which is what the list answers and what this door
+              // takes back. `resolvedKey`, not the argument: a caller who passed a
+              // Relay global id gets the raw key returned, so a round trip through
+              // this door converges on the one form instead of alternating.
+              obj->Dict.set("id", JSON.Encode.string(resolvedKey))
               JSON.Encode.object(obj)
             } else {
               item
@@ -237,21 +260,28 @@ module Make = (Bus: LocalBus.T) => {
               ->Array.filterMap(JSON.Decode.string)
             switch Bus.getQueryDb(name) {
             | Some(ops) =>
-              let loaded = await ids->Array.map(id =>
-                ops.loadStream(id)
+              let load = key =>
+                ops.loadStream(key)
                 ->Stream.runCollect
                 ->Effect.catchAll(_ => Effect.succeed([]))
                 ->Effect.runPromise
-                ->Promise.thenResolve(items => (id, items->Array.get(0)))
+              // Same either-form rule as the single-id door: raw key first, the
+              // key inside a Relay global id only on a miss.
+              let loaded = await ids->Array.map(async id =>
+                switch (await load(id))->Array.get(0) {
+                | Some(item) => (id, Some(item))
+                | None =>
+                  switch Api_Ids.alternateKey(id) {
+                  | Some(localId) => (localId, (await load(localId))->Array.get(0))
+                  | None => (id, None)
+                  }
+                }
               )->Promise.all
               loaded
               ->Array.filterMap(((id, opt)) =>
                 opt->Option.map(item => {
-                  let obj = item->JSON.Decode.object->Option.getOr(Dict.make())
-                  obj->Dict.set(
-                    "id",
-                    encodeId(~typeName=returnTypeName, ~localId=id)->JSON.Encode.string,
-                  )
+                  let obj = item->JSON.Decode.object->Option.mapOr(Dict.make(), Dict.copy)
+                  obj->Dict.set("id", JSON.Encode.string(id))
                   JSON.Encode.object(obj)
                 })
               )
@@ -279,7 +309,7 @@ module Make = (Bus: LocalBus.T) => {
     // so the resolver derives the same serverCapability the FragmentGenerator emitted.
     let stateSchemaOpt = Plugin_Helpers.stateSchemaRegistry->Dict.get(name)
     let capability = switch stateSchemaOpt {
-    | Some(s) => GraphQL_FragmentGenerator.deriveServerCapability(s)
+    | Some(s) => GraphQL_FragmentGenerator.deriveServerCapability(~entityName=name, s)
     | None => GraphQL_FragmentGenerator.emptyCapability
     }
 

package/src/adapter/QueryDb/QueryDbResolvers_GraphQL.res.mjs

@@ -7,6 +7,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stdlib_Nullable from "@rescript/runtime/lib/es6/Stdlib_Nullable.js";
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as Api_Ids$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/Api_Ids.res.mjs";
 import * as Authorization$Reventless from "@reventlessdev/reventless-spec/src/types/Authorization.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as SortKey_Filter$ReventlessLocal from "./SortKey_Filter.res.mjs";
@@ -63,7 +64,7 @@ function Make(Bus) {
         if (item === undefined) {
           return;
         }
-        let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(item), {});
+        let obj = Stdlib_Option.mapOr(Stdlib_JSON.Decode.object(item), {}, prim => Object.assign({}, prim));
         obj["__typename"] = typeName;
         obj["id"] = relay.encodeGlobalId(typeName, localId);
         return obj;
@@ -95,7 +96,6 @@ function Make(Bus) {
     if (includeIdParam && relay !== undefined) {
       relay.registerNodeType(returnTypeName, name);
     }
-    let encodeId = relay !== undefined ? (typeName, localId) => relay.encodeGlobalId(typeName, localId) : (param, localId) => localId;
     let byIdSdl = includeIdParam ? (
         subIdField !== undefined ? `  ` + singleQueryName + `(id: ID!, ` + subIdField + `: String): ` + returnTypeName : `  ` + singleQueryName + `(id: ID!): ` + returnTypeName
       ) : `  ` + singleQueryName + `: ` + returnTypeName;
@@ -109,16 +109,26 @@ function Make(Bus) {
       if (ops === undefined) {
         return null;
       }
-      let items = await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream(id)), param => Effect.succeed([])));
-      let item = items[0];
+      let load = key => Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream(key)), param => Effect.succeed([])));
+      let firstAttempt = await load(id);
+      let match$1 = firstAttempt[0];
+      let match$2 = Api_Ids$ReventlessCore.alternateKey(id);
+      let match$3 = match$1 !== undefined || match$2 === undefined ? [
+          id,
+          firstAttempt
+        ] : [
+          match$2,
+          await load(match$2)
+        ];
+      let item = match$3[1][0];
       if (item === undefined) {
         return null;
       }
       if (!includeIdParam) {
         return item;
       }
-      let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(item), {});
-      obj["id"] = encodeId(returnTypeName, id);
+      let obj = Stdlib_Option.mapOr(Stdlib_JSON.Decode.object(item), {}, prim => Object.assign({}, prim));
+      obj["id"] = match$3[0];
       return obj;
     };
     let byIdsSdl = includeIdParam && subIdField === undefined ? [GraphQL_FragmentGenerator$ReventlessCore.deriveByIdsQueryField(listQueryName, returnTypeName)] : [];
@@ -134,15 +144,33 @@ function Make(Bus) {
         if (ops === undefined) {
           return [];
         }
-        let loaded = await Promise.all(ids.map(id => Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream(id)), param => Effect.succeed([]))).then(items => [
-          id,
-          items[0]
-        ])));
+        let load = key => Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream(key)), param => Effect.succeed([])));
+        let loaded = await Promise.all(ids.map(async id => {
+          let item = (await load(id))[0];
+          if (item !== undefined) {
+            return [
+              id,
+              item
+            ];
+          }
+          let localId = Api_Ids$ReventlessCore.alternateKey(id);
+          if (localId !== undefined) {
+            return [
+              localId,
+              (await load(localId))[0]
+            ];
+          } else {
+            return [
+              id,
+              undefined
+            ];
+          }
+        }));
         return Stdlib_Array.filterMap(loaded, param => {
           let id = param[0];
           return Stdlib_Option.map(param[1], item => {
-            let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(item), {});
-            obj["id"] = encodeId(returnTypeName, id);
+            let obj = Stdlib_Option.mapOr(Stdlib_JSON.Decode.object(item), {}, prim => Object.assign({}, prim));
+            obj["id"] = id;
             return obj;
           });
         });
@@ -156,7 +184,7 @@ function Make(Bus) {
     }
     let labelField = registryEntry !== undefined ? Stdlib_Option.getOr(registryEntry.labelField, "id") : "id";
     let stateSchemaOpt = Plugin_Helpers$ReventlessCore.stateSchemaRegistry[name];
-    let capability = stateSchemaOpt !== undefined ? GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability(stateSchemaOpt) : GraphQL_FragmentGenerator$ReventlessCore.emptyCapability;
+    let capability = stateSchemaOpt !== undefined ? GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability(name, stateSchemaOpt) : GraphQL_FragmentGenerator$ReventlessCore.emptyCapability;
     let fetchAllItems = async () => {
       let makeStream = Bus.getQueryDbStream(name);
       if (makeStream !== undefined) {

package/tests/adapter/GraphQL_SchemaInspectorTest.res

@@ -77,6 +77,14 @@ type plainState = {
   name: string,
 }
 
+// No `*Id` field at all, so the key ladder has nothing to nominate — the state
+// that still produces an empty capability.
+@schema
+type keylessState = {
+  name: string,
+  note: string,
+}
+
 @schema
 type indexedState = {
   productId: @s.matches(Reventless.DcbTag.string) string,
@@ -582,7 +590,12 @@ describe("GraphQL_SchemaInspector", () => {
   // ── Phase 1: server capability — auto-derived Filter / OrderBy ─────────
 
   describe("server capability — auto-derived Filter / OrderBy", () => {
-    testPromise("read model with no annotations emits the unchanged search-only Filter", async () => {
+    // This used to assert that a state with no annotations got a search-only
+    // Filter and no OrderBy at all. It no longer does: `plainState` has exactly
+    // one `*Id` field, so the key is knowable without `@id` and the queryable now
+    // gets that key's eq filter and sort. The search-only case is the one below,
+    // where nothing identifies the row.
+    testPromise("read model with no annotations gets its inferred key's Eq + OrderBy", async () => {
       let fragment = ReventlessCore.GraphQL_FragmentGenerator.generate(
         ~mutationEntries=[],
         ~queryEntries=[
@@ -599,16 +612,44 @@ describe("GraphQL_SchemaInspector", () => {
       )
       let inspection = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment)
       let sdl = inspection.sdlPreview
-      // Filter has only the legacy block
+      // The legacy block is untouched …
       expect(sdl->String.includes("input PlainViewFilter"))->toBe(true)
       expect(sdl->String.includes("search: String"))->toBe(true)
       expect(sdl->String.includes("searchPrefix: String"))->toBe(true)
       expect(sdl->String.includes("ids: [ID!]"))->toBe(true)
-      // No per-field eq inputs
+      // … and `productId`, the sole candidate, now narrows and sorts.
+      expect(sdl->String.includes("productIdEq: ID"))->toBe(true)
+      expect(sdl->String.includes("PlainViewOrderBy"))->toBe(true)
+      expect(sdl->String.includes("PlainViewOrderField"))->toBe(true)
+      expect(sdl->String.includes("orderBy:"))->toBe(true)
+      // Only the key — an inferred key never drags the rest of the record in.
+      expect(sdl->String.includes("nameEq:"))->toBe(false)
+    })
+
+    // The remaining empty-capability case: no `*Id` field, so nothing says which
+    // field identifies a row and the ladder declines rather than guessing.
+    testPromise("read model whose key cannot be resolved stays search-only", async () => {
+      let fragment = ReventlessCore.GraphQL_FragmentGenerator.generate(
+        ~mutationEntries=[],
+        ~queryEntries=[
+          {
+            singleFieldName: "Keyless_View",
+            listFieldName: "Keyless_Views",
+            returnTypeName: "KeylessView",
+            stateSchema: keylessStateSchema->S.castToUnknown,
+            authorization: None,
+            includeIdParam: false,
+            connectionSpec: true,
+          },
+        ],
+      )
+      let inspection = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment)
+      let sdl = inspection.sdlPreview
+      expect(sdl->String.includes("input KeylessViewFilter"))->toBe(true)
+      expect(sdl->String.includes("search: String"))->toBe(true)
       expect(sdl->String.includes("Eq:"))->toBe(false)
-      // No OrderBy / OrderField types or arg
-      expect(sdl->String.includes("PlainViewOrderBy"))->toBe(false)
-      expect(sdl->String.includes("PlainViewOrderField"))->toBe(false)
+      expect(sdl->String.includes("KeylessViewOrderBy"))->toBe(false)
+      expect(sdl->String.includes("KeylessViewOrderField"))->toBe(false)
       expect(sdl->String.includes("orderBy:"))->toBe(false)
     })
 

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -84,6 +84,11 @@ let plainStateSchema = S.schema(s => ({
   name: s.m(S.string)
 }));
 
+let keylessStateSchema = S.schema(s => ({
+  name: s.m(S.string),
+  note: s.m(S.string)
+}));
+
 let indexedStateSchema = S.schema(s => ({
   productId: s.m(DcbTag$Reventless.string),
   ownerId: s.m(S.string),
@@ -453,7 +458,7 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
     });
   });
   globalThis.describe("server capability — auto-derived Filter / OrderBy", () => {
-    globalThis.test("read model with no annotations emits the unchanged search-only Filter", async () => {
+    globalThis.test("read model with no annotations gets its inferred key's Eq + OrderBy", async () => {
       let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
           singleFieldName: "Plain_View",
           listFieldName: "Plain_Views",
@@ -469,9 +474,29 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
       globalThis.expect(sdl.includes("search: String")).toBe(true);
       globalThis.expect(sdl.includes("searchPrefix: String")).toBe(true);
       globalThis.expect(sdl.includes("ids: [ID!]")).toBe(true);
+      globalThis.expect(sdl.includes("productIdEq: ID")).toBe(true);
+      globalThis.expect(sdl.includes("PlainViewOrderBy")).toBe(true);
+      globalThis.expect(sdl.includes("PlainViewOrderField")).toBe(true);
+      globalThis.expect(sdl.includes("orderBy:")).toBe(true);
+      globalThis.expect(sdl.includes("nameEq:")).toBe(false);
+    });
+    globalThis.test("read model whose key cannot be resolved stays search-only", async () => {
+      let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+          singleFieldName: "Keyless_View",
+          listFieldName: "Keyless_Views",
+          returnTypeName: "KeylessView",
+          stateSchema: keylessStateSchema,
+          authorization: undefined,
+          includeIdParam: false,
+          connectionSpec: true
+        }]);
+      let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
+      let sdl = inspection.sdlPreview;
+      globalThis.expect(sdl.includes("input KeylessViewFilter")).toBe(true);
+      globalThis.expect(sdl.includes("search: String")).toBe(true);
       globalThis.expect(sdl.includes("Eq:")).toBe(false);
-      globalThis.expect(sdl.includes("PlainViewOrderBy")).toBe(false);
-      globalThis.expect(sdl.includes("PlainViewOrderField")).toBe(false);
+      globalThis.expect(sdl.includes("KeylessViewOrderBy")).toBe(false);
+      globalThis.expect(sdl.includes("KeylessViewOrderField")).toBe(false);
       globalThis.expect(sdl.includes("orderBy:")).toBe(false);
     });
     globalThis.test("read model with @id + @index emits Eq filters + OrderBy + orderBy arg", async () => {
@@ -701,6 +726,7 @@ export {
   dcbSingleCommandSchema,
   dcbMultiCommandSchema,
   plainStateSchema,
+  keylessStateSchema,
   indexedStateSchema,
   indexedStateSchemaWithAnnotations,
   orderedStateSchema,