@pothos/plugin-prisma 3.52.0 → 3.54.0

package/src/field-builder.ts

@@ -3,8 +3,10 @@ import {
   FieldKind,
   FieldRef,
   InputFieldMap,
+  isThenable,
   MaybePromise,
   ObjectRef,
+  PothosError,
   RootFieldBuilder,
   SchemaTypes,
 } from '@pothos/core';
@@ -13,6 +15,7 @@ import { PrismaConnectionFieldOptions, PrismaModelTypes } from './types';
 import { getCursorFormatter, getCursorParser, resolvePrismaCursorConnection } from './util/cursors';
 import { getRefFromModel } from './util/datamodel';
 import { queryFromInfo } from './util/map-query';
+import { isUsed } from './util/usage';
 
 const fieldBuilderProto = RootFieldBuilder.prototype as PothosSchemaTypes.RootFieldBuilder<
   SchemaTypes,
@@ -32,9 +35,18 @@ fieldBuilderProto.prismaField = function prismaField({ type, resolve, ...options
     ...(options as {}),
     type: typeParam,
     resolve: (parent: never, args: unknown, context: {}, info: GraphQLResolveInfo) => {
-      const query = queryFromInfo({ context, info });
+      const query = queryFromInfo({
+        context,
+        info,
+        withUsageCheck: !!this.builder.options.prisma?.onUnusedQuery,
+      });
 
-      return resolve(query, parent, args as never, context, info) as never;
+      return checkIfQueryIsUsed(
+        this.builder,
+        query,
+        info,
+        resolve(query, parent, args as never, context, info) as never,
+      );
     },
   }) as never;
 };
@@ -57,9 +69,18 @@ fieldBuilderProto.prismaFieldWithInput = function prismaFieldWithInput({
     ...(options as {}),
     type: typeParam,
     resolve: (parent: never, args: unknown, context: {}, info: GraphQLResolveInfo) => {
-      const query = queryFromInfo({ context, info });
+      const query = queryFromInfo({
+        context,
+        info,
+        withUsageCheck: !!this.builder.options.prisma?.onUnusedQuery,
+      });
 
-      return resolve(query, parent, args as never, context, info) as never;
+      return checkIfQueryIsUsed(
+        this.builder,
+        query,
+        info,
+        resolve(query, parent, args as never, context, info) as never,
+      );
     },
   }) as never;
 };
@@ -114,17 +135,20 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
         args: PothosSchemaTypes.DefaultConnectionArguments,
         context: {},
         info: GraphQLResolveInfo,
-      ) =>
-        resolvePrismaCursorConnection(
+      ) => {
+        const query = queryFromInfo({
+          context,
+          info,
+          select: cursorSelection as {},
+          paths: [['nodes'], ['edges', 'node']],
+          typeName,
+          withUsageCheck: !!this.builder.options.prisma?.onUnusedQuery,
+        });
+
+        return resolvePrismaCursorConnection(
           {
             parent,
-            query: queryFromInfo({
-              context,
-              info,
-              select: cursorSelection as {},
-              paths: [['nodes'], ['edges', 'node']],
-              typeName,
-            }),
+            query,
             ctx: context,
             parseCursor,
             maxSize,
@@ -133,8 +157,15 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
             totalCount: totalCount && (() => totalCount(parent, args as never, context, info)),
           },
           formatCursor,
-          (query) => resolve(query as never, parent, args as never, context, info) as never,
-        ),
+          (q) =>
+            checkIfQueryIsUsed(
+              this.builder,
+              query,
+              info,
+              resolve(q as never, parent, args as never, context, info) as never,
+            ),
+        );
+      },
     },
     connectionOptions instanceof ObjectRef
       ? connectionOptions
@@ -163,3 +194,47 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
 
   return fieldRef;
 } as never;
+
+function checkIfQueryIsUsed<Types extends SchemaTypes, T>(
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  query: object,
+  info: GraphQLResolveInfo,
+  result: T,
+): T {
+  const { onUnusedQuery } = builder.options.prisma || {};
+  if (!onUnusedQuery) {
+    return result;
+  }
+
+  if (isThenable(result)) {
+    return result.then((resolved) => {
+      if (!isUsed(query)) {
+        onUnused();
+      }
+
+      return resolved;
+    }) as T;
+  }
+
+  if (!isUsed(query)) {
+    onUnused();
+  }
+
+  return result;
+
+  function onUnused() {
+    if (typeof onUnusedQuery === 'function') {
+      onUnusedQuery(info);
+      return;
+    }
+
+    const message = `Prisma query was unused in resolver for ${info.parentType.name}.${info.fieldName}`;
+
+    if (onUnusedQuery === 'error') {
+      throw new PothosError(message);
+    } else if (onUnusedQuery === 'warn') {
+      // eslint-disable-next-line no-console
+      console.warn(message);
+    }
+  }
+}

package/src/generator.ts

@@ -1,9 +1,8 @@
 /* eslint-disable unicorn/prefer-module */
-/* eslint-disable node/prefer-promises/fs */
 /* eslint-disable no-magic-numbers */
 /* eslint-disable no-nested-ternary */
-import { mkdir, writeFile } from 'fs';
-import { dirname, join, resolve as resolvePath } from 'path';
+import { mkdir, writeFile } from 'node:fs';
+import { dirname, join, resolve as resolvePath } from 'node:path';
 import ts, { ListFormat, ScriptKind, ScriptTarget, SyntaxKind, version } from 'typescript';
 import { DMMF, generatorHandler } from '@prisma/generator-helper';
 

package/src/global-types.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-interface */
-import { A } from 'vitest/dist/types-fafda418';
+import { GraphQLResolveInfo } from 'graphql';
 import {
   FieldKind,
   FieldMap,
@@ -8,7 +8,6 @@ import {
   FieldRef,
   InputFieldMap,
   InputFieldRef,
-  InputShapeFromFields,
   InterfaceParam,
   NormalizeArgs,
   OutputType,
@@ -54,6 +53,7 @@ declare global {
                   models?: boolean;
                   fields?: boolean;
                 };
+            onUnusedQuery?: null | 'warn' | 'error' | ((info: GraphQLResolveInfo) => void);
           }
         | {
             filterConnectionTotalCount?: boolean;
@@ -65,6 +65,7 @@ declare global {
                   models?: boolean;
                   fields?: boolean;
                 };
+            onUnusedQuery?: null | 'warn' | 'error' | ((info: GraphQLResolveInfo) => void);
           };
     }
 

package/src/prisma-field-builder.ts

@@ -3,6 +3,7 @@
 import { FieldNode, GraphQLResolveInfo } from 'graphql';
 import {
   CompatibleTypes,
+  ExposeNullability,
   FieldKind,
   FieldRef,
   InputFieldMap,
@@ -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/util/map-query.ts

@@ -31,6 +31,7 @@ import {
   SelectionState,
   selectionToQuery,
 } from './selections';
+import { wrapWithUsageCheck } from './usage';
 
 function addTypeSelectionsForField(
   type: GraphQLNamedType,
@@ -370,6 +371,7 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   select,
   path = [],
   paths = [],
+  withUsageCheck = false,
 }: {
   context: object;
   info: GraphQLResolveInfo;
@@ -377,6 +379,7 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   select?: T;
   path?: string[];
   paths?: string[][];
+  withUsageCheck?: boolean;
 }): { select: T } | { include?: {} } {
   const returnType = getNamedType(info.returnType);
   const type = typeName ? info.schema.getTypeMap()[typeName] : returnType;
@@ -437,7 +440,9 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
 
   setLoaderMappings(context, info, state.mappings);
 
-  return selectionToQuery(state) as { select: T };
+  const query = selectionToQuery(state) as { select: T };
+
+  return withUsageCheck ? wrapWithUsageCheck(query) : query;
 }
 
 export function selectionStateFromInfo(

package/src/util/usage.ts

@@ -0,0 +1,33 @@
+export const usageSymbol = Symbol.for('Pothos.isUsed');
+
+export function wrapWithUsageCheck<T extends Object>(obj: T): T {
+  const result = {};
+  let used = true;
+
+  Object.defineProperty(result, usageSymbol, {
+    get() {
+      return used;
+    },
+    enumerable: false,
+  });
+
+  for (const key of Object.keys(obj)) {
+    // only set to false if the object has keys
+    used = false;
+    Object.defineProperty(result, key, {
+      enumerable: true,
+      configurable: true,
+      // eslint-disable-next-line @typescript-eslint/no-loop-func
+      get() {
+        used = true;
+        return obj[key as keyof T];
+      },
+    });
+  }
+
+  return result as T;
+}
+
+export function isUsed(obj: object): boolean {
+  return !(usageSymbol in obj) || (obj as { [usageSymbol]: boolean })[usageSymbol];
+}