@reventlessdev/reventless-local 3.0.0-alpha.233 → 3.0.0-alpha.235

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 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.235 (2026-08-22)
+
+* feat(core)!: a slice that has given up says so ([f5559ab](https://github.com/ReventlessDev/reventless-core/commit/f5559abede3a9cf2c9a48aadc69a666c46cc75bf))
+
+### BREAKING CHANGES
+
+* `onExhausted` is required on the Translation and Automation
+module types. ReScript has no optional module-type fields, so the alternative
+was a PPX-injected default — and defaulting this one to silence is the bug.
+A slice now states what abandonment means for its domain, `None` included.
+GeocodeCustomerAddress answers with MarkAddressUnresolvable; the others say
+nothing, on purpose.
+
+
+
+# 3.0.0-alpha.234 (2026-08-21)
+
+### Bug Fixes
+
+* **core:** make @resolves/[@resolves](https://github.com/resolves)Many work end to end ([4c52957](https://github.com/ReventlessDev/reventless-core/commit/4c5295759dcb4b3eda4f0f4f2c1bc387fed88fcb))
+* **deps:** update sury to 11.0.0-rc.2 to fix unreachable union constructors ([fa5744f](https://github.com/ReventlessDev/reventless-core/commit/fa5744fed8de975e2f14725c856c6e5ce7d04a74))
+
+
 # 3.0.0-alpha.233 (2026-08-20)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-local",
-  "version": "3.0.0-alpha.233",
+  "version": "3.0.0-alpha.235",
   "description": "Local platform for Reventless (in-memory or SQLite backend, for development and testing without AWS)",
   "license": "Apache-2.0",
   "bin": {
@@ -32,25 +32,25 @@
     "graphql": "^16.13.2",
     "graphql-ws": "^5.16.0",
     "graphql-yoga": "^5.21.0",
-    "sury": "11.0.0-rc.1",
+    "sury": "11.0.0-rc.2",
     "ws": "^8.18.0",
     "@reventlessdev/rescript-graphql-yoga": "1.0.0-alpha.27",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.245",
-    "@reventlessdev/reventless-gwt": "1.0.0-alpha.192",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.247",
+    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.95",
+    "@reventlessdev/reventless-gwt": "1.0.0-alpha.194",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.111",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.150",
     "@reventlessdev/reventless-seed": "1.0.0-alpha.17",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.120",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.109",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.148",
-    "@reventlessdev/reventless-graphql-server": "1.0.0-alpha.93"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.122"
   },
   "devDependencies": {
     "rescript": "12.3.0",
-    "sury-ppx": "11.0.0-rc.1",
+    "sury-ppx": "11.0.0-rc.2",
     "@reventlessdev/reventless-ppx": "1.0.0-alpha.72"
   },
   "peerDependencies": {

package/src/adapter/DomainGraphQL_Server.res

@@ -347,6 +347,10 @@ type bucket = {
   mutationResolvers: dict<resolverFn>,
   queryResolvers: dict<resolverFn>,
   subscriptionResolvers: dict<resolverFn>,
+  // Object-type field resolvers, keyed type name → field name. Carries the
+  // cross-table fields `@resolves` / `@resolvesMany` add to a queryable; their
+  // SDL rides the plugin's schema fragment, so only the map lives here.
+  fieldResolvers: dict<dict<resolverFn>>,
 }
 
 let makeBucket = (~scope: string): bucket => {
@@ -363,6 +367,7 @@ let makeBucket = (~scope: string): bucket => {
   mutationResolvers: Dict.make(),
   queryResolvers: Dict.make(),
   subscriptionResolvers: Dict.make(),
+  fieldResolvers: Dict.make(),
 }
 
 // Insertion order = composition order (platform bucket is forced first in
@@ -420,6 +425,15 @@ let relabelScope = (~from: string, ~to_: string) =>
         b.subscriptionResolvers
         ->Dict.toArray
         ->Array.forEach(((k, v)) => existing.subscriptionResolvers->Dict.set(k, v))
+        b.fieldResolvers
+        ->Dict.toArray
+        ->Array.forEach(((typeName, byField)) =>
+          switch existing.fieldResolvers->Dict.get(typeName) {
+          | Some(target) =>
+            byField->Dict.toArray->Array.forEach(((k, v)) => target->Dict.set(k, v))
+          | None => existing.fieldResolvers->Dict.set(typeName, byField)
+          }
+        )
       }
       if currentScope.contents == from {
         currentScope.contents = to_
@@ -453,6 +467,24 @@ let registerSubscriptions = (~sdlFields: array<string>, ~resolvers: dict<resolve
   resolvers->Dict.toArray->Array.forEach(((k, v)) => b.subscriptionResolvers->Dict.set(k, v))
 }
 
+let registerFieldResolvers = (~typeName: string, ~resolvers: dict<resolverFn>) => {
+  let b = currentBucket()
+  let forType = switch b.fieldResolvers->Dict.get(typeName) {
+  | Some(d) => d
+  | None =>
+    let d = Dict.make()
+    b.fieldResolvers->Dict.set(typeName, d)
+    d
+  }
+  resolvers->Dict.toArray->Array.forEach(((k, v)) => forType->Dict.set(k, v))
+}
+
+/** Look up a registered object-type field resolver. Searches all scope buckets. */
+let getFieldResolver = (~typeName: string, fieldName: string): option<resolverFn> =>
+  buckets.contents
+  ->Dict.valuesToArray
+  ->Array.findMap(b => b.fieldResolvers->Dict.get(typeName)->Option.flatMap(d => d->Dict.get(fieldName)))
+
 /** Look up a registered mutation resolver by field name (used by MCP_Server).
     Searches all scope buckets. */
 let getMutationResolver = (fieldName: string): option<resolverFn> =>
@@ -620,6 +652,9 @@ let scopeResolverMap = (b: bucket, ~withRootDefaults: bool): dict<dict<resolverF
   if b.subscriptionResolvers->Dict.keysToArray->Array.length > 0 {
     resolvers->Dict.set("Subscription", b.subscriptionResolvers)
   }
+  b.fieldResolvers
+  ->Dict.toArray
+  ->Array.forEach(((typeName, byField)) => resolvers->Dict.set(typeName, byField))
   resolvers
 }
 
@@ -913,6 +948,7 @@ let asInterface: ReventlessGraphqlServer.GraphQL_ServerInstance.t = {
   registerQueries,
   registerSubscriptions,
   registerTypes,
+  registerFieldResolvers,
   getMutationResolver,
   getQueryResolver,
   start,

package/src/adapter/DomainGraphQL_Server.res.mjs

@@ -252,7 +252,8 @@ function makeBucket(scope) {
     typeDefinitions: scope === platformScope ? [] : GraphQL_Stitcher$ReventlessCore.relayBaseTypes.slice(),
     mutationResolvers: {},
     queryResolvers: {},
-    subscriptionResolvers: {}
+    subscriptionResolvers: {},
+    fieldResolvers: {}
   };
 }
 
@@ -316,6 +317,18 @@ function relabelScope(from, to_) {
     Object.entries(b.subscriptionResolvers).forEach(param => {
       existing.subscriptionResolvers[param[0]] = param[1];
     });
+    Object.entries(b.fieldResolvers).forEach(param => {
+      let byField = param[1];
+      let typeName = param[0];
+      let target = existing.fieldResolvers[typeName];
+      if (target !== undefined) {
+        Object.entries(byField).forEach(param => {
+          target[param[0]] = param[1];
+        });
+      } else {
+        existing.fieldResolvers[typeName] = byField;
+      }
+    });
   } else {
     buckets.contents[to_] = b;
   }
@@ -354,6 +367,26 @@ function registerSubscriptions(sdlFields, resolvers) {
   });
 }
 
+function registerFieldResolvers(typeName, resolvers) {
+  let b = bucketFor(currentScope.contents);
+  let d = b.fieldResolvers[typeName];
+  let forType;
+  if (d !== undefined) {
+    forType = d;
+  } else {
+    let d$1 = {};
+    b.fieldResolvers[typeName] = d$1;
+    forType = d$1;
+  }
+  Object.entries(resolvers).forEach(param => {
+    forType[param[0]] = param[1];
+  });
+}
+
+function getFieldResolver(typeName, fieldName) {
+  return Stdlib_Array.findMap(Object.values(buckets.contents), b => Stdlib_Option.flatMap(b.fieldResolvers[typeName], d => d[fieldName]));
+}
+
 function getMutationResolver(fieldName) {
   return Stdlib_Array.findMap(Object.values(buckets.contents), b => b.mutationResolvers[fieldName]);
 }
@@ -486,6 +519,9 @@ function scopeResolverMap(b, withRootDefaults) {
   if (Object.keys(b.subscriptionResolvers).length !== 0) {
     resolvers["Subscription"] = b.subscriptionResolvers;
   }
+  Object.entries(b.fieldResolvers).forEach(param => {
+    resolvers[param[0]] = param[1];
+  });
   return resolvers;
 }
 
@@ -749,6 +785,7 @@ let asInterface = {
   registerQueries: registerQueries,
   registerSubscriptions: registerSubscriptions,
   registerTypes: registerTypes,
+  registerFieldResolvers: registerFieldResolvers,
   getMutationResolver: getMutationResolver,
   getQueryResolver: getQueryResolver,
   start: start,
@@ -798,6 +835,8 @@ export {
   registerMutations,
   registerQueries,
   registerSubscriptions,
+  registerFieldResolvers,
+  getFieldResolver,
   getMutationResolver,
   getQueryResolver,
   registerTypes,

package/src/adapter/GraphQL_Server.res.mjs

@@ -62,6 +62,10 @@ let registerQueries = DomainGraphQL_Server$ReventlessLocal.registerQueries;
 
 let registerSubscriptions = DomainGraphQL_Server$ReventlessLocal.registerSubscriptions;
 
+let registerFieldResolvers = DomainGraphQL_Server$ReventlessLocal.registerFieldResolvers;
+
+let getFieldResolver = DomainGraphQL_Server$ReventlessLocal.getFieldResolver;
+
 let getMutationResolver = DomainGraphQL_Server$ReventlessLocal.getMutationResolver;
 
 let getQueryResolver = DomainGraphQL_Server$ReventlessLocal.getQueryResolver;
@@ -157,6 +161,8 @@ export {
   registerMutations,
   registerQueries,
   registerSubscriptions,
+  registerFieldResolvers,
+  getFieldResolver,
   getMutationResolver,
   getQueryResolver,
   registerTypes,

package/src/adapter/PlatformGraphQL_Server.res

@@ -48,6 +48,10 @@ let registerQueries = (~sdlFields, ~resolvers) =>
   instance.registerQueries(~sdlFields, ~resolvers=wrapAdmin(resolvers))
 let registerSubscriptions = instance.registerSubscriptions
 let registerTypes = instance.registerTypes
+// Not admin-wrapped: a field resolver is only reached through a parent field
+// that already met the group check, so wrapping would re-refuse a caller the
+// root already admitted.
+let registerFieldResolvers = instance.registerFieldResolvers
 let getMutationResolver = instance.getMutationResolver
 let getQueryResolver = instance.getQueryResolver
 let start = instance.start
@@ -67,6 +71,7 @@ let asInterface: ReventlessGraphqlServer.GraphQL_ServerInstance.t = {
   registerQueries,
   registerSubscriptions,
   registerTypes,
+  registerFieldResolvers,
   getMutationResolver,
   getQueryResolver,
   start,

package/src/adapter/PlatformGraphQL_Server.res.mjs

@@ -25,6 +25,8 @@ let registerSubscriptions = instance.registerSubscriptions;
 
 let registerTypes = instance.registerTypes;
 
+let registerFieldResolvers = instance.registerFieldResolvers;
+
 let getMutationResolver = instance.getMutationResolver;
 
 let getQueryResolver = instance.getQueryResolver;
@@ -50,6 +52,7 @@ let asInterface = {
   registerQueries: registerQueries,
   registerSubscriptions: registerSubscriptions,
   registerTypes: registerTypes,
+  registerFieldResolvers: registerFieldResolvers,
   getMutationResolver: getMutationResolver,
   getQueryResolver: getQueryResolver,
   start: start,
@@ -69,6 +72,7 @@ export {
   registerQueries,
   registerSubscriptions,
   registerTypes,
+  registerFieldResolvers,
   getMutationResolver,
   getQueryResolver,
   start,

package/src/adapter/QueryDb/QueryDbResolvers_GraphQL.res

@@ -72,8 +72,8 @@ module Make = (Bus: LocalBus.T) => {
     ~dataSourceName as _,
     ~indexes,
     ~subIdField,
-    ~idResolverConfigs as _,
-    ~idsResolverConfigs as _,
+    ~idResolverConfigs,
+    ~idsResolverConfigs,
     ~authorization,
     ~opts as _,
   ) => {
@@ -913,6 +913,175 @@ module Make = (Bus: LocalBus.T) => {
       },
     )
 
+    // -- Cross-table fields: @resolves / @resolvesMany -------------------------
+    // Field resolvers on this view's object type, following a foreign key into
+    // another queryable's rows. Their SDL rides the plugin's schema fragment
+    // (`GraphQL_FragmentGenerator` emits it from the same config), so only the
+    // resolvers are registered here.
+    //
+    // The rows are the TARGET's, so the target's `@owner` / `@retired` rules
+    // narrow them — the same reading the AppSync resolver bakes into its
+    // response. A nested field takes no `includeRetired` argument, so a retired
+    // row never travels through one; `{list}Refs` is the door that names those.
+    let targetAllows = (~ctx, ~target: string, item: JSON.t): bool => {
+      let schema = Plugin_Helpers.stateSchemaRegistry->Dict.get(target)
+      let cell = field => item->JSON.Decode.object->Option.flatMap(d => d->Dict.get(field))
+      let identity = extractIdentity(ctx)
+      let ownerOk = switch identity->Reventless.OwnerScope.decide(
+        ~ownerField=schema->Option.flatMap(s => Reventless.Owner.fieldNames(s)->Array.get(0)),
+      ) {
+      | Unscoped => true
+      | RefuseOwned => false
+      | ScopeTo(field, required) =>
+        cell(field)->Option.flatMap(JSON.Decode.string)->Option.mapOr(false, v => v == required)
+      }
+      let retiredSpec =
+        schema
+        ->Option.flatMap(Reventless.StateAnnotations.getSpec)
+        ->Option.flatMap(spec => spec.retired)
+      let retiredOk = switch identity
+      ->Reventless.OwnerScope.decideRetired(
+        ~retiredField=retiredSpec->Option.map(r => r.field),
+        ~retiredValues=?retiredSpec->Option.flatMap(r => r.values),
+        ~asked=false,
+      )
+      ->Reventless.OwnerScope.retiredScopeOf {
+      | None => true
+      | Some(scope) => !(scope->Reventless.OwnerScope.isRetiredValue(cell(scope.field)))
+      }
+      ownerOk && retiredOk
+    }
+
+    // The storage key the row was loaded by, reported as `id` — the nested type
+    // is a `Node`, so the field is non-null, and `loadStream` hands back the
+    // stored value without one.
+    let withId = (~key: string, item: JSON.t): JSON.t => {
+      let obj = item->JSON.Decode.object->Option.mapOr(Dict.make(), Dict.copy)
+      obj->Dict.set("id", JSON.Encode.string(key))
+      JSON.Encode.object(obj)
+    }
+    let loadFrom = async (~target: string, key: string): array<JSON.t> =>
+      switch Bus.getQueryDb(target) {
+      | Some(ops) =>
+        await ops.loadStream(key)
+        ->Stream.runCollect
+        ->Effect.catchAll(_ => Effect.succeed([]))
+        ->Effect.runPromise
+      | None => []
+      }
+
+    let lookupByIndexIn = (~target: string, ~field: string, value: string): array<JSON.t> =>
+      switch Bus.getQueryDbIndexLookup(target) {
+      | Some(lookup) => lookup(field, value)
+      | None =>
+        switch Bus.getQueryDbScan(target) {
+        | Some(scanAll) =>
+          scanAll()->Array.filter(item =>
+            item
+            ->JSON.Decode.object
+            ->Option.flatMap(d => d->Dict.get(field))
+            ->Option.flatMap(JSON.Decode.string)
+            ->Option.mapOr(false, v => v == value)
+          )
+        | None => []
+        }
+      }
+
+    let sourceField = (root: JSON.t, field: string): option<JSON.t> =>
+      root->JSON.Decode.object->Option.flatMap(d => d->Dict.get(field))
+
+    let fieldResolvers = Dict.make()
+
+    idResolverConfigs->Array.forEach((config: Reventless.ReadModel.idResolverConfig) => {
+      let {source: {idField, subId, resolvedField}, target} = config
+      let (fieldName, multi) = switch resolvedField {
+      | Single(f) => (f, false)
+      | Multi(f) => (f, true)
+      }
+      let targetName = target.tableName
+      let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
+        root,
+        args,
+        ctx,
+      ) => {
+        let key =
+          root->sourceField(idField)->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+        let rows = if key == "" {
+          []
+        } else {
+          switch target.idField {
+          | Id => (await loadFrom(~target=targetName, key))->Array.map(withId(~key, ...))
+          | Index(index) => lookupByIndexIn(~target=targetName, ~field=index, key)
+          | IndexWithId(_, targetIdField) =>
+            lookupByIndexIn(~target=targetName, ~field=targetIdField, key)
+          }
+        }
+        // The target's sort key, taken from the parent row or from an argument on
+        // the field — the same two sources the AppSync template reads.
+        let narrowed = switch (subId, target.subIdField) {
+        | (Field(sourceSortField), Some(targetSortField)) =>
+          let want = root->sourceField(sourceSortField)->Option.flatMap(JSON.Decode.string)
+          rows->Array.filter(item =>
+            item
+            ->JSON.Decode.object
+            ->Option.flatMap(d => d->Dict.get(targetSortField))
+            ->Option.flatMap(JSON.Decode.string) == want
+          )
+        | (Argument(sortArgument), Some(targetSortField)) =>
+          switch args->JSON.Decode.object->Option.flatMap(d => d->Dict.get(sortArgument)) {
+          | None => rows
+          | Some(want) =>
+            rows->Array.filter(item =>
+              item
+              ->JSON.Decode.object
+              ->Option.flatMap(d => d->Dict.get(targetSortField))
+              ->Option.flatMap(JSON.Decode.string) == want->JSON.Decode.string
+            )
+          }
+        | _ => rows
+        }
+        let allowed = narrowed->Array.filter(item => targetAllows(~ctx, ~target=targetName, item))
+        if multi {
+          allowed->JSON.Encode.array
+        } else {
+          allowed->Array.get(0)->Option.getOr(JSON.Encode.null)
+        }
+      }
+      fieldResolvers->Dict.set(fieldName, resolver)
+    })
+
+    idsResolverConfigs->Array.forEach((config: Reventless.ReadModel.idsResolverConfig) => {
+      let {source: {idsField, resolvedField}, target} = config
+      let targetName = target.tableName
+      let resolver: ReventlessGraphqlServer.GraphQL_ServerInstance.resolverFn = async (
+        root,
+        _args,
+        ctx,
+      ) => {
+        let ids =
+          root
+          ->sourceField(idsField)
+          ->Option.flatMap(JSON.Decode.array)
+          ->Option.getOr([])
+          ->Array.filterMap(JSON.Decode.string)
+        // Missing ids drop out rather than becoming nulls, matching BatchGetItem
+        // and the by-ids door built on it.
+        let rows = await ids->Array.map(async key =>
+          (await loadFrom(~target=targetName, key))->Array.get(0)->Option.map(withId(~key, ...))
+        )->Promise.all
+        rows
+        ->Array.filterMap(row =>
+          row->Option.filter(item => targetAllows(~ctx, ~target=targetName, item))
+        )
+        ->JSON.Encode.array
+      }
+      fieldResolvers->Dict.set(resolvedField, resolver)
+    })
+
+    if fieldResolvers->Dict.keysToArray->Array.length > 0 {
+      server.registerFieldResolvers(~typeName=returnTypeName, ~resolvers=fieldResolvers)
+    }
+
     // -- Register all fields --------------------------------------------------
     let allSdl =
       [byIdSdl]

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

@@ -8,6 +8,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 Owner$Reventless from "@reventlessdev/reventless-spec/src/components/Owner.res.mjs";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
 import * as OwnerScope$Reventless from "@reventlessdev/reventless-spec/src/types/OwnerScope.res.mjs";
 import * as Api_Ids$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/Api_Ids.res.mjs";
@@ -54,7 +55,7 @@ function Make(Bus) {
       nodeTypeRegistry: DomainGraphQL_Server$ReventlessLocal.nodeTypeRegistry
     }
   };
-  let make = (name, param, param$1, param$2, indexes, subIdField, param$3, param$4, authorization, param$5) => {
+  let make = (name, param, param$1, param$2, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, param$3) => {
     let server = serverRef.contents;
     let relay = relayRef.contents;
     if (relay !== undefined) {
@@ -617,6 +618,122 @@ function Make(Bus) {
         resolver
       ];
     });
+    let targetAllows = (ctx, target, item) => {
+      let schema = Plugin_Helpers$ReventlessCore.stateSchemaRegistry[target];
+      let cell = field => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[field]);
+      let identity = extractIdentity(ctx);
+      let match = OwnerScope$Reventless.decide(identity, Stdlib_Option.flatMap(schema, s => Owner$Reventless.fieldNames(s)[0]), undefined);
+      let ownerOk;
+      if (typeof match !== "object") {
+        ownerOk = match === "Unscoped";
+      } else {
+        let required = match._1;
+        ownerOk = Stdlib_Option.mapOr(Stdlib_Option.flatMap(cell(match._0), Stdlib_JSON.Decode.string), false, v => v === required);
+      }
+      let retiredSpec = Stdlib_Option.flatMap(Stdlib_Option.flatMap(schema, StateAnnotations$Reventless.getSpec), spec => spec.retired);
+      let scope = OwnerScope$Reventless.retiredScopeOf(OwnerScope$Reventless.decideRetired(identity, Stdlib_Option.map(retiredSpec, r => r.field), Stdlib_Option.flatMap(retiredSpec, r => r.values), false, undefined));
+      let retiredOk = scope !== undefined ? !OwnerScope$Reventless.isRetiredValue(scope, cell(scope.field)) : true;
+      if (ownerOk) {
+        return retiredOk;
+      } else {
+        return false;
+      }
+    };
+    let withId = (key, item) => {
+      let obj = Stdlib_Option.mapOr(Stdlib_JSON.Decode.object(item), {}, prim => Object.assign({}, prim));
+      obj["id"] = key;
+      return obj;
+    };
+    let loadFrom = async (target, key) => {
+      let ops = Bus.getQueryDb(target);
+      if (ops !== undefined) {
+        return await Effect.runPromise(Effect.catchAll(Stream.runCollect(ops.loadStream(key)), param => Effect.succeed([])));
+      } else {
+        return [];
+      }
+    };
+    let lookupByIndexIn = (target, field, value) => {
+      let lookup = Bus.getQueryDbIndexLookup(target);
+      if (lookup !== undefined) {
+        return lookup(field, value);
+      }
+      let scanAll = Bus.getQueryDbScan(target);
+      if (scanAll !== undefined) {
+        return scanAll().filter(item => Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[field]), Stdlib_JSON.Decode.string), false, v => v === value));
+      } else {
+        return [];
+      }
+    };
+    let sourceField = (root, field) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(root), d => d[field]);
+    let fieldResolvers = {};
+    idResolverConfigs.forEach(config => {
+      let target = config.target;
+      let match = config.source;
+      let resolvedField = match.resolvedField;
+      let subId = match.subId;
+      let idField = match.idField;
+      let match$1;
+      match$1 = resolvedField.TAG === "Single" ? [
+          resolvedField._0,
+          false
+        ] : [
+          resolvedField._0,
+          true
+        ];
+      let multi = match$1[1];
+      let targetName = target.tableName;
+      let resolver = async (root, args, ctx) => {
+        let key = Stdlib_Option.getOr(Stdlib_Option.flatMap(sourceField(root, idField), Stdlib_JSON.Decode.string), "");
+        let rows;
+        if (key === "") {
+          rows = [];
+        } else {
+          let index = target.idField;
+          rows = typeof index !== "object" ? (await loadFrom(targetName, key)).map(extra => withId(key, extra)) : (
+              index.TAG === "Index" ? lookupByIndexIn(targetName, index._0, key) : lookupByIndexIn(targetName, index._1, key)
+            );
+        }
+        let match = target.subIdField;
+        let narrowed;
+        if (typeof subId !== "object") {
+          narrowed = rows;
+        } else if (subId.TAG === "Field") {
+          if (match !== undefined) {
+            let want = Stdlib_Option.flatMap(sourceField(root, subId._0), Stdlib_JSON.Decode.string);
+            narrowed = rows.filter(item => Primitive_object.equal(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[match]), Stdlib_JSON.Decode.string), want));
+          } else {
+            narrowed = rows;
+          }
+        } else if (match !== undefined) {
+          let sortArgument = subId._0;
+          let want$1 = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(args), d => d[sortArgument]);
+          narrowed = want$1 !== undefined ? rows.filter(item => Primitive_object.equal(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[match]), Stdlib_JSON.Decode.string), Stdlib_JSON.Decode.string(want$1))) : rows;
+        } else {
+          narrowed = rows;
+        }
+        let allowed = narrowed.filter(item => targetAllows(ctx, targetName, item));
+        if (multi) {
+          return allowed;
+        } else {
+          return Stdlib_Option.getOr(allowed[0], null);
+        }
+      };
+      fieldResolvers[match$1[0]] = resolver;
+    });
+    idsResolverConfigs.forEach(config => {
+      let match = config.source;
+      let idsField = match.idsField;
+      let targetName = config.target.tableName;
+      let resolver = async (root, _args, ctx) => {
+        let ids = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(sourceField(root, idsField), Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.string);
+        let rows = await Promise.all(ids.map(async key => Stdlib_Option.map((await loadFrom(targetName, key))[0], extra => withId(key, extra))));
+        return Stdlib_Array.filterMap(rows, row => Stdlib_Option.filter(row, item => targetAllows(ctx, targetName, item)));
+      };
+      fieldResolvers[match.resolvedField] = resolver;
+    });
+    if (Object.keys(fieldResolvers).length !== 0) {
+      server.registerFieldResolvers(returnTypeName, fieldResolvers);
+    }
     let allSdl = [byIdSdl].concat(byIdsSdl).concat(refsSdl).concat(match[0]).concat(itemsSdl).concat(indexSdlFields);
     let resolvers = {};
     resolvers[singleQueryName] = byIdResolver;