@pothos/plugin-prisma 4.0.5 → 4.2.0

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,
@@ -137,10 +140,6 @@ export class PrismaObjectFieldBuilder<
                     >
                   >
                 >
-              | ObjectRef<
-                  Types,
-                  ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, false>>
-                >
               | PothosSchemaTypes.ConnectionObjectOptions<
                   Types,
                   ObjectRef<
@@ -289,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;
@@ -411,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),
                 })
@@ -458,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) } });
 
@@ -531,7 +530,7 @@ 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'>;
   }
@@ -559,8 +558,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 {}),
@@ -684,7 +686,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,

package/src/types.ts

@@ -1,33 +1,35 @@
-import { FieldNode, GraphQLResolveInfo } from 'graphql';
 import {
-  ArgumentRef,
-  FieldKind,
-  FieldMap,
-  FieldNullability,
-  FieldOptionsFromKind,
-  InferredFieldOptionsByKind,
-  InferredFieldOptionKeys,
-  InputFieldMap,
-  InputFieldsFromShape,
-  InputShapeFromFields,
-  InterfaceParam,
-  ListResolveValue,
-  MaybePromise,
-  Normalize,
-  ObjectRef,
-  OutputShape,
-  OutputType,
-  SchemaTypes,
-  ShapeFromTypeParam,
-  ShapeWithNullability,
+  type ArgumentRef,
+  type FieldKind,
+  type FieldMap,
+  type FieldNullability,
+  type FieldOptionsFromKind,
+  type InferredFieldOptionKeys,
+  type InferredFieldOptionsByKind,
+  type InputFieldMap,
+  type InputFieldsFromShape,
+  type InputShapeFromFields,
+  type InterfaceParam,
+  type ListResolveValue,
+  type MaybePromise,
+  type Normalize,
+  type ObjectRef,
+  type OutputShape,
+  type OutputType,
+  type SchemaTypes,
+  type ShapeFromTypeParam,
+  type ShapeWithNullability,
+  type TypeParam,
   typeBrandKey,
-  TypeParam,
 } from '@pothos/core';
-import { PrismaInterfaceRef, PrismaRef } from './interface-ref';
+import type { FieldNode, GraphQLResolveInfo } from 'graphql';
+import type { PrismaInterfaceRef, PrismaRef } from './interface-ref';
 import type { PrismaObjectFieldBuilder } from './prisma-field-builder';
 
 export interface PrismaDelegate {
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   findUniqueOrThrow?: (...args: any[]) => Promise<unknown>;
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   findUnique: (...args: any[]) => Promise<unknown>;
 }
 
@@ -84,6 +86,7 @@ export type PrismaObjectFieldOptions<
         ShapeFromSelection<
           Types,
           ExtractModel<Types, ParentShape>,
+          // biome-ignore lint/suspicious/noExplicitAny: <explanation>
           { select: Select extends (...args: any[]) => infer S ? S : Select }
         >,
 > = PothosSchemaTypes.ObjectFieldOptions<Types, Shape, Type, Nullable, Args, ResolveReturnShape> &
@@ -499,10 +502,11 @@ export type RelationCountOptions<
 export type PrismaFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
-  Type extends
+  Type 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>],
   Model extends PrismaModelTypes,
   Param extends TypeParam<Types>,
@@ -511,34 +515,26 @@ export type PrismaFieldOptions<
   ResolveShape,
   ResolveReturnShape,
   Kind extends FieldKind = FieldKind,
-> =
-  FieldOptionsFromKind<
-    Types,
-    ParentShape,
-    Param,
-    Nullable,
-    Args,
-    Kind,
-    ResolveShape,
-    ResolveReturnShape
-  > extends infer FieldOptions
-    ? Omit<FieldOptions, InferredFieldOptionKeys | 'type'> & {
-        type: Type;
-        resolve: FieldOptions extends {
-          resolve?: (parent: infer Parent, ...args: any[]) => unknown;
-        }
-          ? PrismaFieldResolver<Types, Model, Parent, Param, Args, Nullable, ResolveReturnShape>
-          : PrismaFieldResolver<
-              Types,
-              Model,
-              ParentShape,
-              Param,
-              Args,
-              Nullable,
-              ResolveReturnShape
-            >;
+> = FieldOptionsFromKind<
+  Types,
+  ParentShape,
+  Param,
+  Nullable,
+  Args,
+  Kind,
+  ResolveShape,
+  ResolveReturnShape
+> extends infer FieldOptions
+  ? Omit<FieldOptions, InferredFieldOptionKeys | 'type'> & {
+      type: Type;
+      resolve: FieldOptions extends {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        resolve?: (parent: infer Parent, ...args: any[]) => unknown;
       }
-    : never;
+        ? PrismaFieldResolver<Types, Model, Parent, Param, Args, Nullable, ResolveReturnShape>
+        : PrismaFieldResolver<Types, Model, ParentShape, Param, Args, Nullable, ResolveReturnShape>;
+    }
+  : never;
 
 export type PrismaFieldWithInputOptions<
   Types extends SchemaTypes,
@@ -546,10 +542,11 @@ export type PrismaFieldWithInputOptions<
   Kind extends FieldKind,
   Args extends InputFieldMap,
   Fields extends InputFieldMap,
-  Type extends
+  Type 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>],
   Model extends PrismaModelTypes,
   Param extends TypeParam<Types>,
@@ -617,8 +614,9 @@ export type PrismaFieldResolver<
 export type PrismaConnectionFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
-  Type extends
-    | PrismaInterfaceRef<Types, PrismaModelTypes>
+  Type extends // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    | PrismaInterfaceRef<any, PrismaModelTypes>
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     | PrismaRef<any, PrismaModelTypes>
     | keyof Types['PrismaTypes'],
   Model extends PrismaModelTypes,
@@ -627,7 +625,6 @@ export type PrismaConnectionFieldOptions<
   Args extends InputFieldMap,
   ResolveReturnShape,
   Kind extends FieldKind,
-  // eslint-disable-next-line @typescript-eslint/sort-type-constituents
 > = Omit<
   FieldOptionsFromKind<
     Types,
@@ -693,7 +690,6 @@ export type RelatedConnectionOptions<
   Field extends Model['ListRelations'],
   Nullable extends boolean,
   Args extends InputFieldMap,
-  // eslint-disable-next-line @typescript-eslint/sort-type-constituents
 > = Omit<
   PothosSchemaTypes.ObjectFieldOptions<
     Types,
@@ -758,7 +754,7 @@ export type IncludeMap = Record<string, SelectionMap | boolean>;
 export interface SelectionMap {
   select?: Record<string, SelectionMap | boolean>;
   include?: Record<string, SelectionMap | boolean>;
-  where?: {};
+  where?: object;
 }
 
 export type FieldSelection =
@@ -849,7 +845,8 @@ type InferModelShape<Model> = Simplify<
 // Infer relations for a given model
 type InferRelations<Model> = {
   [K in keyof Model]: {
-    Shape: Model[K] extends Array<any> ? InferModelShape<Model[K][0]>[] : InferModelShape<Model[K]>;
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    Shape: Model[K] extends any[] ? InferModelShape<Model[K][0]>[] : InferModelShape<Model[K]>;
     Name: InferField<InferItemOfArray<Model[K]>, 'name'>;
     Nullable: IsNullable<Model[K]>;
   };
@@ -857,7 +854,8 @@ type InferRelations<Model> = {
 
 // Create a list of keys that represent array relations
 type InferRelationList<Model> = {
-  [K in keyof Model as Model[K] extends Array<any> ? K : never]: K;
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  [K in keyof Model as Model[K] extends any[] ? K : never]: K;
 };
 
 // Make a type nullable if IsNullable is true
@@ -868,7 +866,8 @@ type InferItemOfArray<T> = T extends Array<infer U> ? U : T;
 
 // Infers the composites of a given model
 type InferComposites<Model> = {
-  [K in keyof Model]: Model[K] extends Array<any>
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  [K in keyof Model]: Model[K] extends any[]
     ? Simplify<
         InferField<Model[K][0], 'scalars'> & InferComposites<InferField<Model[K][0], 'composites'>>
       >[]

package/src/util/cursors.ts

@@ -1,13 +1,12 @@
-/* eslint-disable no-nested-ternary */
 import {
+  type MaybePromise,
+  PothosValidationError,
+  type SchemaTypes,
   decodeBase64,
   encodeBase64,
-  MaybePromise,
-  PothosValidationError,
-  SchemaTypes,
 } from '@pothos/core';
 import { getModel } from './datamodel';
-import { DMMFField } from './get-client';
+import type { DMMFField } from './get-client';
 import { extendWithUsage } from './usage';
 
 const DEFAULT_MAX_SIZE = 100;
@@ -303,7 +302,7 @@ export function wrapConnectionResult<T extends {}>(
     },
   };
 
-  const edges = nodes.map((value, index) =>
+  const edges = nodes.map((value) =>
     value == null
       ? null
       : resolveNode
@@ -331,8 +330,8 @@ export async function resolvePrismaCursorConnection<T extends {}>(
   options: ResolvePrismaCursorConnectionOptions,
   cursor: (node: T) => string,
   resolve: (query: {
-    include?: {};
-    cursor?: {};
+    include?: object;
+    cursor?: object;
     take: number;
     skip: number;
   }) => MaybePromise<readonly T[]>,

package/src/util/datamodel.ts

@@ -1,7 +1,7 @@
-import { ObjectRef, PothosSchemaError, SchemaTypes } from '@pothos/core';
-import { PrismaInterfaceRef, PrismaRef } from '../interface-ref';
+import { type ObjectRef, PothosSchemaError, type SchemaTypes } from '@pothos/core';
+import { PrismaInterfaceRef, type PrismaRef } from '../interface-ref';
 import { PrismaObjectRef } from '../object-ref';
-import { PrismaClient, PrismaDelegate, PrismaModelTypes } from '../types';
+import type { PrismaClient, PrismaDelegate, PrismaModelTypes } from '../types';
 import { getDMMF } from './get-client';
 
 export const refMap = new WeakMap<object, Map<string, PrismaRef<never, PrismaModelTypes>>>();

package/src/util/deep-equal.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-continue */
 export function deepEqual(left: unknown, right: unknown, ignore?: Set<string>) {
   if (left === right) {
     return true;

package/src/util/description.ts

@@ -1,5 +1,4 @@
-/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
-import { SchemaTypes } from '@pothos/core';
+import type { SchemaTypes } from '@pothos/core';
 import { getFieldData, getModel } from './datamodel';
 
 export function getFieldDescription<Types extends SchemaTypes>(

package/src/util/get-client.ts

@@ -1,6 +1,5 @@
-/* eslint-disable no-underscore-dangle */
-import { createContextCache, SchemaTypes } from '@pothos/core';
-import { PrismaClient } from '../types';
+import { type SchemaTypes, createContextCache } from '@pothos/core';
+import type { PrismaClient } from '../types';
 
 export interface DMMFField {
   type: string;

package/src/util/loader-map.ts

@@ -1,8 +1,8 @@
-import { GraphQLResolveInfo } from 'graphql';
 import { createContextCache } from '@pothos/core';
-import { LoaderMappings } from '../types';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { LoaderMappings } from '../types';
 
-const cache = createContextCache((ctx) => new Map<string, LoaderMappings>());
+const cache = createContextCache(() => new Map<string, LoaderMappings>());
 
 export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath: string[] = []) {
   let key = '';
@@ -23,15 +23,13 @@ export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath
 }
 
 export function setLoaderMappings(ctx: object, info: GraphQLResolveInfo, value: LoaderMappings) {
-  Object.keys(value).forEach((field) => {
-    const map = cache(ctx);
-
-    const mapping = value[field];
+  const map = cache(ctx);
+  for (const [field, mapping] of Object.entries(value)) {
     const subPath = [...mapping.indirectPath, field];
     const key = cacheKey(mapping.type, info.path, subPath);
 
     map.set(key, mapping.mappings);
-  });
+  }
 }
 
 export function getLoaderMapping(ctx: object, path: GraphQLResolveInfo['path'], type: string) {