@pothos/plugin-prisma 3.35.8 → 3.37.0

package/src/connection-helpers.ts

@@ -0,0 +1,122 @@
+import { ObjectRef, SchemaTypes } from '@pothos/core';
+import { ModelLoader } from './model-loader';
+import { PrismaObjectRef } from './object-ref';
+import type { PrismaModelTypes, ShapeFromSelection } from './types';
+import {
+  getCursorFormatter,
+  getCursorParser,
+  prismaCursorConnectionQuery,
+  wrapConnectionResult,
+} from './util/cursors';
+import { getRefFromModel } from './util/datamodel';
+import { getDMMF } from './util/get-client';
+import { getRelationMap } from './util/relation-map';
+import { createState, mergeSelection, selectionToQuery } from './util/selections';
+
+export const prismaModelKey = Symbol.for('Pothos.prismaModelKey');
+
+export function prismaConnectionHelpers<
+  Types extends SchemaTypes,
+  RefOrType extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
+  Select extends Model['Select'] & {},
+  Model extends PrismaModelTypes = RefOrType extends PrismaObjectRef<infer T>
+    ? T & PrismaModelTypes
+    : Types['PrismaTypes'][RefOrType & keyof Types['PrismaTypes']] & PrismaModelTypes,
+  Shape = RefOrType extends PrismaObjectRef<PrismaModelTypes, infer T> ? T : Model['Shape'],
+  EdgeShape = Model['Include'] extends Select
+    ? Shape
+    : ShapeFromSelection<Model, { select: Select }>,
+  NodeShape = EdgeShape,
+>(
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  refOrType: RefOrType,
+  options: {
+    cursor: string & keyof Model['WhereUnique'];
+    select?: (nestedSelection: <T extends {} | true>(selection?: T) => T) => Select;
+    defaultSize?:
+      | number
+      | ((args: PothosSchemaTypes.DefaultConnectionArguments, ctx: {}) => number);
+    maxSize?: number | ((args: PothosSchemaTypes.DefaultConnectionArguments, ctx: {}) => number);
+    resolveNode?: (edge: EdgeShape) => NodeShape;
+  },
+) {
+  const modelName =
+    typeof refOrType === 'string' ? refOrType : (refOrType as PrismaObjectRef<Model>).modelName;
+  const ref =
+    typeof refOrType === 'string'
+      ? getRefFromModel(modelName, builder)
+      : (refOrType as ObjectRef<unknown>);
+  const formatCursor = getCursorFormatter(modelName, builder, options.cursor);
+  const parseCursor = getCursorParser(modelName, builder, options.cursor);
+  const cursorSelection = ModelLoader.getCursorSelection(ref, modelName, options.cursor, builder);
+  const fieldMap = getRelationMap(getDMMF(builder)).get(modelName)!;
+
+  function resolve(
+    list: (EdgeShape & {})[],
+    args: PothosSchemaTypes.DefaultConnectionArguments,
+    ctx: Types['Context'],
+  ) {
+    return wrapConnectionResult(
+      list,
+      args,
+      getQueryArgs(args, ctx).take,
+      formatCursor,
+      null,
+      (options?.resolveNode as never) ?? ((edge: unknown) => edge),
+    ) as unknown as {
+      edges: (Omit<EdgeShape, 'cursor' | 'node'> & { node: NodeShape; cursor: string })[];
+      pageInfo: {
+        startCursor: string | null;
+        endCursor: string | null;
+        hasPreviousPage: boolean;
+        hasNextPage: boolean;
+      };
+    };
+  }
+
+  function getQueryArgs(args: PothosSchemaTypes.DefaultConnectionArguments, ctx: Types['Context']) {
+    return prismaCursorConnectionQuery({
+      args,
+      ctx,
+      maxSize: typeof options.maxSize === 'function' ? options.maxSize(args, ctx) : options.maxSize,
+      defaultSize:
+        typeof options.defaultSize === 'function'
+          ? options.defaultSize(args, ctx)
+          : options.defaultSize,
+      parseCursor,
+    });
+  }
+
+  function getQuery(
+    args: PothosSchemaTypes.DefaultConnectionArguments,
+    ctx: Types['Context'],
+    nestedSelection: <T extends true | {}>(selection?: T, path?: string[]) => T,
+  ) {
+    const nestedSelect: Record<string, unknown> | true = options.select
+      ? { select: options.select((sel) => nestedSelection(sel, ['edges', 'node'])) }
+      : nestedSelection(true, ['edges', 'node']);
+
+    const selectState = createState(fieldMap, 'select');
+
+    mergeSelection(selectState, { select: cursorSelection });
+
+    if (typeof nestedSelect === 'object' && nestedSelect) {
+      mergeSelection(selectState, nestedSelect);
+    }
+
+    return {
+      ...getQueryArgs(args, ctx),
+      ...selectionToQuery(selectState),
+    } as unknown as ReturnType<typeof getQueryArgs> &
+      (Model['Select'] extends Select ? {} : { select: Select });
+  }
+
+  return {
+    ref: (typeof refOrType === 'string'
+      ? getRefFromModel(refOrType, builder)
+      : refOrType) as PrismaObjectRef<Model>,
+    resolve,
+    select: options.select ?? {},
+    getQuery,
+  };
+}

package/src/field-builder.ts

@@ -123,6 +123,8 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
               context,
               info,
               select: cursorSelection as {},
+              path: ['edges', 'node'],
+              typeName,
             }),
             ctx: context,
             parseCursor,
@@ -135,30 +137,28 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
           (query) => resolve(query as never, parent, args as never, context, info) as never,
         ),
     },
-    {
-      ...connectionOptions,
-      fields: totalCount
-        ? (
-            t: PothosSchemaTypes.ObjectFieldBuilder<
-              SchemaTypes,
-              { totalCount?: () => MaybePromise<number> }
-            >,
-          ) => ({
-            totalCount: t.int({
-              nullable: false,
-              resolve: (parent, args, context) => parent.totalCount?.(),
-            }),
-            ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
-          })
-        : (connectionOptions as { fields: undefined }).fields,
-      extensions: {
-        ...(connectionOptions as Record<string, {}> | undefined)?.extensions,
-        pothosPrismaIndirectInclude: {
-          getType: () => typeName,
-          path: [{ name: 'edges' }, { name: 'node' }],
+    connectionOptions instanceof ObjectRef
+      ? connectionOptions
+      : {
+          ...connectionOptions,
+          fields: totalCount
+            ? (
+                t: PothosSchemaTypes.ObjectFieldBuilder<
+                  SchemaTypes,
+                  { totalCount?: () => MaybePromise<number> }
+                >,
+              ) => ({
+                totalCount: t.int({
+                  nullable: false,
+                  resolve: (parent, args, context) => parent.totalCount?.(),
+                }),
+                ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
+              })
+            : (connectionOptions as { fields: undefined }).fields,
+          extensions: {
+            ...(connectionOptions as Record<string, {}> | undefined)?.extensions,
+          },
         },
-      },
-    },
     edgeOptions,
   );
 

package/src/global-types.ts

@@ -2,6 +2,7 @@
 /* eslint-disable @typescript-eslint/no-empty-interface */
 import {
   FieldKind,
+  FieldMap,
   FieldNullability,
   FieldRef,
   InputFieldMap,
@@ -14,7 +15,7 @@ import {
   ShapeFromTypeParam,
   TypeParam,
 } from '@pothos/core';
-import PrismaNodeRef from './node-ref';
+import { PrismaNodeRef } from './node-ref';
 import { prismaModelKey, PrismaObjectRef } from './object-ref';
 import { PrismaObjectFieldBuilder as InternalPrismaObjectFieldBuilder } from './prisma-field-builder';
 import {
@@ -22,6 +23,7 @@ import {
   PrismaConnectionFieldOptions,
   PrismaFieldOptions,
   PrismaFieldWithInputOptions,
+  prismaModelName,
   PrismaModelTypes,
   PrismaNodeOptions,
   PrismaObjectFieldOptions,
@@ -116,6 +118,37 @@ declare global {
         >,
       ) => PrismaObjectRef<Model, ShapeFromSelection<Model, { select: Select; include: Include }>>;
 
+      prismaObjectField: <
+        Type extends PrismaObjectRef<PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
+        Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer M, {}>
+          ? M
+          : Types['PrismaTypes'][Type & keyof Types['PrismaTypes']] & PrismaModelTypes,
+        Shape extends {} = Type extends PrismaObjectRef<PrismaModelTypes, infer S>
+          ? S
+          : Model['Shape'] & {
+              [prismaModelName]?: Type;
+            },
+      >(
+        type: Type,
+        fieldName: string,
+        field: (t: PrismaObjectFieldBuilder<Types, Model, false, Shape>) => FieldRef,
+      ) => void;
+
+      prismaObjectFields: <
+        Type extends PrismaObjectRef<PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
+        Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer M, {}>
+          ? M
+          : Types['PrismaTypes'][Type & keyof Types['PrismaTypes']] & PrismaModelTypes,
+        Shape extends {} = Type extends PrismaObjectRef<PrismaModelTypes, infer S>
+          ? S
+          : Model['Shape'] & {
+              [prismaModelName]?: Type;
+            },
+      >(
+        type: Type,
+        fields: (t: PrismaObjectFieldBuilder<Types, Model, false, Shape>) => FieldMap,
+      ) => void;
+
       prismaNode: 'relay' extends PluginName
         ? <
             Name extends keyof Types['PrismaTypes'],
@@ -199,6 +232,7 @@ declare global {
             Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer T>
               ? T
               : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
+            Shape = Type extends PrismaObjectRef<PrismaModelTypes, infer S> ? S : Model['Shape'],
           >(
             options: PrismaConnectionFieldOptions<
               Types,
@@ -213,19 +247,21 @@ declare global {
             >,
             ...args: NormalizeArgs<
               [
-                connectionOptions: ConnectionObjectOptions<
-                  Types,
-                  ObjectRef<Model['Shape']>,
-                  false,
-                  false,
-                  ResolveReturnShape
-                >,
-                edgeOptions: ConnectionEdgeObjectOptions<
-                  Types,
-                  ObjectRef<Model['Shape']>,
-                  false,
-                  ResolveReturnShape
-                >,
+                connectionOptions:
+                  | ConnectionObjectOptions<
+                      Types,
+                      ObjectRef<Shape>,
+                      false,
+                      false,
+                      ResolveReturnShape
+                    >
+                  | ObjectRef<ShapeFromConnection<ConnectionShapeHelper<Types, Shape, false>>>,
+                edgeOptions:
+                  | ConnectionEdgeObjectOptions<Types, ObjectRef<Shape>, false, ResolveReturnShape>
+                  | ObjectRef<{
+                      cursor: string;
+                      node?: Shape | null | undefined;
+                    }>,
               ],
               0
             >

package/src/index.ts

@@ -13,6 +13,9 @@ import { PrismaModelTypes } from './types';
 import { getLoaderMapping, setLoaderMappings } from './util/loader-map';
 import { queryFromInfo, selectionStateFromInfo } from './util/map-query';
 
+export { prismaConnectionHelpers } from './connection-helpers';
+export { PrismaNodeRef } from './node-ref';
+export { PrismaObjectRef } from './object-ref';
 export * from './types';
 
 const pluginName = 'prisma' as const;

package/src/node-ref.ts

@@ -1,7 +1,4 @@
 import { PrismaObjectRef } from './object-ref';
 import type { PrismaModelTypes } from './types';
 
-export default class PrismaNodeRef<Model extends PrismaModelTypes, T> extends PrismaObjectRef<
-  Model,
-  T
-> {}
+export class PrismaNodeRef<Model extends PrismaModelTypes, T> extends PrismaObjectRef<Model, T> {}

package/src/object-ref.ts

@@ -6,6 +6,13 @@ export const prismaModelKey = Symbol.for('Pothos.prismaModelKey');
 export class PrismaObjectRef<Model extends PrismaModelTypes, T = {}> extends ObjectRef<T> {
   [prismaModelKey]!: Model;
   [abstractReturnShapeKey]!: WithBrand<T>;
+  modelName: string;
+
+  constructor(name: string, modelName: string) {
+    super(name);
+
+    this.modelName = modelName;
+  }
 
   addBrand<V extends T | T[]>(
     value: V,

package/src/prisma-field-builder.ts

@@ -111,19 +111,28 @@ export class PrismaObjectFieldBuilder<
         options: RelatedConnectionOptions<Types, Model, Field, Nullable, Args, NeedsResolve>,
         ...args: NormalizeArgs<
           [
-            connectionOptions: PothosSchemaTypes.ConnectionObjectOptions<
-              Types,
-              ObjectRef<Shape>,
-              false,
-              false,
-              ResolveReturnShape
-            >,
-            edgeOptions: PothosSchemaTypes.ConnectionEdgeObjectOptions<
-              Types,
-              ObjectRef<Shape>,
-              false,
-              ResolveReturnShape
-            >,
+            connectionOptions:
+              | PothosSchemaTypes.ConnectionObjectOptions<
+                  Types,
+                  ObjectRef<Shape>,
+                  false,
+                  false,
+                  ResolveReturnShape
+                >
+              | ObjectRef<
+                  ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, false>>
+                >,
+            edgeOptions:
+              | PothosSchemaTypes.ConnectionEdgeObjectOptions<
+                  Types,
+                  ObjectRef<Shape>,
+                  false,
+                  ResolveReturnShape
+                >
+              | ObjectRef<{
+                  cursor: string;
+                  node?: ShapeFromTypeParam<Types, Model['Shape'], false>;
+                }>,
           ],
           0
         >
@@ -272,18 +281,22 @@ export class PrismaObjectFieldBuilder<
           );
         },
       },
-      {
-        ...connectionOptions,
-        fields: totalCount
-          ? (t: PothosSchemaTypes.ObjectFieldBuilder<SchemaTypes, { totalCount?: number }>) => ({
-              totalCount: t.int({
-                nullable: false,
-                resolve: (parent, args, context) => parent.totalCount,
-              }),
-              ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
-            })
-          : (connectionOptions as { fields: undefined }).fields,
-      },
+      connectionOptions instanceof ObjectRef
+        ? connectionOptions
+        : {
+            ...connectionOptions,
+            fields: totalCount
+              ? (
+                  t: PothosSchemaTypes.ObjectFieldBuilder<SchemaTypes, { totalCount?: number }>,
+                ) => ({
+                  totalCount: t.int({
+                    nullable: false,
+                    resolve: (parent, args, context) => parent.totalCount,
+                  }),
+                  ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
+                })
+              : (connectionOptions as { fields: undefined }).fields,
+          },
       edgeOptions,
     );
 

package/src/schema-builder.ts

@@ -9,7 +9,8 @@ import SchemaBuilder, {
 } from '@pothos/core';
 import { PrismaObjectFieldBuilder } from './field-builder';
 import { ModelLoader } from './model-loader';
-import PrismaNodeRef from './node-ref';
+import { PrismaNodeRef } from './node-ref';
+import { PrismaObjectRef } from './object-ref';
 import { PrismaModelTypes, PrismaNodeOptions } from './types';
 import { getDefaultIDParser, getDefaultIDSerializer } from './util/cursors';
 import { getDelegateFromModel, getRefFromModel } from './util/datamodel';
@@ -24,7 +25,9 @@ schemaBuilderProto.prismaObject = function prismaObject(
   type,
   { fields, findUnique, select, include, description, ...options },
 ) {
-  const ref = options.variant ? this.objectRef(options.variant) : getRefFromModel(type, this);
+  const ref = options.variant
+    ? new PrismaObjectRef(options.variant, type)
+    : getRefFromModel(type, this);
   const name = options.variant ?? options.name ?? type;
   const fieldMap = getRelationMap(getDMMF(this)).get(type)!;
   const idSelection = ModelLoader.getDefaultIDSelection(ref, type, this);
@@ -77,7 +80,7 @@ schemaBuilderProto.prismaNode = function prismaNode(
   const resolve = rawResolve ?? getDefaultIDSerializer(type, fieldName, this);
   const idParser = fieldName ? getDefaultIDParser(type, fieldName, this) : undefined;
   const typeName = variant ?? name ?? type;
-  const nodeRef = new PrismaNodeRef(typeName);
+  const nodeRef = new PrismaNodeRef(typeName, type);
   const findUnique = rawFindUnique
     ? (parent: unknown, context: {}) =>
         rawFindUnique(resolve(parent as never, context) as string, context)
@@ -156,3 +159,35 @@ schemaBuilderProto.prismaNode = function prismaNode(
 
   return nodeRef;
 } as never;
+
+schemaBuilderProto.prismaObjectField = function prismaObjectField(type, fieldName, field) {
+  const ref = typeof type === 'string' ? getRefFromModel(type, this) : type;
+  this.configStore.onTypeConfig(ref, ({ name }) => {
+    this.configStore.addFields(ref, () => ({
+      [fieldName]: field(
+        new PrismaObjectFieldBuilder(
+          name,
+          this,
+          ref.modelName,
+          getRelationMap(getDMMF(this)).get(ref.modelName)!,
+        ),
+      ),
+    }));
+  });
+};
+
+schemaBuilderProto.prismaObjectFields = function prismaObjectFields(type, fields) {
+  const ref = typeof type === 'string' ? getRefFromModel(type, this) : type;
+  this.configStore.onTypeConfig(ref, ({ name }) => {
+    this.configStore.addFields(ref, () =>
+      fields(
+        new PrismaObjectFieldBuilder(
+          name,
+          this,
+          ref.modelName,
+          getRelationMap(getDMMF(this)).get(ref.modelName)!,
+        ),
+      ),
+    );
+  });
+};

package/src/types.ts

@@ -151,29 +151,15 @@ type RelationShapeFromInclude<Model extends PrismaModelTypes, Include> = Normali
     : unknown;
 }>;
 
-export type PrismaObjectTypeOptions<
+export type PrismaObjectRefOptions<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
-  Interfaces extends InterfaceParam<Types>[],
   FindUnique,
   Include,
   Select,
   Shape extends object,
 > = NameOrVariant &
-  Omit<
-    | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
-    | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
-    'fields' | 'description'
-  > & {
-    description?: string | false;
-    fields?: PrismaObjectFieldsShape<
-      Types,
-      Model,
-      FindUnique extends null ? true : false,
-      Shape & (FindUnique extends null ? {} : { [prismaModelName]?: Model['Name'] }),
-      Select
-    >;
-  } & (
+  (
     | {
         include?: Include & Model['Include'];
         select?: never;
@@ -187,6 +173,39 @@ export type PrismaObjectTypeOptions<
       }
   );
 
+export type PrismaObjectImplementationOptions<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  Interfaces extends InterfaceParam<Types>[],
+  FindUnique,
+  Select,
+  Shape extends object,
+> = Omit<
+  | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
+  | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
+  'fields' | 'description'
+> & {
+  description?: string | false;
+  fields?: PrismaObjectFieldsShape<
+    Types,
+    Model,
+    FindUnique extends null ? true : false,
+    Shape & (FindUnique extends null ? {} : { [prismaModelName]?: Model['Name'] }),
+    Select
+  >;
+};
+
+export type PrismaObjectTypeOptions<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  Interfaces extends InterfaceParam<Types>[],
+  FindUnique,
+  Include,
+  Select,
+  Shape extends object,
+> = PrismaObjectRefOptions<Types, Model, FindUnique, Include, Select, Shape> &
+  PrismaObjectImplementationOptions<Types, Model, Interfaces, FindUnique, Select, Shape>;
+
 type NameOrVariant =
   | {
       name?: never;

package/src/util/cursors.ts

@@ -261,7 +261,8 @@ export function wrapConnectionResult<T extends {}>(
   args: PothosSchemaTypes.DefaultConnectionArguments,
   take: number,
   cursor: (node: T) => string,
-  totalCount?: number | (() => MaybePromise<number>),
+  totalCount?: null | number | (() => MaybePromise<number>),
+  resolveNode?: (node: unknown) => unknown,
 ) {
   const gotFullResults = results.length === Math.abs(take);
   const hasNextPage = args.before ? true : gotFullResults;
@@ -273,6 +274,12 @@ export function wrapConnectionResult<T extends {}>(
   const edges = nodes.map((value, index) =>
     value == null
       ? null
+      : resolveNode
+      ? {
+          ...value,
+          cursor: cursor(value),
+          node: resolveNode(value),
+        }
       : {
           cursor: cursor(value),
           node: value,

package/src/util/datamodel.ts

@@ -24,7 +24,7 @@ export function getRefFromModel<Types extends SchemaTypes>(
   const cache = refMap.get(builder)!;
 
   if (!cache.has(name)) {
-    cache.set(name, new PrismaObjectRef(name));
+    cache.set(name, new PrismaObjectRef(name, name));
   }
 
   return cache.get(name)!;

package/src/util/map-query.ts

@@ -96,6 +96,11 @@ function resolveIndirectInclude(
   path: string[],
   resolve: (type: GraphQLNamedType, field: FieldNode, path: string[]) => void,
 ) {
+  if (includePath.length === 0) {
+    resolve(type, selection as FieldNode, path);
+    return;
+  }
+
   const [include, ...rest] = includePath;
   if (!selection.selectionSet || !include) {
     return;
@@ -107,18 +112,14 @@ function resolveIndirectInclude(
         if (sel.name.value === include.name && isObjectType(type)) {
           const returnType = getNamedType(type.getFields()[sel.name.value].type);
 
-          if (rest.length === 0) {
-            resolve(returnType, sel, [...path, sel.alias?.value ?? sel.name.value]);
-          } else {
-            resolveIndirectInclude(
-              returnType,
-              info,
-              sel,
-              rest,
-              [...path, sel.alias?.value ?? sel.name.value],
-              resolve,
-            );
-          }
+          resolveIndirectInclude(
+            returnType,
+            info,
+            sel,
+            rest,
+            [...path, sel.alias?.value ?? sel.name.value],
+            resolve,
+          );
         }
         continue;
       case Kind.FRAGMENT_SPREAD:
@@ -334,7 +335,8 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   select?: T;
   path?: string[];
 }): { select: T } | { include?: {} } {
-  const type = typeName ? info.schema.getTypeMap()[typeName] : getNamedType(info.returnType);
+  const returnType = getNamedType(info.returnType);
+  const type = typeName ? info.schema.getTypeMap()[typeName] : returnType;
   const state = createStateForType(type, info);
 
   if (select) {
@@ -342,14 +344,27 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   }
 
   if (path.length > 0) {
+    const { pothosPrismaIndirectInclude } = (returnType.extensions ?? {}) as {
+      pothosPrismaIndirectInclude?: IndirectInclude;
+    };
+
     resolveIndirectInclude(
-      getNamedType(info.returnType),
+      returnType,
       info,
       info.fieldNodes[0],
-      path.map((n) => (typeof n === 'string' ? { name: n } : n)),
+      pothosPrismaIndirectInclude?.path ?? [],
       [],
-      (resolvedType, resolvedField, nested) => {
-        addTypeSelectionsForField(resolvedType, context, info, state, resolvedField, nested);
+      (indirectType, indirectField, subPath) => {
+        resolveIndirectInclude(
+          indirectType,
+          info,
+          indirectField,
+          path.map((n) => (typeof n === 'string' ? { name: n } : n)),
+          subPath,
+          (resolvedType, resolvedField, nested) => {
+            addTypeSelectionsForField(resolvedType, context, info, state, resolvedField, nested);
+          },
+        );
       },
     );
   } else {