@pothos/plugin-prisma 4.1.0 → 4.2.1

package/src/field-builder.ts

@@ -1,17 +1,23 @@
-import { getNamedType, GraphQLResolveInfo, isInterfaceType, isObjectType, Kind } from 'graphql';
 import {
-  FieldKind,
-  FieldRef,
-  InputFieldMap,
-  isThenable,
-  MaybePromise,
+  type FieldKind,
+  type FieldRef,
+  type InputFieldMap,
+  type MaybePromise,
   ObjectRef,
   PothosError,
   RootFieldBuilder,
-  SchemaTypes,
+  type SchemaTypes,
+  isThenable,
 } from '@pothos/core';
+import {
+  type GraphQLResolveInfo,
+  Kind,
+  getNamedType,
+  isInterfaceType,
+  isObjectType,
+} from 'graphql';
 import { ModelLoader } from './model-loader';
-import { PrismaConnectionFieldOptions, PrismaModelTypes } from './types';
+import type { PrismaConnectionFieldOptions, PrismaModelTypes } from './types';
 import { getCursorFormatter, getCursorParser, resolvePrismaCursorConnection } from './util/cursors';
 import { getRefFromModel } from './util/datamodel';
 import { queryFromInfo } from './util/map-query';
@@ -177,7 +183,9 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
           },
           formatCursor,
           (q) => {
-            if (totalCountOnly) return [];
+            if (totalCountOnly) {
+              return [];
+            }
 
             return checkIfQueryIsUsed(
               this.builder,
@@ -205,13 +213,13 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
                   extensions: {
                     pothosPrismaTotalCount: true,
                   },
-                  resolve: (parent, args, context) => parent.totalCount?.(),
+                  resolve: (parent) => parent.totalCount?.(),
                 }),
                 ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
               })
             : (connectionOptions as { fields: undefined }).fields,
           extensions: {
-            ...(connectionOptions as Record<string, {}> | undefined)?.extensions,
+            ...(connectionOptions as Record<string, object> | undefined)?.extensions,
           },
         },
     edgeOptions,
@@ -257,8 +265,8 @@ function checkIfQueryIsUsed<Types extends SchemaTypes, T>(
 
     if (onUnusedQuery === 'error') {
       throw new PothosError(message);
-    } else if (onUnusedQuery === 'warn') {
-      // eslint-disable-next-line no-console
+    }
+    if (onUnusedQuery === 'warn') {
       console.warn(message);
     }
   }

package/src/generator.ts

@@ -1,11 +1,8 @@
-/* eslint-disable unicorn/prefer-module */
-/* eslint-disable no-magic-numbers */
-/* eslint-disable no-nested-ternary */
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve as resolvePath, posix } from 'node:path';
+import { dirname, join, posix, resolve as resolvePath } from 'node:path';
+import { type DMMF, generatorHandler } from '@prisma/generator-helper';
 import ts, { ListFormat, ScriptKind, ScriptTarget, SyntaxKind, version } from 'typescript';
-import { DMMF, generatorHandler } from '@prisma/generator-helper';
-import { PothosPrismaDatamodel } from './types';
+import type { PothosPrismaDatamodel } from './types';
 
 const MIN_TS_VERSION = [4, 5, 2];
 
@@ -83,7 +80,7 @@ function trimDmmf(dmmf: DMMF.Document, documentation = false): PothosPrismaDatam
     },
   };
 
-  dmmf.datamodel.models.forEach((model) => {
+  for (const model of dmmf.datamodel.models) {
     trimmed.datamodel.models[model.name] = {
       fields: model.fields.map((field) => ({
         type: field.type,
@@ -108,7 +105,7 @@ function trimDmmf(dmmf: DMMF.Document, documentation = false): PothosPrismaDatam
       })),
       documentation: documentation ? model.documentation : undefined,
     };
-  });
+  }
 
   return trimmed;
 }

package/src/global-types.ts

@@ -1,7 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-empty-interface */
-import { GraphQLResolveInfo } from 'graphql';
-import {
+import type {
   FieldKind,
   FieldMap,
   FieldNullability,
@@ -15,24 +12,25 @@ import {
   ShapeFromTypeParam,
   TypeParam,
 } from '@pothos/core';
-import { PrismaInterfaceRef, PrismaRef } from './interface-ref';
-import { PrismaNodeRef } from './node-ref';
-import { prismaModelKey, PrismaObjectRef } from './object-ref';
-import { PrismaObjectFieldBuilder as InternalPrismaObjectFieldBuilder } from './prisma-field-builder';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { PrismaInterfaceRef, PrismaRef } from './interface-ref';
+import type { PrismaNodeRef } from './node-ref';
+import type { PrismaObjectRef, prismaModelKey } from './object-ref';
+import type { PrismaObjectFieldBuilder as InternalPrismaObjectFieldBuilder } from './prisma-field-builder';
 import {
-  PrismaClient,
-  PrismaConnectionFieldOptions,
-  PrismaConnectionShape,
-  PrismaFieldOptions,
-  PrismaFieldWithInputOptions,
-  PrismaInterfaceTypeOptions,
+  type PrismaClient,
+  type PrismaConnectionFieldOptions,
+  type PrismaConnectionShape,
+  type PrismaFieldOptions,
+  type PrismaFieldWithInputOptions,
+  type PrismaInterfaceTypeOptions,
+  type PrismaModelTypes,
+  type PrismaNodeOptions,
+  type PrismaObjectFieldOptions,
+  type PrismaObjectTypeOptions,
+  type ShapeFromConnection,
+  type ShapeFromSelection,
   prismaModelName,
-  PrismaModelTypes,
-  PrismaNodeOptions,
-  PrismaObjectFieldOptions,
-  PrismaObjectTypeOptions,
-  ShapeFromConnection,
-  ShapeFromSelection,
 } from './types';
 
 import type { PothosPrismaPlugin } from '.';
@@ -254,10 +252,11 @@ declare global {
     > {
       prismaField: <
         Args extends InputFieldMap,
-        TypeParam extends
+        TypeParam extends // biome-ignore lint/suspicious/noExplicitAny: <explanation>
           | PrismaRef<any, PrismaModelTypes>
           | keyof Types['PrismaTypes']
           | [keyof Types['PrismaTypes']]
+          // biome-ignore lint/suspicious/noExplicitAny: <explanation>
           | [PrismaRef<any, PrismaModelTypes>],
         Nullable extends FieldNullability<Type>,
         ResolveShape,
@@ -268,9 +267,11 @@ declare global {
         Model extends PrismaModelTypes = PrismaModelTypes &
           (TypeParam extends [keyof Types['PrismaTypes']]
             ? Types['PrismaTypes'][TypeParam[0]]
-            : TypeParam extends [PrismaRef<any, PrismaModelTypes>]
+            : // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+              TypeParam extends [PrismaRef<any, PrismaModelTypes>]
               ? TypeParam[0][typeof prismaModelKey]
-              : TypeParam extends PrismaRef<any, PrismaModelTypes>
+              : // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                TypeParam extends PrismaRef<any, PrismaModelTypes>
                 ? TypeParam[typeof prismaModelKey]
                 : TypeParam extends keyof Types['PrismaTypes']
                   ? Types['PrismaTypes'][TypeParam]
@@ -292,14 +293,17 @@ declare global {
 
       prismaConnection: 'relay' extends PluginName
         ? <
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             Type extends PrismaRef<any, PrismaModelTypes> | keyof Types['PrismaTypes'],
             Nullable extends boolean,
             ResolveReturnShape,
             Args extends InputFieldMap = {},
-            Model extends PrismaModelTypes = Type extends PrismaRef<Types, infer T>
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            Model extends PrismaModelTypes = Type extends PrismaRef<any, infer T>
               ? T
               : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
-            Shape = Type extends PrismaRef<Types, PrismaModelTypes, infer S> ? S : Model['Shape'],
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            Shape = Type extends PrismaRef<any, PrismaModelTypes, infer S> ? S : Model['Shape'],
             ConnectionInterfaces extends InterfaceParam<Types>[] = [],
             EdgeInterfaces extends InterfaceParam<Types>[] = [],
           >(
@@ -356,10 +360,11 @@ declare global {
       prismaFieldWithInput: 'withInput' extends PluginName
         ? <
             Fields extends InputFieldMap,
-            TypeParam extends
+            TypeParam extends // biome-ignore lint/suspicious/noExplicitAny: <explanation>
               | PrismaRef<any, PrismaModelTypes>
               | keyof Types['PrismaTypes']
               | [keyof Types['PrismaTypes']]
+              // biome-ignore lint/suspicious/noExplicitAny: <explanation>
               | [PrismaRef<any, PrismaModelTypes>],
             Type extends TypeParam extends [unknown]
               ? [ObjectRef<Types, Model['Shape']>]
@@ -373,9 +378,11 @@ declare global {
             Model extends PrismaModelTypes = PrismaModelTypes &
               (TypeParam extends [keyof Types['PrismaTypes']]
                 ? Types['PrismaTypes'][TypeParam[0]]
-                : TypeParam extends [PrismaRef<any, PrismaModelTypes>]
+                : // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                  TypeParam extends [PrismaRef<any, PrismaModelTypes>]
                   ? TypeParam[0][typeof prismaModelKey]
-                  : TypeParam extends PrismaRef<any, PrismaModelTypes>
+                  : // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                    TypeParam extends PrismaRef<any, PrismaModelTypes>
                     ? TypeParam[typeof prismaModelKey]
                     : TypeParam extends keyof Types['PrismaTypes']
                       ? Types['PrismaTypes'][TypeParam]

package/src/index.ts

@@ -1,18 +1,19 @@
 import './global-types';
 import './schema-builder';
 import './field-builder';
-import { GraphQLFieldResolver, GraphQLResolveInfo } from 'graphql';
 import SchemaBuilder, {
   BasePlugin,
-  BuildCache,
-  PothosOutputFieldConfig,
+  type BuildCache,
+  type PothosOutputFieldConfig,
   PothosSchemaError,
-  PothosTypeConfig,
-  SchemaTypes,
+  type PothosTypeConfig,
+  type SchemaTypes,
 } from '@pothos/core';
-import { ModelLoader } from './model-loader';
+// biome-ignore lint/style/useImportType: <explanation>
+import { GraphQLFieldResolver, GraphQLResolveInfo } from 'graphql';
+import type { ModelLoader } from './model-loader';
 import { PrismaObjectFieldBuilder as InternalPrismaObjectFieldBuilder } from './prisma-field-builder';
-import { PrismaModelTypes } from './types';
+import type { PrismaModelTypes } from './types';
 import { formatPrismaCursor, parsePrismaCursor } from './util/cursors';
 import { getModel, getRefFromModel } from './util/datamodel';
 import { getLoaderMapping, setLoaderMappings } from './util/loader-map';
@@ -56,7 +57,7 @@ export class PothosPrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Ty
 
     let model = typeConfig.extensions?.pothosPrismaModel as string | undefined;
 
-    typeConfig.interfaces.forEach((iface) => {
+    for (const iface of typeConfig.interfaces) {
       const interfaceModel = this.buildCache.getTypeConfig(iface, 'Interface').extensions
         ?.pothosPrismaModel as string | undefined;
 
@@ -69,7 +70,7 @@ export class PothosPrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Ty
 
         model = interfaceModel;
       }
-    });
+    }
 
     return {
       ...typeConfig,
@@ -133,12 +134,12 @@ export class PothosPrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Ty
     const parentTypes = new Set([fieldConfig.parentType]);
 
     if (parentConfig.kind === 'Interface' || parentConfig.kind === 'Object') {
-      parentConfig.interfaces.forEach((iface) => {
+      for (const iface of parentConfig.interfaces) {
         const interfaceConfig = this.buildCache.getTypeConfig(iface, 'Interface');
         if (interfaceConfig.extensions?.pothosPrismaModel) {
           parentTypes.add(interfaceConfig.name);
         }
-      });
+      }
     }
 
     return (parent, args, context, info) => {

package/src/interface-ref.ts

@@ -1,5 +1,5 @@
-import { InterfaceRef, SchemaTypes } from '@pothos/core';
-import { prismaModelKey, PrismaObjectRef } from './object-ref';
+import { InterfaceRef, type SchemaTypes } from '@pothos/core';
+import { type PrismaObjectRef, prismaModelKey } from './object-ref';
 import type { PrismaModelTypes } from './types';
 
 export type PrismaRef<Types extends SchemaTypes, Model extends PrismaModelTypes, T = {}> =

package/src/model-loader.ts

@@ -1,20 +1,20 @@
-import { GraphQLResolveInfo } from 'graphql';
 import {
-  createContextCache,
-  InterfaceRef,
-  ObjectRef,
+  type InterfaceRef,
+  type ObjectRef,
   PothosSchemaError,
-  SchemaTypes,
+  type SchemaTypes,
+  createContextCache,
 } from '@pothos/core';
-import { PrismaDelegate, SelectionMap } from './types';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { PrismaDelegate, SelectionMap } from './types';
 import { getDelegateFromModel, getModel } from './util/datamodel';
 import { getClient } from './util/get-client';
 import { cacheKey, setLoaderMappings } from './util/loader-map';
 import { selectionStateFromInfo } from './util/map-query';
 import {
+  type SelectionState,
   mergeSelection,
   selectionCompatible,
-  SelectionState,
   selectionToQuery,
 } from './util/selections';
 
@@ -75,7 +75,7 @@ export class ModelLoader {
             ? () => {
                 throw new PothosSchemaError(`Missing findUnique for ${ref.name}`);
               }
-            : findUnique ?? this.getDefaultFindUnique(ref, modelName, builder),
+            : findUnique ?? ModelLoader.getDefaultFindUnique(ref, modelName, builder),
         ),
     );
   }
@@ -147,9 +147,9 @@ export class ModelLoader {
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ): (model: Record<string, unknown>) => {} {
-    const findBy = this.getDefaultFindBy(ref, modelName, builder);
+    const findBy = ModelLoader.getDefaultFindBy(ref, modelName, builder);
 
-    return this.getFindUnique(findBy);
+    return ModelLoader.getFindUnique(findBy);
   }
 
   static getDefaultIDSelection<Types extends SchemaTypes>(
@@ -157,7 +157,7 @@ export class ModelLoader {
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ): Record<string, boolean> {
-    const findBy = this.getDefaultFindBy(ref, modelName, builder);
+    const findBy = ModelLoader.getDefaultFindBy(ref, modelName, builder);
 
     if (typeof findBy === 'string') {
       return { [findBy]: true };
@@ -236,7 +236,7 @@ export class ModelLoader {
       throw new PothosSchemaError(`Unable to find field or index for ${fieldName} of ${ref.name}`);
     }
 
-    return this.getFindUnique(findBy);
+    return ModelLoader.getFindUnique(findBy);
   }
 
   getSelection(info: GraphQLResolveInfo) {
@@ -277,7 +277,7 @@ export class ModelLoader {
           entry.models.set(model, createResolvablePromise<Record<string, unknown> | null>());
         }
 
-        return entry.models.get(model)!.promise;
+        return await entry.models.get(model)!.promise;
       }
     }
 
@@ -298,31 +298,29 @@ export class ModelLoader {
     this.staged.add(entry);
 
     const nextTick = createResolvablePromise<void>();
-    void this.tick.then(() => {
+    this.tick.then(() => {
       this.staged.delete(entry);
 
       for (const [model, { resolve, reject }] of entry.models) {
         if (this.delegate.findUniqueOrThrow) {
-          void this.delegate
+          this.delegate
             .findUniqueOrThrow({
               ...selectionToQuery(state),
               where: { ...(this.findUnique(model as Record<string, unknown>, this.context) as {}) },
             } as never)
-            // eslint-disable-next-line promise/no-nesting
             .then(resolve as () => {}, reject);
         } else {
-          void this.delegate
+          this.delegate
             .findUnique({
               rejectOnNotFound: true,
               ...selectionToQuery(state),
               where: { ...(this.findUnique(model as Record<string, unknown>, this.context) as {}) },
             } as never)
-            // eslint-disable-next-line promise/no-nesting
             .then(resolve as () => {}, reject);
         }
       }
     });
-    setTimeout(() => void nextTick.resolve(), 0);
+    setTimeout(() => nextTick.resolve(), 0);
     this.tick = nextTick.promise;
 
     return promise.promise;

package/src/node-ref.ts

@@ -1,4 +1,4 @@
-import { SchemaTypes } from '@pothos/core';
+import type { SchemaTypes } from '@pothos/core';
 import { PrismaObjectRef } from './object-ref';
 import type { PrismaModelTypes } from './types';
 

package/src/object-ref.ts

@@ -1,8 +1,8 @@
 import {
+  ObjectRef,
+  type SchemaTypes,
   abstractReturnShapeKey,
   brandWithType,
-  ObjectRef,
-  SchemaTypes,
   typeBrandKey,
 } from '@pothos/core';
 import type { PrismaModelTypes, WithBrand } from './types';
@@ -30,7 +30,9 @@ export class PrismaObjectRef<
     value: V,
   ): V extends T[] ? { [K in keyof V]: WithBrand<V[K]> } : WithBrand<V> {
     if (Array.isArray(value)) {
-      value.forEach((val) => void brandWithType(val, this.name as never));
+      for (const val of value) {
+        brandWithType(val, this.name as never);
+      }
 
       return value as never;
     }

package/src/prisma-field-builder.ts

@@ -1,34 +1,32 @@
-/* eslint-disable no-nested-ternary */
-/* eslint-disable no-underscore-dangle */
 import {
-  FieldNode,
+  type CompatibleTypes,
+  type ExposeNullability,
+  type FieldKind,
+  type FieldRef,
+  type InferredFieldOptionKeys,
+  type InputFieldMap,
+  type InterfaceParam,
+  type MaybePromise,
+  type NormalizeArgs,
+  ObjectRef,
+  type PluginName,
+  RootFieldBuilder,
+  type SchemaTypes,
+  type ShapeFromTypeParam,
+  type TypeParam,
+  isThenable,
+} from '@pothos/core';
+import {
+  type FieldNode,
+  type GraphQLResolveInfo,
+  Kind,
   getNamedType,
-  GraphQLResolveInfo,
   isInterfaceType,
   isObjectType,
-  Kind,
 } from 'graphql';
-import {
-  CompatibleTypes,
-  ExposeNullability,
-  FieldKind,
-  FieldRef,
-  InferredFieldOptionKeys,
-  InputFieldMap,
-  InterfaceParam,
-  isThenable,
-  MaybePromise,
-  NormalizeArgs,
-  ObjectRef,
-  PluginName,
-  RootFieldBuilder,
-  SchemaTypes,
-  ShapeFromTypeParam,
-  TypeParam,
-} from '@pothos/core';
-import { PrismaRef } from './interface-ref';
+import type { PrismaRef } from './interface-ref';
 import { ModelLoader } from './model-loader';
-import {
+import type {
   PrismaConnectionShape,
   PrismaModelTypes,
   RelatedConnectionOptions,
@@ -47,11 +45,11 @@ import {
 } from './util/cursors';
 import { getRefFromModel, getRelation } from './util/datamodel';
 import { getFieldDescription } from './util/description';
-import { FieldMap } from './util/relation-map';
+import type { FieldMap } from './util/relation-map';
 
 // Workaround for FieldKind not being extended on Builder classes
 const RootBuilder: {
-  // eslint-disable-next-line @typescript-eslint/prefer-function-type
+  // biome-ignore lint/suspicious/noRedeclare: <explanation>
   new <Types extends SchemaTypes, Shape, Kind extends FieldKind>(
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
     kind: FieldKind,
@@ -59,21 +57,26 @@ const RootBuilder: {
   ): PothosSchemaTypes.RootFieldBuilder<Types, Shape, Kind>;
 } = RootFieldBuilder as never;
 
-type ContextForAuth<Types extends SchemaTypes, Scopes extends {} = {}> =
-  PothosSchemaTypes.ScopeAuthContextForAuth<Types, Scopes> extends {
-    Context: infer T;
-  }
-    ? T extends object
-      ? T
-      : object
-    : object;
-
-type FieldAuthScopes<Types extends SchemaTypes, Parent, Args extends {} = {}> =
-  PothosSchemaTypes.ScopeAuthFieldAuthScopes<Types, Parent, Args> extends {
-    Scopes: infer T;
-  }
+type ContextForAuth<
+  Types extends SchemaTypes,
+  Scopes extends {} = {},
+> = PothosSchemaTypes.ScopeAuthContextForAuth<Types, Scopes> extends {
+  Context: infer T;
+}
+  ? T extends object
     ? T
-    : never;
+    : object
+  : object;
+
+type FieldAuthScopes<
+  Types extends SchemaTypes,
+  Parent,
+  Args extends {} = {},
+> = PothosSchemaTypes.ScopeAuthFieldAuthScopes<Types, Parent, Args> extends {
+  Scopes: infer T;
+}
+  ? T
+  : never;
 
 export class PrismaObjectFieldBuilder<
   Types extends SchemaTypes,
@@ -285,7 +288,7 @@ export class PrismaObjectFieldBuilder<
     const relationSelect = (
       args: object,
       context: object,
-      nestedQuery: (query: unknown, path?: unknown) => { select?: {} },
+      nestedQuery: (query: unknown, path?: unknown) => { select?: object },
       getSelection: (path: string[]) => FieldNode | null,
     ) => {
       typeName ??= this.builder.configStore.getTypeConfig(ref).name;
@@ -407,7 +410,7 @@ export class PrismaObjectFieldBuilder<
                     extensions: {
                       pothosPrismaTotalCount: true,
                     },
-                    resolve: (parent, args, context) => parent.totalCount,
+                    resolve: (parent, _args, _context) => parent.totalCount,
                   }),
                   ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
                 })
@@ -454,8 +457,8 @@ export class PrismaObjectFieldBuilder<
     const { query = {}, resolve, extensions, onNull, ...rest } = options;
 
     const relationSelect = (
-      args: object,
-      context: object,
+      _args: object,
+      _context: object,
       nestedQuery: (query: unknown) => unknown,
     ) => ({ select: { [name]: nestedQuery(query) } });
 
@@ -527,13 +530,14 @@ export class PrismaObjectFieldBuilder<
       type: 'Int',
       nullable: false,
       select: countSelect as never,
-      resolve: (parent, args, context, info) =>
+      resolve: (parent, _args, _context, _info) =>
         (parent as unknown as { _count: Record<string, never> })._count?.[name],
     }) as FieldRef<Types, number, 'Object'>;
   }
 
   variant<
-    Variant extends Model['Name'] | PrismaRef<Types, Model>,
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    Variant extends Model['Name'] | PrismaRef<any, Model>,
     Args extends InputFieldMap,
     Nullable,
   >(
@@ -543,7 +547,8 @@ export class PrismaObjectFieldBuilder<
         options: VariantFieldOptions<
           Types,
           Model,
-          Variant extends PrismaRef<Types, Model> ? Variant : PrismaRef<Types, Model>,
+          // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+          Variant extends PrismaRef<any, Model> ? Variant : PrismaRef<Types, Model>,
           Args,
           Nullable,
           Shape
@@ -555,8 +560,11 @@ export class PrismaObjectFieldBuilder<
     const ref: PrismaRef<Types, PrismaModelTypes> =
       typeof variant === 'string' ? getRefFromModel(variant, this.builder) : variant;
 
-    const selfSelect = (args: object, context: object, nestedQuery: (query: unknown) => unknown) =>
-      nestedQuery({});
+    const selfSelect = (
+      _args: object,
+      _context: object,
+      nestedQuery: (query: unknown) => unknown,
+    ) => nestedQuery({});
 
     return this.field({
       ...(options as {}),
@@ -680,7 +688,6 @@ function addScopes(
 ) {
   const originalCreateField = builder.createField;
 
-  // eslint-disable-next-line no-param-reassign
   builder.createField = function createField(options) {
     return originalCreateField.call(this, {
       authScopes: scopes,

package/src/schema-builder.ts

@@ -1,20 +1,20 @@
 import './global-types';
-import { GraphQLResolveInfo } from 'graphql';
 import SchemaBuilder, {
   brandWithType,
   completeValue,
-  FieldRef,
-  InterfaceRef,
-  OutputType,
+  type FieldRef,
+  type InterfaceRef,
+  type OutputType,
   PothosError,
-  SchemaTypes,
+  type SchemaTypes,
 } from '@pothos/core';
+import type { GraphQLResolveInfo } from 'graphql';
 import { PrismaInterfaceRef } from './interface-ref';
 import { ModelLoader } from './model-loader';
 import { PrismaNodeRef } from './node-ref';
 import { PrismaObjectRef } from './object-ref';
 import { PrismaObjectFieldBuilder } from './prisma-field-builder';
-import { PrismaModelTypes, PrismaNodeOptions } from './types';
+import type { PrismaModelTypes, PrismaNodeOptions } from './types';
 import { getDefaultIDParser, getDefaultIDSerializer } from './util/cursors';
 import { getDelegateFromModel, getRefFromModel } from './util/datamodel';
 import { getModelDescription } from './util/description';
@@ -187,12 +187,12 @@ schemaBuilderProto.prismaNode = function prismaNode(
             globalID: (options: Record<string, unknown>) => FieldRef<SchemaTypes, unknown>;
           }
         ).globalID({
-          ...(this.options as { relayOptions?: { idFieldOptions?: {} } }).relayOptions
+          ...(this.options as { relayOptions?: { idFieldOptions?: object } }).relayOptions
             ?.idFieldOptions,
           ...idOptions,
           nullable: false,
           args: {},
-          resolve: (parent: never, args: object, context: object, info: GraphQLResolveInfo) =>
+          resolve: (parent: never, _args: object, context: object) =>
             completeValue(resolve(parent, context), (id) => ({
               type: nodeConfig.name,
               id,