@reventlessdev/reventless-local 3.0.0-alpha.226 → 3.0.0-alpha.228

package/src/adapter/DomainGraphQL_Server.res

@@ -110,7 +110,7 @@ let handleLogin = (req: nodeRequest, res: nodeResponse): unit =>
           | None => Reventless.Identity.anonymous
           }
           let identityJson =
-            identity->S.reverseConvertToJsonOrThrow(Reventless.Identity.schema)
+            identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema)
           _writeJson(
             res,
             ~status=200,
@@ -171,7 +171,7 @@ let handleSwitchRole = (req: nodeRequest, res: nodeResponse): unit =>
               ("token", JSON.Encode.string(newToken)),
               (
                 "identity",
-                identity->S.reverseConvertToJsonOrThrow(Reventless.Identity.schema),
+                identity->Reventless.Util_Sury.toJson(Reventless.Identity.schema),
               ),
             ]),
           ),

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
 import * as Http from "http";
 import * as Graphql from "graphql";
 import * as GraphqlYoga from "@reventlessdev/rescript-graphql-yoga/src/GraphqlYoga.res.mjs";
@@ -14,6 +13,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 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 Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 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";
@@ -75,7 +75,7 @@ function handleLogin(req, res) {
       if (result.TAG === "Ok") {
         let i = LocalAuth$ReventlessLocal.Login.mintedIdentity(username, activeRole);
         let identity = i !== undefined ? i : Identity$Reventless.anonymous;
-        let identityJson = S.reverseConvertToJsonOrThrow(identity, Identity$Reventless.schema);
+        let identityJson = Util_Sury$Reventless.toJson(identity, Identity$Reventless.schema);
         _writeJson(res, 200, Object.fromEntries([
           [
             "token",
@@ -130,7 +130,7 @@ function handleSwitchRole(req, res) {
       ],
       [
         "identity",
-        S.reverseConvertToJsonOrThrow(identity, Identity$Reventless.schema)
+        Util_Sury$Reventless.toJson(identity, Identity$Reventless.schema)
       ]
     ]));
   });

package/src/adapter/DomainMCP_Server.res

@@ -143,7 +143,7 @@ let extractIdentity = (req: McpSdk.incomingMessage): Reventless.Identity.t => {
     | Some(json) =>
       json
       ->JSON.parseOrThrow
-      ->S.parseOrThrow(Reventless.Identity.schema)
+      ->S.parseOrThrow(~to=Reventless.Identity.schema)
     | None => Reventless.Identity.anonymous
     }
   } catch {

package/src/adapter/MCP_ServerInstance.res

@@ -157,7 +157,7 @@ let make = (~label: string="MCP"): t => {
       | Some(json) =>
         json
         ->JSON.parseOrThrow
-        ->S.parseOrThrow(Reventless.Identity.schema)
+        ->S.parseOrThrow(~to=Reventless.Identity.schema)
       | None => Reventless.Identity.anonymous
       }
     } catch {

package/src/adapter/QueryDb/QueryDbResolvers_GraphQL.res

@@ -228,8 +228,6 @@ module Make = (Bus: LocalBus.T) => {
         )
       }
 
-    let cap = s => s->String.charAt(0)->String.toUpperCase ++ s->String.slice(~start=1)
-
     // Resolve query field names: check registry first, fall back to safe defaults.
     // Fallbacks use simple GraphQL built-in types to avoid referencing non-existent custom types.
     let registryEntry = Plugin_Helpers.queryFieldNamesRegistry->Dict.get(name)
@@ -271,10 +269,16 @@ module Make = (Bus: LocalBus.T) => {
     }
 
     // -- Main query: getById ---------------------------------------------------
+    // `includeRetired` here matches the connection field and the AppSync SDL the
+    // FragmentGenerator emits. The resolver below already reads it — `retiredAllows`
+    // consults `askedForRetired(~args)` on every door — so this argument was the
+    // only missing half, and without it an elevated caller could see an archived
+    // row in a list and not open it.
     let byIdSdl = if includeIdParam {
       switch subIdField {
-      | Some(sf) => `  ${singleQueryName}(id: ID!, ${sf}: String): ${returnTypeName}`
-      | None => `  ${singleQueryName}(id: ID!): ${returnTypeName}`
+      | Some(sf) =>
+        `  ${singleQueryName}(id: ID!, ${sf}: String, includeRetired: Boolean): ${returnTypeName}`
+      | None => `  ${singleQueryName}(id: ID!, includeRetired: Boolean): ${returnTypeName}`
       }
     } else {
       `  ${singleQueryName}: ${returnTypeName}`
@@ -402,6 +406,124 @@ module Make = (Bus: LocalBus.T) => {
     | None => "id"
     }
 
+    // -- Reference door: {listFieldName}Refs -----------------------------------
+    // Names the rows a caller already holds pointers to, and nothing more. Three
+    // fields, fixed by the type, so this cannot be widened by what a caller
+    // selects.
+    //
+    // Retirement is lifted here only where the view declared `@namedWhenRetired`.
+    // Ownership is not lifted at all, and the asymmetry is the point: an archived
+    // product is a thing the shop sold and every order naming one may say what it
+    // was, while a deactivated customer is somebody's row before it is anything
+    // else. One predicate answers "is this row still on offer", the other "is this
+    // row yours", and only the first is what an archive withdraws.
+    let refsSdl = if includeIdParam && subIdField === None {
+      [GraphQL_FragmentGenerator.deriveRefsQueryField(~listFieldName=listQueryName, ~returnTypeName)]
+    } else {
+      []
+    }
+    let refsResolverEntry: option<(string, ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn)> =
+      if includeIdParam && subIdField === None {
+        server.registerTypes(~sdlTypes=[GraphQL_FragmentGenerator.deriveRefTypeSdl(~returnTypeName)])
+        let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
+          _root,
+          args,
+          ctx,
+        ) => {
+          switch await runInterceptor(~ctx, ~args) {
+          | Deny(_) => []->JSON.Encode.array
+          | Allow =>
+            let ids =
+              args
+              ->JSON.Decode.object
+              ->Option.flatMap(d => d->Dict.get("ids"))
+              ->Option.flatMap(JSON.Decode.array)
+              ->Option.getOr([])
+              ->Array.filterMap(JSON.Decode.string)
+            let spec = retiredSpecOf()
+            let namesRetired = spec->Option.mapOr(false, r => r.namedWhenRetired)
+            // The row's own retirement, read with the same `isRetiredValue` every
+            // other door narrows by — so "retired" here and "withheld" there are
+            // one answer, not two that drift.
+            let retirementOf = (item: JSON.t) =>
+              switch spec {
+              | None => (false, None)
+              | Some(r) =>
+                let cell = item->JSON.Decode.object->Option.flatMap(d => d->Dict.get(r.field))
+                let scope: Reventless.OwnerScope.retiredScope = {field: r.field, values: r.values}
+                let retired = scope->Reventless.OwnerScope.isRetiredValue(cell)
+                (
+                  retired,
+                  // The state that retired it, and only that. A live row reports
+                  // none — this door names rows, it does not publish a lifecycle
+                  // column to callers the list withholds. Nor does the boolean
+                  // form, where the field is the state and `retired` said it.
+                  retired && r.values->Option.isSome
+                    ? cell->Option.flatMap(JSON.Decode.string)
+                    : None,
+                )
+              }
+            switch Bus.getQueryDb(name) {
+            | Some(ops) =>
+              let load = key =>
+                ops.loadStream(key)
+                ->Stream.runCollect
+                ->Effect.catchAll(_ => Effect.succeed([]))
+                ->Effect.runPromise
+              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.filter(item => ownerAllows(~ctx, item))
+                ->Option.flatMap(item => {
+                  let (retired, state) = retirementOf(item)
+                  // A retired row leaves through this door only where the view
+                  // said it may. Where it did not, the door answers exactly as
+                  // every other one does — with nothing.
+                  if retired && !namesRetired {
+                    None
+                  } else {
+                    let label =
+                      item
+                      ->JSON.Decode.object
+                      ->Option.flatMap(d => d->Dict.get(labelField))
+                      ->Option.flatMap(JSON.Decode.string)
+                      // A view with no label field resolves to its id, which is
+                      // what `labelField`'s own fallback already decided.
+                      ->Option.getOr(id)
+                    Some(
+                      Dict.fromArray([
+                        ("id", JSON.Encode.string(id)),
+                        ("label", JSON.Encode.string(label)),
+                        ("retired", JSON.Encode.bool(retired)),
+                        (
+                          "retiredState",
+                          state->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+                        ),
+                      ])->JSON.Encode.object,
+                    )
+                  }
+                })
+              )
+              ->JSON.Encode.array
+            | None => []->JSON.Encode.array
+            }
+          }
+        }
+        Some((listQueryName ++ "Refs", resolver))
+      } else {
+        None
+      }
+
     // -- List query -------------------------------------------------------------
     // Look up the registered state schema (populated alongside queryFieldNamesRegistry)
     // so the resolver derives the same serverCapability the FragmentGenerator emitted.
@@ -666,20 +788,95 @@ module Make = (Bus: LocalBus.T) => {
     }
 
     // -- Index queries: {name}By{Index} ---------------------------------------
+    // Name, argument and return type all come from `GraphQL_FragmentGenerator`,
+    // which is also where the AppSync SDL gets them. They used to be spelled out
+    // here independently and disagreed with that emitter on all three, so the
+    // same door had a different signature per backend and worked on neither.
     let indexSdlFields = indexes->Array.map((ic: Reventless.ReadModel.indexConfig) =>
-      `  ${singleQueryName}By${cap(ic.index)}(${ic.index}: String!): [String]`
+      GraphQL_FragmentGenerator.deriveIndexQueryField(
+        ~singleFieldName=singleQueryName,
+        ~indexConfig=ic,
+        ~connectionTypeName=returnTypeName ++ "Connection",
+      )
     )
+    // Backward paging is refused rather than ignored, and refused on both
+    // backends rather than on the one that cannot do it. `listAllItemsConnection`
+    // already sets the rule for a door whose read cannot walk backwards — "fail
+    // loud rather than silently returning the forward page" — and its reasoning
+    // is about the answer, not about DynamoDB: `last: 2` handed the first two
+    // rows is a different question answered without saying so.
+    //
+    // The arguments stay in the SDL. One that appeared and disappeared with the
+    // backend would make adding a sort key a breaking schema change and force
+    // every client to feature-detect, which is the same argument `includeRetired`
+    // and the reference door are emitted unconditionally for.
+    let rejectBackwardPaging = (~args) => {
+      let given = key =>
+        switch args->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key)) {
+        | None | Some(JSON.Null) => false
+        | Some(_) => true
+        }
+      if given("last") || given("before") {
+        throw(
+          GraphQL_CallerError.badUserInput(
+            "Backward pagination (last/before) is not supported on by-index connections; use first/after.",
+          ),
+        )
+      }
+    }
+    // A positional connection. This door answers an equality lookup on one index
+    // value and has no ordering key to cut a cursor from — the list door borrows
+    // its sort key because it orders by one. An offset is stable for as long as
+    // a page-forward takes, which is what the field advertises and no more.
+    let indexConnection = (~args, items: array<JSON.t>) => {
+      let arg = key => args->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))
+      let after =
+        arg("after")->Option.flatMap(JSON.Decode.string)->Option.flatMap(s => Int.fromString(s))->Option.getOr(-1)
+      let first =
+        arg("first")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)->Option.getOr(50)
+      let start = after + 1
+      let page = items->Array.slice(~start, ~end=start + first)
+      let taken = page->Array.length
+      let edges =
+        page->Array.mapWithIndex((item, i) =>
+          Dict.fromArray([
+            ("node", item),
+            ("cursor", (start + i)->Int.toString->JSON.Encode.string),
+          ])->JSON.Encode.object
+        )
+      let cursorAt = i => i->Int.toString->JSON.Encode.string
+      Dict.fromArray([
+        ("edges", edges->JSON.Encode.array),
+        (
+          "pageInfo",
+          Dict.fromArray([
+            ("hasNextPage", JSON.Encode.bool(start + taken < items->Array.length)),
+            ("hasPreviousPage", JSON.Encode.bool(start > 0)),
+            ("startCursor", taken > 0 ? cursorAt(start) : JSON.Encode.null),
+            ("endCursor", taken > 0 ? cursorAt(start + taken - 1) : JSON.Encode.null),
+          ])->JSON.Encode.object,
+        ),
+      ])->JSON.Encode.object
+    }
     let indexResolvers: array<(string, ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn)> = indexes->Array.map(
       (ic: Reventless.ReadModel.indexConfig) => {
-        let index = ic.index
-        let resolverName = singleQueryName ++ "By" ++ cap(index)
-        let filterField = ic.idField->Option.getOr(index)
+        let resolverName = GraphQL_FragmentGenerator.indexQueryFieldName(
+          ~singleFieldName=singleQueryName,
+          ~index=ic.index,
+        )
+        // The argument the caller passes and the row field this filters on are
+        // one and the same — the door reads the index's key, not its name.
+        let filterField = GraphQL_FragmentGenerator.indexKeyField(ic)
         let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (_root, args, ctx) => {
           switch await runInterceptor(~ctx, ~args) {
-          | Deny(_) => []->JSON.Encode.array
+          | Deny(_) => indexConnection(~args, [])
           | Allow =>
+            // After the interceptor, matching the AppSync pipeline, where the
+            // interceptor leads the chain and the query function's `request`
+            // raises this second.
+            rejectBackwardPaging(~args)
             let value =
-              args->JSON.Decode.object->Option.flatMap(d => d->Dict.get(index))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+              args->JSON.Decode.object->Option.flatMap(d => d->Dict.get(filterField))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
             // Applied to whichever arm answers, rather than inside one of them: the
             // push-down and the scan are two ways to reach the same rows, and a
             // narrowing that lives in only one is a hole that appears when a
@@ -690,22 +887,24 @@ module Make = (Bus: LocalBus.T) => {
             // in-memory reuses its lazy snapshot). Fall back to scan+filter only
             // if no lookup is registered for this QueryDb.
             switch Bus.getQueryDbIndexLookup(name) {
-            | Some(lookup) => lookup(filterField, value)->scoped->JSON.Encode.array
+            | Some(lookup) => indexConnection(~args, lookup(filterField, value)->scoped)
             | None =>
               switch Bus.getQueryDbScan(name) {
               | Some(scanAll) =>
-                scanAll()
-                ->Array.filter(item =>
-                  item
-                  ->JSON.Decode.object
-                  ->Option.flatMap(d => d->Dict.get(filterField))
-                  ->Option.flatMap(JSON.Decode.string)
-                  ->Option.map(v => v == value)
-                  ->Option.getOr(false)
+                indexConnection(
+                  ~args,
+                  scanAll()
+                  ->Array.filter(item =>
+                    item
+                    ->JSON.Decode.object
+                    ->Option.flatMap(d => d->Dict.get(filterField))
+                    ->Option.flatMap(JSON.Decode.string)
+                    ->Option.map(v => v == value)
+                    ->Option.getOr(false)
+                  )
+                  ->scoped,
                 )
-                ->scoped
-                ->JSON.Encode.array
-              | None => []->JSON.Encode.array
+              | None => indexConnection(~args, [])
               }
             }
           }
@@ -718,6 +917,7 @@ module Make = (Bus: LocalBus.T) => {
     let allSdl =
       [byIdSdl]
       ->Array.concat(byIdsSdl)
+      ->Array.concat(refsSdl)
       ->Array.concat(listSdl)
       ->Array.concat(itemsSdl)
       ->Array.concat(indexSdlFields)
@@ -725,6 +925,7 @@ module Make = (Bus: LocalBus.T) => {
     let resolvers = Dict.make()
     resolvers->Dict.set(singleQueryName, byIdResolver)
     byIdsResolverEntry->Option.forEach(((k, v)) => resolvers->Dict.set(k, v))
+    refsResolverEntry->Option.forEach(((k, v)) => resolvers->Dict.set(k, v))
     listResolvers->Array.forEach(((k, v)) => resolvers->Dict.set(k, v))
     itemsResolvers->Array.forEach(((k, v)) => resolvers->Dict.set(k, v))
     indexResolvers->Array.forEach(((k, v)) => resolvers->Dict.set(k, v))

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];
     });