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

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 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.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.234",
   "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-graphql-yoga": "1.0.0-alpha.27",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-mcp-sdk": "1.0.0-alpha.21",
     "@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-graphql-server": "1.0.0-alpha.94",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.246",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.149",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.110",
     "@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-gwt": "1.0.0-alpha.193",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.121"
   },
   "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;

package/tests/adapter/QueryDbResolvedFieldsTest.res

@@ -0,0 +1,253 @@
+// Behavioural tests for the in-memory cross-table field resolvers
+// (`@resolves` / `@resolvesMany`). An Orders view carries a foreign `productId`
+// and a `productIds` array; both follow into a Products view's rows.
+//
+// The rows handed back are the TARGET's, so the target's `@retired` rule narrows
+// them — the same reading the AppSync response bakes in. A nested field takes no
+// `includeRetired` argument, so a retired row never travels through one.
+
+@@warning("-44")
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+@schema
+type productRow = {productId: string, name: string, archived: bool}
+
+@schema
+type orderRow = {orderId: string, productId: string, productIds: array<string>}
+
+let annotations = (~retired: option<Reventless.StateAnnotations.retiredSpec>) => {
+  Reventless.StateAnnotations.ids: [],
+  compositeIds: [],
+  subIds: [],
+  compositeSubIds: [],
+  indexes: [],
+  hidden: [],
+  summary: [],
+  drillTargets: [],
+  drillTargetKeys: [],
+  collapsed: [],
+  scan: [],
+  scanSort: [],
+  semantic: [],
+  metric: [],
+  lifecycle: None,
+  groupBy: None,
+  visibility: None,
+  live: None,
+  retired,
+}
+
+let ctxFor = (~groups: array<string>): JSON.t =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      (
+        "request",
+        JSON.Encode.object(Dict.fromArray([("headers", JSON.Encode.object(Dict.make()))])),
+      ),
+      (
+        "identity",
+        (
+          {
+            ...Reventless.Identity.anonymous,
+            userId: "test-user",
+            username: "test-user",
+            groups,
+          }: Reventless.Identity.t
+        )->Obj.magic,
+      ),
+    ]),
+  )
+
+let plainCtx = ctxFor(~groups=["User"])
+
+let noArgs: JSON.t = JSON.Encode.object(Dict.make())
+
+let getString = (json: JSON.t, key: string): option<string> =>
+  json->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.string)
+
+let names = (json: JSON.t): array<string> =>
+  json->JSON.Decode.array->Option.getOr([])->Array.filterMap(item => item->getString("name"))
+
+// One Bus carrying both views, resolvers registered for the Orders view with the
+// two configs the PPX writes from `@resolves` / `@resolvesMany`.
+let buildFixture = async (~suffix: string, ~retired: option<Reventless.StateAnnotations.retiredSpec>) => {
+  module Bus = LocalBus.Make()
+  module Storage = LocalQueryDbStorage.Make(Bus)
+  module Resolvers = QueryDbResolvers_GraphQL.Make(Bus)
+
+  let productsName = "Products" ++ suffix
+  let ordersName = "Orders" ++ suffix
+  let orderTypeName = "Shop_Order" ++ suffix
+
+  module ProductsSpec = {
+    module Id = Reventless.Id.StringPure
+    let name = productsName
+    let moduleUrl: string = %raw(`import.meta.url`)
+    @schema
+    type state = productRow
+    let config = Reventless.ReadModel.config()
+    let subIdConfig = None
+    let authorization: Reventless.Authorization.permission = AllowAuthenticated
+    let visibility: Reventless.Visibility.t = Public
+  }
+
+  module OrdersSpec = {
+    module Id = Reventless.Id.StringPure
+    let name = ordersName
+    let moduleUrl: string = %raw(`import.meta.url`)
+    @schema
+    type state = orderRow
+    let config = Reventless.ReadModel.config(
+      ~idResolvers=[
+        {
+          source: {
+            Reventless.ReadModel.idField: "productId",
+            subId: NoSubId,
+            resolvedField: Single("product"),
+          },
+          target: {Reventless.ReadModel.tableName: productsName, idField: Id},
+        },
+      ],
+      ~idsResolvers=[
+        {
+          source: {Reventless.ReadModel.idsField: "productIds", resolvedField: "products"},
+          target: {Reventless.ReadModel.tableName: productsName},
+        },
+      ],
+    )
+    let subIdConfig = None
+    let authorization: Reventless.Authorization.permission = AllowAuthenticated
+    let visibility: Reventless.Visibility.t = Public
+  }
+
+  module NoResolvers = ReventlessCore.QueryDb_Adapter.NoResolvers(Storage)
+  module ProductsDb = ReventlessCore.QueryDb_Builder.Make(ProductsSpec, Storage, NoResolvers)
+  module OrdersDb = ReventlessCore.QueryDb_Builder.Make(OrdersSpec, Storage, NoResolvers)
+
+  let register = (~viewName, ~returnTypeName) =>
+    ReventlessCore.Plugin_Helpers.queryFieldNamesRegistry->Dict.set(
+      viewName,
+      {
+        singleFieldName: returnTypeName,
+        listFieldName: returnTypeName ++ "s",
+        returnTypeName,
+        pluralTypeName: returnTypeName ++ "s",
+        includeIdParam: true,
+        connectionSpec: true,
+      },
+    )
+  register(~viewName=productsName, ~returnTypeName="Shop_Product" ++ suffix)
+  register(~viewName=ordersName, ~returnTypeName=orderTypeName)
+  ReventlessCore.Plugin_Helpers.stateSchemaRegistry->Dict.set(
+    productsName,
+    productRowSchema
+    ->S.Metadata.set(
+      ~id=Reventless.StateAnnotations.stateAnnotationsId,
+      annotations(~retired),
+    )
+    ->S.castToUnknown,
+  )
+
+  let productsDb = ProductsDb.make(~api=(), ~apiRole=())
+  let productOps = await productsDb->ReventlessCore.Component.operations->TestRunner.resolve
+  let ordersDb = OrdersDb.make(~api=(), ~apiRole=())
+  let orderOps = await ordersDb->ReventlessCore.Component.operations->TestRunner.resolve
+
+  let _: ReventlessCore.QueryDb_Adapter.resolvers = Resolvers.make(
+    ~name=ordersName,
+    ~api=(),
+    ~apiRole=(),
+    ~dataSourceName=""->Pulumi.Output.make,
+    ~indexes=[],
+    ~subIdField=None,
+    ~idResolverConfigs=OrdersSpec.config.idResolvers,
+    ~idsResolverConfigs=OrdersSpec.config.idsResolvers,
+    ~authorization=Reventless.Authorization.AllowAuthenticated,
+    ~opts=({}: Pulumi.CustomResourceOptions.t),
+  )
+
+  let _ = await productOps.save("p-1", {productId: "p-1", name: "Book", archived: false}, Init, None)
+  let _ = await productOps.save("p-2", {productId: "p-2", name: "Pen", archived: true}, Init, None)
+  let _ = await orderOps.save(
+    "o-1",
+    {orderId: "o-1", productId: "p-1", productIds: ["p-1", "gone", "p-2"]},
+    Init,
+    None,
+  )
+
+  let resolverFor = field =>
+    switch DomainGraphQL_Server.getFieldResolver(~typeName=orderTypeName, field) {
+    | Some(r) => r
+    | None => JsError.throwWithMessage("field resolver not registered: " ++ field)
+    }
+
+  let order = JSON.Encode.object(
+    Dict.fromArray([
+      ("orderId", JSON.Encode.string("o-1")),
+      ("productId", JSON.Encode.string("p-1")),
+      (
+        "productIds",
+        ["p-1", "gone", "p-2"]->Array.map(JSON.Encode.string)->JSON.Encode.array,
+      ),
+    ]),
+  )
+
+  (resolverFor, order)
+}
+
+describe("QueryDb cross-table field resolvers", () => {
+  beforeEach(() => {
+    DomainGraphQL_Server.reset()
+  })
+
+  testPromise("@resolves follows the foreign key into the target's row", async () => {
+    let (resolverFor, order) = await buildFixture(~suffix="A", ~retired=None)
+    let product = await resolverFor("product")(order, noArgs, plainCtx)
+    expect((product->getString("name"), product->getString("id")))->toEqual((
+      Some("Book"),
+      Some("p-1"),
+    ))
+  })
+
+  testPromise("@resolvesMany batch-follows the id array", async () => {
+    let (resolverFor, order) = await buildFixture(~suffix="B", ~retired=None)
+    let products = await resolverFor("products")(order, noArgs, plainCtx)
+    // "gone" names no row and drops out rather than becoming a null, matching
+    // BatchGetItem and the by-ids door built on it.
+    expect(products->names)->toEqual(["Book", "Pen"])
+  })
+
+  testPromise("a foreign key naming no row resolves to nothing", async () => {
+    let (resolverFor, _) = await buildFixture(~suffix="C", ~retired=None)
+    let orphan = JSON.Encode.object(
+      Dict.fromArray([("productId", JSON.Encode.string("nope"))]),
+    )
+    let product = await resolverFor("product")(orphan, noArgs, plainCtx)
+    expect(product)->toBe(JSON.Encode.null)
+  })
+
+  // The narrowing is the target's: Products declares the retirement, Orders
+  // declares the field, and the caller reading through Orders is answered by
+  // the Products rule.
+  testPromise("a retired target row is withheld from both forms", async () => {
+    let retired: Reventless.StateAnnotations.retiredSpec = {
+      field: "archived",
+      label: "",
+      showWhenFalse: false,
+      values: None,
+      namedWhenRetired: false,
+    }
+    let (resolverFor, order) = await buildFixture(~suffix="D", ~retired=Some(retired))
+    let products = await resolverFor("products")(order, noArgs, plainCtx)
+    expect(products->names)->toEqual(["Book"])
+
+    let archivedOnly = JSON.Encode.object(
+      Dict.fromArray([("productId", JSON.Encode.string("p-2"))]),
+    )
+    let product = await resolverFor("product")(archivedOnly, noArgs, plainCtx)
+    expect(product)->toBe(JSON.Encode.null)
+  })
+})

package/tests/adapter/QueryDbResolvedFieldsTest.res.mjs

@@ -0,0 +1,291 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+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 Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../src/test/TestRunner.res.mjs";
+import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
+import * as QueryDb_Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Adapter.res.mjs";
+import * as QueryDb_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Builder.res.mjs";
+import * as LocalQueryDbStorage$ReventlessLocal from "../../src/adapter/QueryDb/LocalQueryDbStorage.res.mjs";
+import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
+import * as QueryDbResolvers_GraphQL$ReventlessLocal from "../../src/adapter/QueryDb/QueryDbResolvers_GraphQL.res.mjs";
+
+TestRunner$ReventlessLocal.setup();
+
+let productRowSchema = Sury.$schema(s => ({
+  productId: s.m(Sury.string),
+  name: s.m(Sury.string),
+  archived: s.m(Sury.bool)
+}));
+
+let orderRowSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
+  productId: s.m(Sury.string),
+  productIds: s.m(Sury.array(Sury.string))
+}));
+
+function annotations(retired) {
+  return {
+    ids: [],
+    compositeIds: [],
+    subIds: [],
+    compositeSubIds: [],
+    indexes: [],
+    hidden: [],
+    summary: [],
+    drillTargets: [],
+    drillTargetKeys: [],
+    collapsed: [],
+    scan: [],
+    scanSort: [],
+    semantic: [],
+    metric: [],
+    lifecycle: undefined,
+    groupBy: undefined,
+    visibility: undefined,
+    live: undefined,
+    retired: retired
+  };
+}
+
+function ctxFor(groups) {
+  let newrecord = {...Identity$Reventless.anonymous};
+  return Object.fromEntries([
+    [
+      "request",
+      Object.fromEntries([[
+          "headers",
+          {}
+        ]])
+    ],
+    [
+      "identity",
+      (newrecord.groups = groups, newrecord.username = "test-user", newrecord.userId = "test-user", newrecord)
+    ]
+  ]);
+}
+
+let plainCtx = ctxFor(["User"]);
+
+let noArgs = {};
+
+function getString(json, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.string);
+}
+
+function names(json) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(json), []), item => getString(item, "name"));
+}
+
+async function buildFixture(suffix, retired) {
+  let Bus = LocalBus$ReventlessLocal.Make({});
+  let Storage = LocalQueryDbStorage$ReventlessLocal.Make(Bus);
+  let Resolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
+  let productsName = "Products" + suffix;
+  let ordersName = "Orders" + suffix;
+  let orderTypeName = "Shop_Order" + suffix;
+  let moduleUrl = import.meta.url;
+  let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+  let moduleUrl$1 = import.meta.url;
+  let config$1 = ReadModel$Reventless.config([{
+      source: {
+        idField: "productId",
+        subId: "NoSubId",
+        resolvedField: {
+          TAG: "Single",
+          _0: "product"
+        }
+      },
+      target: {
+        tableName: productsName,
+        idField: "Id"
+      }
+    }], [{
+      source: {
+        idsField: "productIds",
+        resolvedField: "products"
+      },
+      target: {
+        tableName: productsName
+      }
+    }], undefined);
+  let NoResolvers = QueryDb_Adapter$ReventlessCore.NoResolvers({
+    make: Storage.make
+  });
+  let ProductsDb = QueryDb_Builder$ReventlessCore.Make({
+    Id: {
+      schema: Id$Reventless.StringPure.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: Id$Reventless.StringPure.cmp
+    },
+    name: productsName,
+    moduleUrl: moduleUrl,
+    stateSchema: productRowSchema,
+    config: config,
+    subIdConfig: undefined,
+    authorization: "AllowAuthenticated",
+    visibility: "Public"
+  })({
+    make: Storage.make
+  })(NoResolvers);
+  let OrdersDb = QueryDb_Builder$ReventlessCore.Make({
+    Id: {
+      schema: Id$Reventless.StringPure.schema,
+      make: prim => prim,
+      makeFromString: prim => prim,
+      toString: prim => prim,
+      cmp: Id$Reventless.StringPure.cmp
+    },
+    name: ordersName,
+    moduleUrl: moduleUrl$1,
+    stateSchema: orderRowSchema,
+    config: config$1,
+    subIdConfig: undefined,
+    authorization: "AllowAuthenticated",
+    visibility: "Public"
+  })({
+    make: Storage.make
+  })(NoResolvers);
+  let register = (viewName, returnTypeName) => {
+    Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[viewName] = {
+      singleFieldName: returnTypeName,
+      listFieldName: returnTypeName + "s",
+      returnTypeName: returnTypeName,
+      pluralTypeName: returnTypeName + "s",
+      includeIdParam: true,
+      connectionSpec: true
+    };
+  };
+  register(productsName, "Shop_Product" + suffix);
+  register(ordersName, orderTypeName);
+  Plugin_Helpers$ReventlessCore.stateSchemaRegistry[productsName] = Sury.$Metadata_set(productRowSchema, StateAnnotations$Reventless.stateAnnotationsId, annotations(retired));
+  let productsDb = ProductsDb.make(undefined, undefined, undefined, undefined, undefined);
+  let productOps = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(productsDb));
+  let ordersDb = OrdersDb.make(undefined, undefined, undefined, undefined, undefined);
+  let orderOps = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(ordersDb));
+  Resolvers.make(ordersName, undefined, undefined, Pulumi.output(""), [], undefined, config$1.idResolvers, config$1.idsResolvers, "AllowAuthenticated", {});
+  await productOps.save("p-1", {
+    productId: "p-1",
+    name: "Book",
+    archived: false
+  }, "Init", undefined);
+  await productOps.save("p-2", {
+    productId: "p-2",
+    name: "Pen",
+    archived: true
+  }, "Init", undefined);
+  await orderOps.save("o-1", {
+    orderId: "o-1",
+    productId: "p-1",
+    productIds: [
+      "p-1",
+      "gone",
+      "p-2"
+    ]
+  }, "Init", undefined);
+  let resolverFor = field => {
+    let r = DomainGraphQL_Server$ReventlessLocal.getFieldResolver(orderTypeName, field);
+    if (r !== undefined) {
+      return r;
+    } else {
+      return Stdlib_JsError.throwWithMessage("field resolver not registered: " + field);
+    }
+  };
+  let order = Object.fromEntries([
+    [
+      "orderId",
+      "o-1"
+    ],
+    [
+      "productId",
+      "p-1"
+    ],
+    [
+      "productIds",
+      [
+        "p-1",
+        "gone",
+        "p-2"
+      ].map(prim => prim)
+    ]
+  ]);
+  return [
+    resolverFor,
+    order
+  ];
+}
+
+globalThis.describe("QueryDb cross-table field resolvers", () => {
+  globalThis.beforeEach(() => DomainGraphQL_Server$ReventlessLocal.reset());
+  globalThis.test("@resolves follows the foreign key into the target's row", async () => {
+    let match = await buildFixture("A", undefined);
+    let product = await match[0]("product")(match[1], noArgs, plainCtx);
+    globalThis.expect([
+      getString(product, "name"),
+      getString(product, "id")
+    ]).toEqual([
+      "Book",
+      "p-1"
+    ]);
+  });
+  globalThis.test("@resolvesMany batch-follows the id array", async () => {
+    let match = await buildFixture("B", undefined);
+    let products = await match[0]("products")(match[1], noArgs, plainCtx);
+    globalThis.expect(names(products)).toEqual([
+      "Book",
+      "Pen"
+    ]);
+  });
+  globalThis.test("a foreign key naming no row resolves to nothing", async () => {
+    let match = await buildFixture("C", undefined);
+    let orphan = Object.fromEntries([[
+        "productId",
+        "nope"
+      ]]);
+    let product = await match[0]("product")(orphan, noArgs, plainCtx);
+    globalThis.expect(product).toBe(null);
+  });
+  globalThis.test("a retired target row is withheld from both forms", async () => {
+    let match = await buildFixture("D", {
+      field: "archived",
+      label: "",
+      showWhenFalse: false,
+      values: undefined,
+      namedWhenRetired: false
+    });
+    let resolverFor = match[0];
+    let products = await resolverFor("products")(match[1], noArgs, plainCtx);
+    globalThis.expect(names(products)).toEqual(["Book"]);
+    let archivedOnly = Object.fromEntries([[
+        "productId",
+        "p-2"
+      ]]);
+    let product = await resolverFor("product")(archivedOnly, noArgs, plainCtx);
+    globalThis.expect(product).toBe(null);
+  });
+});
+
+export {
+  productRowSchema,
+  orderRowSchema,
+  annotations,
+  ctxFor,
+  plainCtx,
+  noArgs,
+  getString,
+  names,
+  buildFixture,
+}
+/*  Not a pure module */