@reventlessdev/reventless-local 3.0.0-alpha.225 → 3.0.0-alpha.227

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

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -16,6 +17,7 @@ import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/s
 import * as SortKey_Filter$ReventlessLocal from "./SortKey_Filter.res.mjs";
 import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
 import * as QueryDb_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Callback.res.mjs";
+import * as GraphQL_CallerError$ReventlessLocal from "../GraphQL_CallerError.res.mjs";
 import * as DomainGraphQL_Server$ReventlessLocal from "../DomainGraphQL_Server.res.mjs";
 import * as OwnerScopeDiagnostics$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/OwnerScopeDiagnostics.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
@@ -112,7 +114,6 @@ function Make(Bus) {
         return true;
       }
     };
-    let cap = s => s.charAt(0).toUpperCase() + s.slice(1);
     let registryEntry = Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[name];
     let singleQueryName = registryEntry !== undefined ? registryEntry.singleFieldName : name.charAt(0).toLowerCase() + name.slice(1);
     let listQueryName = registryEntry !== undefined ? registryEntry.listFieldName : name + "s";
@@ -124,7 +125,7 @@ function Make(Bus) {
       relay.registerNodeType(returnTypeName, name);
     }
     let byIdSdl = includeIdParam ? (
-        subIdField !== undefined ? `  ` + singleQueryName + `(id: ID!, ` + subIdField + `: String): ` + returnTypeName : `  ` + singleQueryName + `(id: ID!): ` + returnTypeName
+        subIdField !== undefined ? `  ` + singleQueryName + `(id: ID!, ` + subIdField + `: String, includeRetired: Boolean): ` + returnTypeName : `  ` + singleQueryName + `(id: ID!, includeRetired: Boolean): ` + returnTypeName
       ) : `  ` + singleQueryName + `: ` + returnTypeName;
     let byIdResolver = async (_root, args, ctx) => {
       let match = await runInterceptor(ctx, args);
@@ -219,6 +220,101 @@ function Make(Bus) {
       byIdsResolverEntry = undefined;
     }
     let labelField = registryEntry !== undefined ? Stdlib_Option.getOr(registryEntry.labelField, "id") : "id";
+    let refsSdl = includeIdParam && subIdField === undefined ? [GraphQL_FragmentGenerator$ReventlessCore.deriveRefsQueryField(listQueryName, returnTypeName)] : [];
+    let refsResolverEntry;
+    if (includeIdParam && subIdField === undefined) {
+      server.registerTypes([GraphQL_FragmentGenerator$ReventlessCore.deriveRefTypeSdl(returnTypeName)]);
+      let resolver$1 = async (_root, args, ctx) => {
+        let match = await runInterceptor(ctx, args);
+        if (typeof match === "object") {
+          return [];
+        }
+        let ids = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d["ids"]), Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.string);
+        let spec = retiredSpecOf();
+        let namesRetired = Stdlib_Option.mapOr(spec, false, r => r.namedWhenRetired);
+        let retirementOf = item => {
+          if (spec === undefined) {
+            return [
+              false,
+              undefined
+            ];
+          }
+          let cell = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[spec.field]);
+          let scope_field = spec.field;
+          let scope_values = spec.values;
+          let scope = {
+            field: scope_field,
+            values: scope_values
+          };
+          let retired = OwnerScope$Reventless.isRetiredValue(scope, cell);
+          return [
+            retired,
+            retired && Stdlib_Option.isSome(spec.values) ? Stdlib_Option.flatMap(cell, Stdlib_JSON.Decode.string) : undefined
+          ];
+        };
+        let ops = Bus.getQueryDb(name);
+        if (ops === undefined) {
+          return [];
+        }
+        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.flatMap(Stdlib_Option.filter(param[1], item => ownerAllows(ctx, item)), item => {
+            let match = retirementOf(item);
+            let retired = match[0];
+            if (retired && !namesRetired) {
+              return;
+            }
+            let label = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[labelField]), Stdlib_JSON.Decode.string), id);
+            return Object.fromEntries([
+              [
+                "id",
+                id
+              ],
+              [
+                "label",
+                label
+              ],
+              [
+                "retired",
+                retired
+              ],
+              [
+                "retiredState",
+                Stdlib_Option.mapOr(match[1], null, prim => prim)
+              ]
+            ]);
+          });
+        });
+      };
+      refsResolverEntry = [
+        listQueryName + "Refs",
+        resolver$1
+      ];
+    } else {
+      refsResolverEntry = undefined;
+    }
     let stateSchemaOpt = Plugin_Helpers$ReventlessCore.stateSchemaRegistry[name];
     let capability = stateSchemaOpt !== undefined ? GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability(name, stateSchemaOpt) : GraphQL_FragmentGenerator$ReventlessCore.emptyCapability;
     let fetchAllItems = async () => {
@@ -250,7 +346,7 @@ function Make(Bus) {
           endCursor: null
         }
       };
-      let resolver$1 = async (_root, args, ctx) => {
+      let resolver$2 = async (_root, args, ctx) => {
         let match = await runInterceptor(ctx, args);
         if (typeof match === "object") {
           return emptyConnection;
@@ -277,11 +373,11 @@ function Make(Bus) {
       };
       match = [
         sdl,
-        resolver$1
+        resolver$2
       ];
     } else {
       let sdl$1 = [`  ` + listQueryName + `(nextToken: String, limit: Int): ` + pluralTypeName + `!`];
-      let resolver$2 = async (_root, args, ctx) => {
+      let resolver$3 = async (_root, args, ctx) => {
         let match = await runInterceptor(ctx, args);
         if (typeof match === "object") {
           return {
@@ -306,7 +402,7 @@ function Make(Bus) {
       };
       match = [
         sdl$1,
-        resolver$2
+        resolver$3
       ];
     }
     let listResolvers = [[
@@ -324,7 +420,7 @@ function Make(Bus) {
     }
     let itemsResolvers;
     if (subIdField !== undefined) {
-      let resolver$3 = async (_root, args, ctx) => {
+      let resolver$4 = async (_root, args, ctx) => {
         let emptyConn = {
           edges: [],
           pageInfo: {
@@ -423,22 +519,81 @@ function Make(Bus) {
       };
       itemsResolvers = [[
           singleQueryName + "Items",
-          resolver$3
+          resolver$4
         ]];
     } else {
       itemsResolvers = [];
     }
-    let indexSdlFields = indexes.map(ic => `  ` + singleQueryName + `By` + cap(ic.index) + `(` + ic.index + `: String!): [String]`);
+    let indexSdlFields = indexes.map(ic => GraphQL_FragmentGenerator$ReventlessCore.deriveIndexQueryField(singleQueryName, ic, returnTypeName + "Connection"));
+    let rejectBackwardPaging = args => {
+      let given = key => {
+        let match = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d[key]);
+        if (match !== undefined) {
+          return match !== null;
+        } else {
+          return false;
+        }
+      };
+      if (!(given("last") || given("before"))) {
+        return;
+      }
+      throw GraphQL_CallerError$ReventlessLocal.badUserInput("Backward pagination (last/before) is not supported on by-index connections; use first/after.");
+    };
+    let indexConnection = (args, items) => {
+      let arg = key => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d[key]);
+      let after = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(arg("after"), Stdlib_JSON.Decode.string), s => Stdlib_Int.fromString(s, undefined)), -1);
+      let first = Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(arg("first"), Stdlib_JSON.Decode.float), prim => prim | 0), 50);
+      let start = after + 1 | 0;
+      let page = items.slice(start, start + first | 0);
+      let taken = page.length;
+      let edges = page.map((item, i) => Object.fromEntries([
+        [
+          "node",
+          item
+        ],
+        [
+          "cursor",
+          (start + i | 0).toString()
+        ]
+      ]));
+      return Object.fromEntries([
+        [
+          "edges",
+          edges
+        ],
+        [
+          "pageInfo",
+          Object.fromEntries([
+            [
+              "hasNextPage",
+              (start + taken | 0) < items.length
+            ],
+            [
+              "hasPreviousPage",
+              start > 0
+            ],
+            [
+              "startCursor",
+              taken > 0 ? start.toString() : null
+            ],
+            [
+              "endCursor",
+              taken > 0 ? ((start + taken | 0) - 1 | 0).toString() : null
+            ]
+          ])
+        ]
+      ]);
+    };
     let indexResolvers = indexes.map(ic => {
-      let index = ic.index;
-      let resolverName = singleQueryName + "By" + cap(index);
-      let filterField = Stdlib_Option.getOr(ic.idField, index);
+      let resolverName = GraphQL_FragmentGenerator$ReventlessCore.indexQueryFieldName(singleQueryName, ic.index);
+      let filterField = GraphQL_FragmentGenerator$ReventlessCore.indexKeyField(ic);
       let resolver = async (_root, args, ctx) => {
         let match = await runInterceptor(ctx, args);
         if (typeof match === "object") {
-          return [];
+          return indexConnection(args, []);
         }
-        let value = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d[index]), Stdlib_JSON.Decode.string), "");
+        rejectBackwardPaging(args);
+        let value = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d[filterField]), Stdlib_JSON.Decode.string), "");
         let scoped = rows => rows.filter(item => {
           if (ownerAllows(ctx, item)) {
             return retiredAllows(ctx, args, item);
@@ -448,13 +603,13 @@ function Make(Bus) {
         });
         let lookup = Bus.getQueryDbIndexLookup(name);
         if (lookup !== undefined) {
-          return scoped(lookup(filterField, value));
+          return indexConnection(args, scoped(lookup(filterField, value)));
         }
         let scanAll = Bus.getQueryDbScan(name);
         if (scanAll !== undefined) {
-          return scoped(scanAll().filter(item => Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[filterField]), Stdlib_JSON.Decode.string), v => v === value), false)));
+          return indexConnection(args, scoped(scanAll().filter(item => Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[filterField]), Stdlib_JSON.Decode.string), v => v === value), false))));
         } else {
-          return [];
+          return indexConnection(args, []);
         }
       };
       return [
@@ -462,12 +617,15 @@ function Make(Bus) {
         resolver
       ];
     });
-    let allSdl = [byIdSdl].concat(byIdsSdl).concat(match[0]).concat(itemsSdl).concat(indexSdlFields);
+    let allSdl = [byIdSdl].concat(byIdsSdl).concat(refsSdl).concat(match[0]).concat(itemsSdl).concat(indexSdlFields);
     let resolvers = {};
     resolvers[singleQueryName] = byIdResolver;
     Stdlib_Option.forEach(byIdsResolverEntry, param => {
       resolvers[param[0]] = param[1];
     });
+    Stdlib_Option.forEach(refsResolverEntry, param => {
+      resolvers[param[0]] = param[1];
+    });
     listResolvers.forEach(param => {
       resolvers[param[0]] = param[1];
     });

package/tests/UiHintsTest.res

@@ -103,30 +103,54 @@ describe("UiHints.emit", () => {
 // point, while mid-session it is almost always an editor mid-save, and killing a
 // running dev server over a keystroke is worse than the restart this replaces.
 
-// Both exits close the watcher AND clear the deadline. A watcher is `unref`ed
+// The edit is repeated, and that is not belt-and-braces.
+//
+// `fs.watch` does not promise that a write landing near the watcher's creation
+// is reported. The FSEvents stream behind it on macOS is armed asynchronously,
+// and a write that gets there first is not reported late — it is not reported at
+// all. Measured against this very module: once the stream is up the edit is seen
+// in about 10ms, and when it is not, the same edit produces no event in four
+// seconds, with which of the two happens varying by how many watchers the
+// process has already opened rather than by anything the test does.
+//
+// So a single edit tests the arming, not the reload. Repeating it on an interval
+// far longer than a reload takes — 50ms of debounce plus a file copy — leaves the
+// case where the first write lands identical to what it always was, and lets the
+// case where it is dropped recover on the next one instead of reporting that hot
+// reload is broken. Re-writing the same bytes is what a developer saving twice
+// does, so nothing here asserts less than it did.
+let retryEvery = 1000
+
+// All three exits close the watcher AND clear both timers. A watcher is `unref`ed
 // and would not hold the run open on its own, but a live 4-second timer would —
 // and "Jest did not exit" on a suite that passed is exactly the noise that
 // teaches a reader to ignore it.
-let waitForReload = (~timeoutMs: int=4000, ~afterWatching: unit => unit, ~uiHintsFile, ~dir) =>
+let waitForReload = (~timeoutMs: int=4000, ~edit: unit => unit, ~uiHintsFile, ~dir) =>
   Promise.make((resolve, _) => {
     let fired = ref(0)
     let watcher = ref(None)
     let deadline = ref(None)
+    let retry = ref(None)
     // Resolves with a count rather than rejecting on the deadline: "nothing was
     // re-served" is the expected answer in half these cases, and a rejection
     // would make the assertion read as an infrastructure failure.
     let finish = () => {
       watcher.contents->Option.forEach(NodeFs.watcherClose)
       deadline.contents->Option.forEach(clearTimeout)
+      retry.contents->Option.forEach(clearTimeout)
       resolve(fired.contents)
     }
+    let rec editUntilSeen = () => {
+      edit()
+      retry := Some(setTimeout(editUntilSeen, retryEvery))
+    }
     watcher :=
       UiHints.watch(~uiHintsFile, ~dir, ~onReload=() => {
         fired := fired.contents + 1
         finish()
       })
     deadline := Some(setTimeout(finish, timeoutMs))
-    afterWatching()
+    editUntilSeen()
   })
 
 describe("UiHints.watch", () => {
@@ -147,7 +171,7 @@ describe("UiHints.watch", () => {
     let fired = await waitForReload(
       ~uiHintsFile=Some(path),
       ~dir,
-      ~afterWatching=() => NodeFs.writeFileSync(path, edited),
+      ~edit=() => NodeFs.writeFileSync(path, edited),
     )
     expect((fired > 0, served(dir)))->toEqual((true, edited))
   })
@@ -163,7 +187,7 @@ describe("UiHints.watch", () => {
       ~timeoutMs=1500,
       ~uiHintsFile=Some(path),
       ~dir,
-      ~afterWatching=() => NodeFs.writeFileSync(path, `{"Catalog": {"views":`),
+      ~edit=() => NodeFs.writeFileSync(path, `{"Catalog": {"views":`),
     )
     expect((fired, served(dir)))->toEqual((0, declared))
   })
@@ -178,7 +202,10 @@ describe("UiHints.watch", () => {
     let fired = await waitForReload(
       ~uiHintsFile=Some(path),
       ~dir,
-      ~afterWatching=() => {
+      // Both halves of the save, so a repeat of this edit is the same story told
+      // again and still ends on the whole file — never a truncated write left
+      // standing after a complete one.
+      ~edit=() => {
         NodeFs.writeFileSync(path, `{"Catalog": {"views":`)
         let _ = setTimeout(() => NodeFs.writeFileSync(path, whole), 200)
       },

package/tests/UiHintsTest.res.mjs

@@ -88,7 +88,7 @@ globalThis.describe("UiHints.emit", () => {
   });
 });
 
-function waitForReload(timeoutMsOpt, afterWatching, uiHintsFile, dir) {
+function waitForReload(timeoutMsOpt, edit, uiHintsFile, dir) {
   let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 4000;
   return new Promise((resolve, param) => {
     let fired = {
@@ -100,6 +100,9 @@ function waitForReload(timeoutMsOpt, afterWatching, uiHintsFile, dir) {
     let deadline = {
       contents: undefined
     };
+    let retry = {
+      contents: undefined
+    };
     let finish = () => {
       Stdlib_Option.forEach(watcher.contents, prim => {
         prim.close();
@@ -107,14 +110,21 @@ function waitForReload(timeoutMsOpt, afterWatching, uiHintsFile, dir) {
       Stdlib_Option.forEach(deadline.contents, prim => {
         clearTimeout(prim);
       });
+      Stdlib_Option.forEach(retry.contents, prim => {
+        clearTimeout(prim);
+      });
       resolve(fired.contents);
     };
+    let editUntilSeen = () => {
+      edit();
+      retry.contents = Primitive_option.some(setTimeout(editUntilSeen, 1000));
+    };
     watcher.contents = UiHints$ReventlessLocal.watch(uiHintsFile, dir, () => {
       fired.contents = fired.contents + 1 | 0;
       finish();
     });
     deadline.contents = Primitive_option.some(setTimeout(finish, timeoutMs));
-    afterWatching();
+    editUntilSeen();
   });
 }
 
@@ -178,6 +188,8 @@ globalThis.describe("UiHints.watch", () => {
   });
 });
 
+let retryEvery = 1000;
+
 export {
   shipped,
   declared,
@@ -187,6 +199,7 @@ export {
   served,
   baselinePath,
   threw,
+  retryEvery,
   waitForReload,
 }
 /*  Not a pure module */

package/tests/adapter/DcbEventLogStorageSqliteTest.res

@@ -94,7 +94,7 @@ describe("DcbEventLogStorage_Sqlite", () => {
   // Backend contract: an empty tag value (an absent composite-partition member) is
   // legitimate — it appends, is recorded verbatim, and keeps matching through both
   // the partition read and a composite read. Held identically by the in-memory and
-  // DynamoDB backends. See docs/plans/dcb-empty-tag-values-break-append.md.
+  // DynamoDB backends. See docs/plans/done/dcb-empty-tag-values-break-append.md.
   testPromise("an empty tag value appends and stays readable", async () => {
     await runUnderSqlite(async () => {
       module TestBus = LocalBus.Make()

package/tests/adapter/DcbEventLogStorageTest.res

@@ -145,7 +145,7 @@ describe("DcbEventLogStorage_InMemory", () => {
     // An empty tag value is a legitimate model state — an absent member of a
     // composite partition key. Every backend must accept it, record it verbatim,
     // and keep matching the event through its partition and composite reads. See
-    // docs/plans/dcb-empty-tag-values-break-append.md.
+    // docs/plans/done/dcb-empty-tag-values-break-append.md.
     testPromise("an empty tag value appends and stays readable", async () => {
       let storage = makeStorage()
       let ops = await storage.operations->TestRunner.resolve

package/tests/adapter/EventLogSnapshotParityTest.res

@@ -1,5 +1,5 @@
 // Backend-parity tests for the EventLog snapshot ops
-// (docs/plans/aggregate-snapshotting.md): the in-memory and SQLite backends
+// (docs/plans/done/aggregate-snapshotting.md): the in-memory and SQLite backends
 // must behave identically for latestSnapshot / writeSnapshot (keep-one) and
 // the replayStream ~fromSeq delta read, so GWT/local tests of
 // snapshot-enabled aggregates give the same results under either backend.

package/tests/adapter/GraphQL_SchemaInspectorTest.res

@@ -271,7 +271,7 @@ describe("GraphQL_SchemaInspector", () => {
       expect(result.typeDef->Option.isSome)->toBe(true)
       let typeDef = result.typeDef->Option.getOrThrow
       expect(typeDef->String.includes("type CatalogProduct"))->toBe(true)
-      expect(result.singleQuery->String.includes("Catalog_Product(id: ID!)"))->toBe(true)
+      expect(result.singleQuery->String.includes("Catalog_Product(id: ID!, includeRetired: Boolean)"))->toBe(true)
       expect(result.singleQuery->String.includes("CatalogProduct"))->toBe(true)
       expect(result.listQuery->Option.isSome)->toBe(true)
       let listQ = result.listQuery->Option.getOrThrow
@@ -298,7 +298,7 @@ describe("GraphQL_SchemaInspector", () => {
       )
       let inspection = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment)
       let sdl = inspection.sdlPreview
-      expect(sdl->String.includes("RM_Product(id: ID!): RMProduct"))->toBe(true)
+      expect(sdl->String.includes("RM_Product(id: ID!, includeRetired: Boolean): RMProduct"))->toBe(true)
       expect(sdl->String.includes("type RMProduct"))->toBe(true)
       // The type should have an injected id: ID! field (first field in the type)
       let typeLines = sdl->String.split("\n")
@@ -357,7 +357,7 @@ describe("GraphQL_SchemaInspector", () => {
       )
       let inspection = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment)
       let sdl = inspection.sdlPreview
-      expect(sdl->String.includes("Default_Thing(id: ID!): DefaultThing"))->toBe(true)
+      expect(sdl->String.includes("Default_Thing(id: ID!, includeRetired: Boolean): DefaultThing"))->toBe(true)
     })
   })
 
@@ -542,13 +542,15 @@ describe("GraphQL_SchemaInspector", () => {
         ],
       )
       let inspection = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment)
-      // TestState, TestStateEdge, TestStateConnection, TestStateFilter (Phase 4 connection filter)
+      // TestState, TestStateEdge, TestStateConnection, TestStateFilter (connection filter)
+      // + TestStateRef (the reference door's projection)
       // + CommandResult union + CommandAccepted + CommandRejected + CommandPending
       // (auto-injected whenever the fragment emits any mutation field).
-      expect(inspection.types->Array.length)->toBe(8)
+      expect(inspection.types->Array.length)->toBe(9)
       expect(inspection.mutations->Array.length)->toBe(1)
-      // single Test_State(id), list Test_States(...), and Test_StatesByIds(ids: [String!]!)
-      expect(inspection.queries->Array.length)->toBe(3)
+      // single Test_State(id), list Test_States(...), Test_StatesByIds(ids: [String!]!)
+      // and Test_StatesRefs(ids: [ID!]!) — the by-ids read projected to a reference.
+      expect(inspection.queries->Array.length)->toBe(4)
       expect(inspection.sdlPreview->String.includes("type TestState"))->toBe(true)
       expect(inspection.sdlPreview->String.includes("type TestStateEdge"))->toBe(true)
       expect(inspection.sdlPreview->String.includes("type TestStateConnection"))->toBe(true)

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -239,7 +239,7 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
       globalThis.expect(Stdlib_Option.isSome(result.typeDef)).toBe(true);
       let typeDef = Stdlib_Option.getOrThrow(result.typeDef, undefined);
       globalThis.expect(typeDef.includes("type CatalogProduct")).toBe(true);
-      globalThis.expect(result.singleQuery.includes("Catalog_Product(id: ID!)")).toBe(true);
+      globalThis.expect(result.singleQuery.includes("Catalog_Product(id: ID!, includeRetired: Boolean)")).toBe(true);
       globalThis.expect(result.singleQuery.includes("CatalogProduct")).toBe(true);
       globalThis.expect(Stdlib_Option.isSome(result.listQuery)).toBe(true);
       let listQ = Stdlib_Option.getOrThrow(result.listQuery, undefined);
@@ -258,7 +258,7 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
         }]);
       let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
       let sdl = inspection.sdlPreview;
-      globalThis.expect(sdl.includes("RM_Product(id: ID!): RMProduct")).toBe(true);
+      globalThis.expect(sdl.includes("RM_Product(id: ID!, includeRetired: Boolean): RMProduct")).toBe(true);
       globalThis.expect(sdl.includes("type RMProduct")).toBe(true);
       let typeLines = sdl.split("\n");
       let idFieldInType = typeLines.some(line => {
@@ -302,7 +302,7 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
         }]);
       let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
       let sdl = inspection.sdlPreview;
-      globalThis.expect(sdl.includes("Default_Thing(id: ID!): DefaultThing")).toBe(true);
+      globalThis.expect(sdl.includes("Default_Thing(id: ID!, includeRetired: Boolean): DefaultThing")).toBe(true);
     });
   });
   globalThis.describe("Relay compliance", () => {
@@ -424,9 +424,9 @@ globalThis.describe("GraphQL_SchemaInspector", () => {
           authorization: undefined
         }]);
       let inspection = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment);
-      globalThis.expect(inspection.types.length).toBe(8);
+      globalThis.expect(inspection.types.length).toBe(9);
       globalThis.expect(inspection.mutations.length).toBe(1);
-      globalThis.expect(inspection.queries.length).toBe(3);
+      globalThis.expect(inspection.queries.length).toBe(4);
       globalThis.expect(inspection.sdlPreview.includes("type TestState")).toBe(true);
       globalThis.expect(inspection.sdlPreview.includes("type TestStateEdge")).toBe(true);
       globalThis.expect(inspection.sdlPreview.includes("type TestStateConnection")).toBe(true);

package/tests/adapter/QueryDbListResolverTest.res

@@ -102,7 +102,7 @@ let pageInfoString = (response: JSON.t, key: string): option<string> =>
 // Per-test fixture — fresh Bus + storage + registry + resolver
 // ─────────────────────────────────────────────────────────────
 
-let buildFixture = async (~name: string) => {
+let buildFixture = async (~name: string, ~indexes: array<Reventless.ReadModel.indexConfig>=[]) => {
   module Bus = LocalBus.Make()
   module Storage = LocalQueryDbStorage.Make(Bus)
   module Resolvers = QueryDbResolvers_GraphQL.Make(Bus)
@@ -151,7 +151,7 @@ let buildFixture = async (~name: string) => {
     ~api=(),
     ~apiRole=(),
     ~dataSourceName=""->Pulumi.Output.make,
-    ~indexes=[],
+    ~indexes,
     ~subIdField=None,
     ~idResolverConfigs=[],
     ~idsResolverConfigs=[],
@@ -440,3 +440,83 @@ describe("QueryDb list resolver — SQLite push-down path", () => {
     })
   )
 })
+
+// The by-index door answers a Relay connection, keyed on the index's column.
+// Both halves used to be wrong here and in the opposite direction on AppSync:
+// this backend promised `[String]` and returned whole rows, so every call failed
+// to serialise before a caller could reach the rows at all.
+describe("QueryDb by-index resolver", () => {
+  let statusIndex: array<Reventless.ReadModel.indexConfig> = [
+    {index: "status", type_: "S", projectionType: ALL},
+  ]
+
+  let indexResolver = async (~name) => {
+    let _ = await buildFixture(~name, ~indexes=statusIndex)
+    switch DomainGraphQL_Server.getQueryResolver(name ++ "ByStatus") {
+    | Some(r) => r
+    | None => JsError.throwWithMessage("index resolver not registered: " ++ name ++ "ByStatus")
+    }
+  }
+
+  beforeEach(() => {
+    DomainGraphQL_Server.reset()
+  })
+
+  testPromise("answers the rows carrying the index value, as edges", async () => {
+    let resolver = await indexResolver(~name="IdxA")
+    let response = await resolver(JSON.Encode.null, argsOf([("status", strJson("active"))]), emptyCtx)
+    let edges = getEdges(response)
+    expect(edges->Array.length)->toBe(3)
+    expect(edgeNodeField(edges->Array.getUnsafe(0), "productId"))->toBe("p-1")
+  })
+
+  testPromise("pages forward on first/after like every other connection", async () => {
+    let resolver = await indexResolver(~name="IdxB")
+    let page1 =
+      await resolver(
+        JSON.Encode.null,
+        argsOf([("status", strJson("active")), ("first", numJson(2))]),
+        emptyCtx,
+      )
+    expect(getEdges(page1)->Array.length)->toBe(2)
+    expect(pageInfoBool(page1, "hasNextPage"))->toBe(true)
+
+    let page2 =
+      await resolver(
+        JSON.Encode.null,
+        argsOf([
+          ("status", strJson("active")),
+          ("first", numJson(2)),
+          ("after", strJson(pageInfoString(page1, "endCursor")->Option.getOr(""))),
+        ]),
+        emptyCtx,
+      )
+    let edges2 = getEdges(page2)
+    expect(edges2->Array.length)->toBe(1)
+    expect(edgeNodeField(edges2->Array.getUnsafe(0), "productId"))->toBe("p-4")
+    expect(pageInfoBool(page2, "hasNextPage"))->toBe(false)
+  })
+
+  // Refused rather than ignored, and refused here because AppSync cannot do it:
+  // a door that paged backward on one backend and quietly returned the forward
+  // page on the other is the divergence this whole field was rebuilt to remove.
+  testPromise("refuses backward paging instead of answering forward", async () => {
+    let resolver = await indexResolver(~name="IdxC")
+    let outcome = try {
+      let _ =
+        await resolver(
+          JSON.Encode.null,
+          argsOf([("status", strJson("active")), ("last", numJson(2))]),
+          emptyCtx,
+        )
+      Ok()
+    } catch {
+    | e => Error(e->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr(""))
+    }
+    switch outcome {
+    | Ok() => expect("no error")->toBe("a BAD_USER_INPUT refusal")
+    | Error(message) =>
+      expect(message->String.includes("Backward pagination (last/before) is not supported"))->toBe(true)
+    }
+  })
+})