support indirect paths in queryFromInfo

.changeset/smooth-rocks-bathe.md

@@ -0,0 +1,5 @@
+---
+'@pothos/plugin-prisma': minor
+---
+
+update queryFromInfo to support indirect paths

packages/plugin-prisma/src/field-builder.ts

@@ -33,10 +33,10 @@ fieldBuilderProto.prismaField = function prismaField({ type, resolve, ...options
   return this.field({
     ...(options as {}),
     type: typeParam,
-    resolve: (parent: never, args: unknown, ctx: {}, info: GraphQLResolveInfo) => {
-      const query = queryFromInfo(ctx, info);
+    resolve: (parent: never, args: unknown, context: {}, info: GraphQLResolveInfo) => {
+      const query = queryFromInfo({ context, info });
 
-      return resolve(query, parent, args as never, ctx, info) as never;
+      return resolve(query, parent, args as never, context, info) as never;
     },
   }) as never;
 };
@@ -89,21 +89,25 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
       resolve: (
         parent: unknown,
         args: PothosSchemaTypes.DefaultConnectionArguments,
-        ctx: {},
+        context: {},
         info: GraphQLResolveInfo,
       ) =>
         resolvePrismaCursorConnection(
           {
-            query: queryFromInfo(ctx, info, undefined, { select: cursorSelection as {} }),
-            ctx,
+            query: queryFromInfo({
+              context,
+              info,
+              select: cursorSelection as {},
+            }),
+            ctx: context,
             parseCursor,
             maxSize,
             defaultSize,
             args,
-            totalCount: totalCount && (() => totalCount(parent, args as never, ctx, info)),
+            totalCount: totalCount && (() => totalCount(parent, args as never, context, info)),
           },
           formatCursor,
-          (query) => resolve(query as never, parent, args as never, ctx, info),
+          (query) => resolve(query as never, parent, args as never, context, info),
         ),
     },
     {

packages/plugin-prisma/src/index.ts

@@ -99,7 +99,7 @@ export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
       }
 
       if (fallback) {
-        return fallback(queryFromInfo(context, info), parent, args, context, info);
+        return fallback(queryFromInfo({ context, info }), parent, args, context, info);
       }
 
       const selectionState = selectionStateFromInfo(context, info);

packages/plugin-prisma/src/schema-builder.ts

@@ -97,7 +97,7 @@ schemaBuilderProto.prismaNode = function prismaNode(
       context: SchemaTypes['Context'],
       info: GraphQLResolveInfo,
     ) => {
-      const query = queryFromInfo(context, info, typeName);
+      const query = queryFromInfo({ context, info, typeName });
       const delegate = getDelegateFromModel(getClient(this, context), type);
 
       const record = await (delegate.findUniqueOrThrow

packages/plugin-prisma/src/util/map-query.ts

@@ -306,20 +306,40 @@ function addFieldSelection(
   }
 }
 
-export function queryFromInfo(
-  context: object,
-  info: GraphQLResolveInfo,
-  typeName?: string,
-  initialSelection?: SelectionMap,
-): {} {
+export function queryFromInfo({
+  context,
+  info,
+  typeName,
+  select,
+  path = [],
+}: {
+  context: object;
+  info: GraphQLResolveInfo;
+  typeName?: string;
+  select?: SelectionMap['select'];
+  path?: string[];
+}): {} {
   const type = typeName ? info.schema.getTypeMap()[typeName] : getNamedType(info.returnType);
   const state = createStateForType(type, info);
 
-  if (initialSelection) {
-    mergeSelection(state, initialSelection);
+  if (select) {
+    mergeSelection(state, { select });
   }
 
-  addTypeSelectionsForField(type, context, info, state, info.fieldNodes[0], []);
+  if (path.length > 0) {
+    resolveIndirectInclude(
+      getNamedType(info.returnType),
+      info,
+      info.fieldNodes[0],
+      path.map((n) => (typeof n === 'string' ? { name: n } : n)),
+      [],
+      (resolvedType, resolvedField, nested) => {
+        addTypeSelectionsForField(resolvedType, context, info, state, resolvedField, nested);
+      },
+    );
+  } else {
+    addTypeSelectionsForField(type, context, info, state, info.fieldNodes[0], []);
+  }
 
   setLoaderMappings(context, info, state.mappings);
 

packages/plugin-prisma/tests/__snapshots__/index.test.ts.snap

@@ -5,6 +5,11 @@ exports[`prisma generates schema 1`] = `
   message: String!
 }
 
+type Blog {
+  pages: [Int!]!
+  posts: [Post!]!
+}
+
 type Comment {
   author: User!
   authorBio: String
@@ -109,6 +114,7 @@ type Profile {
 
 type Query {
   badUser: User!
+  blog: Blog!
   findUniqueRelations: FindUniqueRelations!
   findUniqueRelationsSelect: FindUniqueRelations!
   manualConnection(after: ID, before: ID, first: Int, last: Int): QueryManualConnection!

packages/plugin-prisma/tests/example/schema/index.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-underscore-dangle */
 import { resolveCursorConnection, ResolveCursorConnectionArgs } from '@pothos/plugin-relay';
+import { queryFromInfo } from '../../../src/util/map-query';
 import { Post } from '../../client';
 import builder, { prisma } from '../builder';
 
@@ -769,4 +770,27 @@ builder.queryField('manualConnection', (t) =>
   }),
 );
 
+const Blog = builder.objectRef<{ posts: Post[]; pages: number[] }>('Blog').implement({
+  fields: (t) => ({
+    posts: t.prismaField({
+      type: ['Post'],
+      resolve: (_, blog) => blog.posts,
+    }),
+    pages: t.exposeIntList('pages'),
+  }),
+});
+
+builder.queryField('blog', (t) =>
+  t.field({
+    type: Blog,
+    resolve: async (_, args, context, info) => ({
+      posts: await prisma.post.findMany({
+        ...queryFromInfo({ context, info, typeName: 'Post', path: ['posts'] }),
+        take: 3,
+      }),
+      pages: [1, 2, 3],
+    }),
+  }),
+);
+
 export default builder.toSchema({});

packages/plugin-prisma/tests/nested-query.test.ts

@@ -194,4 +194,83 @@ describe('nested query', () => {
       ]
     `);
   });
+
+  it('queryFromInfo with nested path', async () => {
+    const query = gql`
+      query {
+        blog {
+          posts {
+            id
+            author {
+              name
+            }
+          }
+          pages
+        }
+      }
+    `;
+
+    const result = await execute({
+      schema,
+      document: query,
+      contextValue: { user: { id: 1 } },
+    });
+
+    expect(result).toMatchInlineSnapshot(`
+      Object {
+        "data": Object {
+          "blog": Object {
+            "pages": Array [
+              1,
+              2,
+              3,
+            ],
+            "posts": Array [
+              Object {
+                "author": Object {
+                  "name": "Maurine Rath",
+                },
+                "id": "1",
+              },
+              Object {
+                "author": Object {
+                  "name": "Maurine Rath",
+                },
+                "id": "2",
+              },
+              Object {
+                "author": Object {
+                  "name": "Maurine Rath",
+                },
+                "id": "3",
+              },
+            ],
+          },
+        },
+      }
+    `);
+
+    expect(queries).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "action": "findMany",
+          "args": Object {
+            "include": Object {
+              "author": true,
+              "comments": Object {
+                "include": Object {
+                  "author": true,
+                },
+                "take": 3,
+              },
+            },
+            "take": 3,
+          },
+          "dataPath": Array [],
+          "model": "Post",
+          "runInTransaction": false,
+        },
+      ]
+    `);
+  });
 });