@pothos/plugin-prisma 3.51.1 → 3.53.0

package/src/prisma-field-builder.ts

@@ -3,6 +3,7 @@
 import { FieldNode, GraphQLResolveInfo } from 'graphql';
 import {
   CompatibleTypes,
+  ExposeNullability,
   FieldKind,
   FieldRef,
   InputFieldMap,
@@ -261,7 +262,7 @@ export class PrismaObjectFieldBuilder<
           }
           return typeName;
         },
-        path: [{ name: 'edges' }, { name: 'node' }],
+        paths: [[{ name: 'nodes' }], [{ name: 'edges' }, { name: 'node' }]],
       }) as SelectionMap;
 
       const hasTotalCount = totalCount && !!getSelection(['totalCount']);
@@ -525,7 +526,7 @@ export class PrismaObjectFieldBuilder<
     Type extends TypeParam<Types>,
     Nullable extends boolean,
     ResolveReturnShape,
-    Name extends CompatibleTypes<Types, Model['Shape'], Type, Nullable>,
+    Name extends CompatibleTypes<Types, Model['Shape'], Type, true>,
   >(
     ...args: NormalizeArgs<
       [
@@ -539,8 +540,11 @@ export class PrismaObjectFieldBuilder<
             {},
             ResolveReturnShape
           >,
-          'resolve' | 'select'
-        >,
+          'resolve' | 'select' | 'description' | 'nullable'
+        > &
+          ExposeNullability<Types, Type, Model['Shape'], Name, Nullable> & {
+            description?: string | false;
+          },
       ]
     >
   ) {
@@ -549,13 +553,19 @@ export class PrismaObjectFieldBuilder<
     const typeConfig = this.builder.configStore.getTypeConfig(this.typename, 'Object');
     const usingSelect = !!typeConfig.extensions?.pothosPrismaSelect;
 
-    return this.exposeField(name as never, {
+    return this.exposeField<Type, Nullable, never>(name as never, {
       ...options,
+      description: getFieldDescription(
+        this.model,
+        this.builder,
+        name as string,
+        options.description,
+      ) as never,
       extensions: {
         ...options.extensions,
         pothosPrismaVariant: name,
         pothosPrismaSelect: usingSelect && {
-          [name]: true,
+          [name as string]: true,
         },
       },
     });
@@ -565,7 +575,7 @@ export class PrismaObjectFieldBuilder<
     return <
       Nullable extends boolean,
       ResolveReturnShape,
-      Name extends CompatibleTypes<Types, Model['Shape'], Type, Nullable>,
+      Name extends CompatibleTypes<Types, Model['Shape'], Type, true>,
     >(
       ...args: NormalizeArgs<
         [
@@ -579,23 +589,23 @@ export class PrismaObjectFieldBuilder<
               {},
               ResolveReturnShape
             >,
-            'resolve' | 'type' | 'select' | 'description'
-          > & { description?: string | false },
+            'resolve' | 'type' | 'select' | 'description' | 'nullable'
+          > &
+            ExposeNullability<Types, Type, Model['Shape'], Name, Nullable> & {
+              description?: string | false;
+            },
         ]
       >
     ): FieldRef<ShapeFromTypeParam<Types, Type, Nullable>, 'PrismaObject'> => {
       const [name, { description, ...options } = {} as never] = args;
 
-      return this.expose(name as never, {
-        ...options,
-        description: getFieldDescription(
-          this.model,
-          this.builder,
-          name as string,
-          description,
-        ) as never,
-        type,
-      });
+      return this.expose<Type, Nullable, ResolveReturnShape, never>(
+        name as never,
+        {
+          ...options,
+          type,
+        } as never,
+      );
     };
   }
 }

package/src/types.ts

@@ -747,7 +747,8 @@ export type LoaderMappings = Record<
 
 export interface IndirectInclude {
   getType: () => string;
-  path: { type?: string; name: string }[];
+  path?: { type?: string; name: string }[];
+  paths?: { type?: string; name: string }[][];
 }
 
 export type ShapeFromConnection<T> = T extends { shape: unknown } ? T['shape'] : never;

package/src/util/map-query.ts

@@ -56,12 +56,16 @@ function addTypeSelectionsForField(
     pothosPrismaIndirectInclude?: IndirectInclude;
   };
 
-  if (pothosPrismaIndirectInclude && pothosPrismaIndirectInclude.path.length > 0) {
-    resolveIndirectInclude(
+  if (
+    (pothosPrismaIndirectInclude?.path && pothosPrismaIndirectInclude.path.length > 0) ||
+    (pothosPrismaIndirectInclude?.paths && pothosPrismaIndirectInclude.paths.length === 0)
+  ) {
+    resolveIndirectIncludePaths(
       type,
       info,
       selection,
-      pothosPrismaIndirectInclude.path,
+      [],
+      pothosPrismaIndirectInclude.paths ?? [pothosPrismaIndirectInclude.path!],
       indirectPath,
       (resolvedType, field, path) => {
         addTypeSelectionsForField(resolvedType, context, info, state, field, path);
@@ -99,11 +103,29 @@ function addTypeSelectionsForField(
   }
 }
 
+function resolveIndirectIncludePaths(
+  type: GraphQLNamedType,
+  info: GraphQLResolveInfo,
+  selection: FieldNode | FragmentDefinitionNode | InlineFragmentNode,
+  pathPrefix: { type?: string; name: string }[],
+  includePaths: { type?: string; name: string }[][],
+  path: string[],
+  resolve: (type: GraphQLNamedType, field: FieldNode, path: string[]) => void,
+) {
+  for (const includePath of includePaths) {
+    if (pathPrefix.length > 0) {
+      resolveIndirectInclude(type, info, selection, [...pathPrefix, ...includePath], path, resolve);
+    } else {
+      resolveIndirectInclude(type, info, selection, includePath, path, resolve);
+    }
+  }
+}
+
 function resolveIndirectInclude(
   type: GraphQLNamedType,
   info: GraphQLResolveInfo,
   selection: FieldNode | FragmentDefinitionNode | InlineFragmentNode,
-  includePath: IndirectInclude['path'],
+  includePath: { type?: string; name: string }[],
   path: string[],
   resolve: (type: GraphQLNamedType, field: FieldNode, path: string[]) => void,
 ) {
@@ -275,15 +297,16 @@ function addFieldSelection(
           mergeSelection(fieldState, { select: {}, ...query });
         }
 
-        if (normalizedIndirectInclude && normalizedIndirectInclude.path.length > 0) {
-          resolveIndirectInclude(
+        if (
+          (normalizedIndirectInclude?.path && normalizedIndirectInclude.path.length > 0) ||
+          (normalizedIndirectInclude?.paths && normalizedIndirectInclude.paths.length > 0)
+        ) {
+          resolveIndirectIncludePaths(
             returnType,
             info,
             selection,
-            [
-              ...((returnType.extensions?.pothosPrismaIndirectInclude as { path: [] })?.path ?? []),
-              ...normalizedIndirectInclude.path,
-            ],
+            (returnType.extensions?.pothosPrismaIndirectInclude as { path: [] })?.path ?? [],
+            normalizedIndirectInclude.paths ?? [normalizedIndirectInclude.path!],
             [],
             (resolvedType, resolvedField, path) => {
               addTypeSelectionsForField(
@@ -346,12 +369,14 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   typeName,
   select,
   path = [],
+  paths = [],
 }: {
   context: object;
   info: GraphQLResolveInfo;
   typeName?: string;
   select?: T;
   path?: string[];
+  paths?: string[][];
 }): { select: T } | { include?: {} } {
   const returnType = getNamedType(info.returnType);
   const type = typeName ? info.schema.getTypeMap()[typeName] : returnType;
@@ -359,7 +384,7 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   let state: SelectionState | undefined;
   const initialSelection = select ? { select } : undefined;
 
-  if (path.length > 0) {
+  if (path.length > 0 || paths.length > 0) {
     const { pothosPrismaIndirectInclude } = (returnType.extensions ?? {}) as {
       pothosPrismaIndirectInclude?: IndirectInclude;
     };
@@ -371,11 +396,14 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
       pothosPrismaIndirectInclude?.path ?? [],
       [],
       (indirectType, indirectField, subPath) => {
-        resolveIndirectInclude(
+        resolveIndirectIncludePaths(
           indirectType,
           info,
           indirectField,
-          path.map((n) => (typeof n === 'string' ? { name: n } : n)),
+          [],
+          paths.length > 0
+            ? paths.map((p) => p.map((n) => (typeof n === 'string' ? { name: n } : n)))
+            : [path.map((n) => (typeof n === 'string' ? { name: n } : n))],
           subPath,
           (resolvedType, resolvedField, nested) => {
             state = createStateForType(
@@ -465,7 +493,7 @@ export function getIndirectType(type: GraphQLNamedType, info: GraphQLResolveInfo
   return targetType;
 }
 
-function normalizeInclude(path: string[], type: GraphQLNamedType) {
+function normalizeInclude(path: string[], type: GraphQLNamedType): IndirectInclude {
   let currentType = type;
 
   const normalized: { name: string; type: string }[] = [];