@pothos/plugin-prisma 3.29.0 → 3.31.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pothos/plugin-prisma",
-  "version": "3.29.0",
+  "version": "3.31.1",
   "description": "A Pothos plugin for more efficient integration with prisma",
   "main": "./lib/index.js",
   "types": "./dts/index.d.ts",
@@ -36,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@prisma/generator-helper": "^4.2.1"
+    "@prisma/generator-helper": "^4.3.1"
   },
   "prisma": {
     "seed": "node prisma/seed.mjs"
@@ -48,16 +48,16 @@
     "typescript": ">=4.7.2"
   },
   "devDependencies": {
-    "@pothos/core": "3.19.0",
-    "@pothos/plugin-complexity": "3.8.0",
+    "@pothos/core": "3.19.1",
+    "@pothos/plugin-complexity": "3.9.1",
     "@pothos/plugin-errors": "3.6.0",
     "@pothos/plugin-relay": "3.24.0",
     "@pothos/plugin-simple-objects": "3.4.0",
     "@pothos/test-utils": "1.3.0",
-    "@prisma/client": "^4.2.1",
+    "@prisma/client": "^4.3.1",
     "graphql": "16.6.0",
     "graphql-tag": "^2.12.6",
-    "prisma": "^4.2.1"
+    "prisma": "^4.3.1"
   },
   "scripts": {
     "generate": "prisma generate",

package/src/generator.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-magic-numbers */
 /* eslint-disable no-nested-ternary */
 import { mkdir, writeFile } from 'fs';
-import { dirname } from 'path';
+import { dirname, resolve as resolvePath } from 'path';
 import ts, { ListFormat, ScriptKind, ScriptTarget, SyntaxKind, version } from 'typescript';
 import { generatorHandler } from '@prisma/generator-helper';
 
@@ -24,11 +24,13 @@ function checkTSVersion() {
   }
 }
 
+const defaultOutput = resolvePath(__dirname, '../generated.ts');
+
 generatorHandler({
   onManifest: () => ({
     prettyName: 'Pothos integration',
-    defaultOutput: 'node_modules/@pothos/plugin-prisma/generated.ts',
     requiresGenerators: ['prisma-client-js'],
+    defaultOutput,
   }),
   onGenerate: async (options) => {
     checkTSVersion();

package/src/global-types.ts

@@ -39,6 +39,7 @@ declare global {
     export interface SchemaBuilderOptions<Types extends SchemaTypes> {
       prisma:
         | {
+            filterConnectionTotalCount?: boolean;
             client: PrismaClient;
             exposeDescriptions?:
               | boolean
@@ -48,6 +49,7 @@ declare global {
                 };
           }
         | {
+            filterConnectionTotalCount?: boolean;
             client: (ctx: Types['Context']) => PrismaClient;
             dmmf: { datamodel: unknown };
             exposeDescriptions?:

package/src/model-loader.ts

@@ -11,7 +11,7 @@ import {
 export class ModelLoader {
   model: object;
   builder: PothosSchemaTypes.SchemaBuilder<never>;
-  findUnique: (args: unknown, ctx: {}) => unknown;
+  findUnique: (model: Record<string, unknown>, ctx: {}) => unknown;
   modelName: string;
 
   staged = new Set<{
@@ -23,7 +23,7 @@ export class ModelLoader {
     model: object,
     builder: PothosSchemaTypes.SchemaBuilder<never>,
     modelName: string,
-    findUnique: (args: unknown, ctx: {}) => unknown,
+    findUnique: (model: Record<string, unknown>, ctx: {}) => unknown,
   ) {
     this.model = model;
     this.builder = builder;
@@ -34,7 +34,7 @@ export class ModelLoader {
   static forRef<Types extends SchemaTypes>(
     ref: ObjectRef<unknown>,
     modelName: string,
-    findUnique: (args: unknown, ctx: {}) => unknown,
+    findUnique: ((model: Record<string, unknown>, ctx: {}) => unknown) | undefined,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ) {
     return createContextCache(
@@ -238,14 +238,14 @@ export class ModelLoader {
         if (delegate.findUniqueOrThrow) {
           return delegate.findUniqueOrThrow({
             ...selectionToQuery(state),
-            where: { ...(this.findUnique(this.model, context) as {}) },
+            where: { ...(this.findUnique(this.model as Record<string, unknown>, context) as {}) },
           } as never) as Promise<Record<string, unknown>>;
         }
 
         return delegate.findUnique({
           rejectOnNotFound: true,
           ...selectionToQuery(state),
-          where: { ...(this.findUnique(this.model, context) as {}) },
+          where: { ...(this.findUnique(this.model as Record<string, unknown>, context) as {}) },
         } as never) as Promise<Record<string, unknown>>;
       }),
       state,

package/src/prisma-field-builder.ts

@@ -1,5 +1,6 @@
+/* eslint-disable no-nested-ternary */
 /* eslint-disable no-underscore-dangle */
-import { GraphQLResolveInfo } from 'graphql';
+import { FieldNode, GraphQLResolveInfo } from 'graphql';
 import {
   CompatibleTypes,
   FieldKind,
@@ -172,6 +173,7 @@ export class PrismaObjectFieldBuilder<
         args,
       }),
     });
+
     const cursorSelection = ModelLoader.getCursorSelection(
       ref,
       relationField.type,
@@ -182,7 +184,8 @@ export class PrismaObjectFieldBuilder<
     const relationSelect = (
       args: object,
       context: object,
-      nestedQuery: (query: unknown, path: unknown) => unknown,
+      nestedQuery: (query: unknown, path?: unknown) => { select?: {} },
+      getSelection: (path: string[]) => FieldNode | null,
     ) => {
       const nested = nestedQuery(getQuery(args, context), {
         getType: () => {
@@ -194,8 +197,16 @@ export class PrismaObjectFieldBuilder<
         path: [{ name: 'edges' }, { name: 'node' }],
       }) as SelectionMap;
 
+      const hasTotalCount = totalCount && !!getSelection(['totalCount']);
+      const countSelect = this.builder.options.prisma.filterConnectionTotalCount
+        ? nested.where
+          ? { where: nested.where }
+          : true
+        : true;
+
       return {
         select: {
+          ...(hasTotalCount ? { _count: { select: { [name]: countSelect } } } : {}),
           [name]: nested?.select
             ? {
                 ...nested,
@@ -266,9 +277,6 @@ export class PrismaObjectFieldBuilder<
           ? (t: PothosSchemaTypes.ObjectFieldBuilder<SchemaTypes, { totalCount?: number }>) => ({
               totalCount: t.int({
                 nullable: false,
-                extensions: {
-                  pothosPrismaParentSelect: { _count: { select: { [name]: true } } },
-                },
                 resolve: (parent, args, context) => parent.totalCount,
               }),
               ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
@@ -352,18 +360,35 @@ export class PrismaObjectFieldBuilder<
 
   relationCount<Field extends Model['RelationName']>(
     ...allArgs: NormalizeArgs<
-      [name: Field, options?: RelationCountOptions<Types, Shape, NeedsResolve>]
+      [
+        name: Field,
+        options?: RelationCountOptions<
+          Types,
+          Shape,
+          NeedsResolve,
+          Model['Relations'][Field]['Types']['Where']
+        >,
+      ]
     >
   ): FieldRef<number, 'Object'> {
-    const [name, options = {} as never] = allArgs;
+    const [name, { where, ...options } = {} as never] = allArgs;
 
     const { resolve, ...rest } = options;
 
-    const countSelect = {
-      _count: {
-        select: { [name]: true },
-      },
-    };
+    const countSelect =
+      typeof where === 'function'
+        ? (args: {}, context: {}) => ({
+            _count: {
+              select: {
+                [name]: { where: (where as (args: unknown, ctx: unknown) => {})(args, context) },
+              },
+            },
+          })
+        : {
+            _count: {
+              select: { [name]: where ? { where } : true },
+            },
+          };
 
     return this.field({
       ...(rest as {}),

package/src/types.ts

@@ -1,4 +1,4 @@
-import { GraphQLResolveInfo } from 'graphql';
+import { FieldNode, GraphQLResolveInfo } from 'graphql';
 import {
   FieldKind,
   FieldMap,
@@ -385,12 +385,14 @@ export type RelationCountOptions<
   Types extends SchemaTypes,
   Shape,
   NeedsResolve extends boolean,
+  Where,
 > = Omit<
   PothosSchemaTypes.ObjectFieldOptions<Types, Shape, 'Int', false, {}, number>,
   'resolve' | 'type'
 > &
   (NeedsResolve extends false
     ? {
+        where?: Where | ((args: {}, context: Types['Context']) => Where);
         resolve?: (
           parent: Shape,
           args: {},
@@ -399,6 +401,7 @@ export type RelationCountOptions<
         ) => MaybePromise<number>;
       }
     : {
+        where?: Where | ((args: {}, context: Types['Context']) => Where);
         resolve: (
           parent: Shape,
           args: {},
@@ -620,6 +623,7 @@ export type FieldSelection =
         selection: SelectionMap | boolean | ((args: object, context: object) => SelectionMap),
         path?: string[] | IndirectInclude,
       ) => SelectionMap | boolean,
+      resolveSelection: (path: string[]) => FieldNode | null,
     ) => SelectionMap);
 
 export type LoaderMappings = Record<

package/src/util/map-query.ts

@@ -222,9 +222,6 @@ function addFieldSelection(
 
   let fieldSelectionMap: SelectionMap;
 
-  const fieldParentSelect = field.extensions?.pothosPrismaParentSelect as
-    | Record<string, SelectionMap | boolean>
-    | undefined;
   let mappings: LoaderMappings = {};
 
   if (typeof fieldSelect === 'function') {
@@ -233,52 +230,82 @@ function addFieldSelection(
       unknown
     >;
 
-    fieldSelectionMap = fieldSelect(args, context, (rawQuery, indirectInclude) => {
-      const returnType = getNamedType(field.type);
-      const query = typeof rawQuery === 'function' ? rawQuery(args, context) : rawQuery;
+    fieldSelectionMap = fieldSelect(
+      args,
+      context,
+      (rawQuery, indirectInclude) => {
+        const returnType = getNamedType(field.type);
+        const query = typeof rawQuery === 'function' ? rawQuery(args, context) : rawQuery;
+
+        const normalizedIndirectInclude = Array.isArray(indirectInclude)
+          ? normalizeInclude(indirectInclude, getIndirectType(returnType, info))
+          : indirectInclude;
+
+        const fieldState = createStateForType(
+          getIndirectType(
+            normalizedIndirectInclude
+              ? info.schema.getType(normalizedIndirectInclude.getType())!
+              : returnType,
+            info,
+          ),
+          info,
+          state,
+        );
 
-      const normalizedIndirectInclude = Array.isArray(indirectInclude)
-        ? normalizeInclude(indirectInclude, getIndirectType(returnType, info))
-        : indirectInclude;
+        if (typeof query === 'object' && Object.keys(query).length > 0) {
+          mergeSelection(fieldState, { select: {}, ...query });
+        }
 
-      const fieldState = createStateForType(
-        getIndirectType(
-          normalizedIndirectInclude
-            ? info.schema.getType(normalizedIndirectInclude.getType())!
-            : returnType,
-          info,
-        ),
-        info,
-        state,
-      );
+        if (normalizedIndirectInclude && normalizedIndirectInclude.path.length > 0) {
+          resolveIndirectInclude(
+            returnType,
+            info,
+            selection,
+            [
+              ...((returnType.extensions?.pothosPrismaIndirectInclude as { path: [] })?.path ?? []),
+              ...normalizedIndirectInclude.path,
+            ],
+            [],
+            (resolvedType, resolvedField, path) => {
+              addTypeSelectionsForField(
+                resolvedType,
+                context,
+                info,
+                fieldState,
+                resolvedField,
+                path,
+              );
+            },
+          );
+        }
+
+        addTypeSelectionsForField(returnType, context, info, fieldState, selection, []);
+
+        // eslint-disable-next-line prefer-destructuring
+        mappings = fieldState.mappings;
 
-      if (typeof query === 'object' && Object.keys(query).length > 0) {
-        mergeSelection(fieldState, { select: {}, ...query });
-      }
+        return selectionToQuery(fieldState);
+      },
+      (path) => {
+        const returnType = getNamedType(field.type);
+        let node: FieldNode | null = null;
 
-      if (normalizedIndirectInclude && normalizedIndirectInclude.path.length > 0) {
         resolveIndirectInclude(
           returnType,
           info,
           selection,
-          [
-            ...((returnType.extensions?.pothosPrismaIndirectInclude as { path: [] })?.path ?? []),
-            ...normalizedIndirectInclude.path,
-          ],
+          path.map((name) => ({
+            name,
+          })),
           [],
-          (resolvedType, resolvedField, path) => {
-            addTypeSelectionsForField(resolvedType, context, info, fieldState, resolvedField, path);
+          (_, resolvedField) => {
+            node = resolvedField;
           },
         );
-      }
-
-      addTypeSelectionsForField(returnType, context, info, fieldState, selection, []);
-
-      // eslint-disable-next-line prefer-destructuring
-      mappings = fieldState.mappings;
 
-      return selectionToQuery(fieldState);
-    });
+        return node;
+      },
+    );
   } else {
     fieldSelectionMap = { select: fieldSelect };
   }
@@ -291,18 +318,6 @@ function addFieldSelection(
       mappings,
       indirectPath,
     };
-  } else if (
-    fieldParentSelect &&
-    state.parent &&
-    selectionCompatible(state.parent, { select: fieldParentSelect }, true)
-  ) {
-    mergeSelection(state.parent, { select: fieldParentSelect });
-    state.mappings[selection.alias?.value ?? selection.name.value] = {
-      field: selection.name.value,
-      type: type.name,
-      mappings,
-      indirectPath,
-    };
   }
 }
 

package/src/util/selections.ts

@@ -11,7 +11,7 @@ export interface SelectionState {
   query: object;
   mode: SelectionMode;
   fields: Set<string>;
-  counts: Set<string>;
+  counts: Map<string, boolean | Record<string, unknown>>;
   relations: Map<string, SelectionState>;
   mappings: LoaderMappings;
   parent?: SelectionState;
@@ -39,6 +39,19 @@ export function selectionCompatible(
   return ignoreQuery || deepEqual(state.query, query);
 
   function compare(key: string, value: SelectionMap | boolean) {
+    if (key === '_count') {
+      const selections = value && (value as { select?: Record<string, unknown> }).select;
+      const keys = selections && Object.keys(selections);
+
+      if (!keys || keys.length === 0) {
+        return false;
+      }
+
+      return keys.some(
+        (k) => state.counts.has(k) && !deepEqual(state.counts.get(k), selections[k]),
+      );
+    }
+
     return (
       value &&
       state.fieldMap.relations.has(key) &&
@@ -89,7 +102,7 @@ export function createState(
     fieldMap,
     query: {},
     fields: new Set(),
-    counts: new Set(),
+    counts: new Map(),
     relations: new Map(),
     mappings: {},
   };
@@ -122,9 +135,9 @@ export function mergeSelection(state: SelectionState, { select, include, ...quer
     }
 
     if (key === '_count') {
-      const counts = (value as { select?: {} }).select ?? {};
+      const counts = (value as { select?: Record<string, boolean> }).select ?? {};
       Object.keys(counts).forEach((count) => {
-        state.counts.add(count);
+        state.counts.set(count, counts[count]);
       });
 
       return;
@@ -149,7 +162,7 @@ export function mergeSelection(state: SelectionState, { select, include, ...quer
 
 export function selectionToQuery(state: SelectionState): SelectionMap {
   const nestedIncludes: Record<string, SelectionMap | boolean> = {};
-  const counts: Record<string, boolean> = {};
+  const counts: Record<string, unknown> = {};
 
   let hasSelection = false;
 
@@ -161,12 +174,12 @@ export function selectionToQuery(state: SelectionState): SelectionMap {
 
   if (state.counts.size > 0) {
     hasSelection = true;
-    for (const count of state.counts) {
-      counts[count] = true;
+    for (const [count, selection] of state.counts) {
+      counts[count] = selection;
     }
 
     nestedIncludes._count = {
-      select: counts,
+      select: counts as {},
     };
   }