@pothos/plugin-prisma 4.1.0 → 4.2.0

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
+  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) {

package/src/util/map-query.ts

@@ -1,25 +1,23 @@
-/* eslint-disable no-param-reassign */
-/* eslint-disable no-continue */
+import { PothosValidationError, getMappedArgumentValues } from '@pothos/core';
 import {
-  FieldNode,
-  FragmentDefinitionNode,
-  getDirectiveValues,
-  getNamedType,
-  GraphQLField,
+  type FieldNode,
+  type FragmentDefinitionNode,
+  type GraphQLField,
   GraphQLIncludeDirective,
-  GraphQLInterfaceType,
-  GraphQLNamedType,
-  GraphQLObjectType,
-  GraphQLResolveInfo,
+  type GraphQLInterfaceType,
+  type GraphQLNamedType,
+  type GraphQLObjectType,
+  type GraphQLResolveInfo,
   GraphQLSkipDirective,
-  InlineFragmentNode,
+  type InlineFragmentNode,
+  Kind,
+  type SelectionSetNode,
+  getDirectiveValues,
+  getNamedType,
   isInterfaceType,
   isObjectType,
-  Kind,
-  SelectionSetNode,
 } from 'graphql';
-import { getMappedArgumentValues, PothosValidationError } from '@pothos/core';
-import {
+import type {
   FieldSelection,
   IncludeMap,
   IndirectInclude,
@@ -27,12 +25,12 @@ import {
   SelectionMap,
 } from '../types';
 import { setLoaderMappings } from './loader-map';
-import { FieldMap } from './relation-map';
+import type { FieldMap } from './relation-map';
 import {
+  type SelectionState,
   createState,
   mergeSelection,
   selectionCompatible,
-  SelectionState,
   selectionToQuery,
 } from './selections';
 import { wrapWithUsageCheck } from './usage';
@@ -355,7 +353,6 @@ function addFieldSelection(
 
         addTypeSelectionsForField(returnType, context, info, fieldState, selection, []);
 
-        // eslint-disable-next-line prefer-destructuring
         mappings = fieldState.mappings;
 
         return selectionToQuery(fieldState);

package/src/util/relation-map.ts

@@ -1,5 +1,5 @@
 import { createContextCache } from '@pothos/core';
-import { DMMF, RuntimeDataModel } from './get-client';
+import type { DMMF, RuntimeDataModel } from './get-client';
 
 export interface FieldMap {
   model: string;
@@ -16,33 +16,33 @@ export function createRelationMap({ models }: DMMF['datamodel'] | RuntimeDataMod
   const relationMap: RelationMap = new Map();
 
   if (Array.isArray(models)) {
-    models.forEach((model) => {
+    for (const model of models) {
       relationMap.set(model.name, { model: model.name, relations: new Map() });
-    });
+    }
 
-    models.forEach((model) => {
+    for (const model of models) {
       const map = relationMap.get(model.name)!.relations;
 
-      model.fields.forEach((field) => {
+      for (const field of model.fields) {
         if (field.kind === 'object' && relationMap.has(field.type)) {
           map.set(field.name, relationMap.get(field.type)!);
         }
-      });
-    });
+      }
+    }
   } else {
-    Object.keys(models).forEach((name) => {
+    for (const name of Object.keys(models)) {
       relationMap.set(name, { model: name, relations: new Map() });
-    });
+    }
 
-    Object.entries(models).forEach(([name, model]) => {
+    for (const [name, model] of Object.entries(models)) {
       const map = relationMap.get(name)!.relations;
 
-      model.fields.forEach((field) => {
+      for (const field of model.fields) {
         if (field.kind === 'object' && relationMap.has(field.type)) {
           map.set(field.name, relationMap.get(field.type)!);
         }
-      });
-    });
+      }
+    }
   }
 
   return relationMap;

package/src/util/selections.ts

@@ -1,8 +1,6 @@
-/* eslint-disable no-param-reassign */
-/* eslint-disable no-underscore-dangle */
-import { LoaderMappings, SelectionMap } from '../types';
+import type { LoaderMappings, SelectionMap } from '../types';
 import { deepEqual } from './deep-equal';
-import { FieldMap } from './relation-map';
+import type { FieldMap } from './relation-map';
 
 export type SelectionMode = 'include' | 'select';
 
@@ -114,15 +112,15 @@ export function mergeSelection(state: SelectionState, { select, include, ...quer
   }
 
   if (include) {
-    Object.keys(include).forEach((key) => {
+    for (const key of Object.keys(include)) {
       merge(key, include[key]);
-    });
+    }
   }
 
   if (select) {
-    Object.keys(select).forEach((key) => {
+    for (const key of Object.keys(select)) {
       merge(key, select[key]);
-    });
+    }
   }
 
   if (Object.keys(query).length > 0) {
@@ -136,9 +134,9 @@ export function mergeSelection(state: SelectionState, { select, include, ...quer
 
     if (key === '_count') {
       const counts = (value as { select?: Record<string, boolean> }).select ?? {};
-      Object.keys(counts).forEach((count) => {
+      for (const count of Object.keys(counts)) {
         state.counts.set(count, counts[count]);
-      });
+      }
 
       return;
     }
@@ -184,10 +182,10 @@ export function selectionToQuery(state: SelectionState): SelectionMap {
   }
 
   if (state.mode === 'select') {
-    state.fields.forEach((field) => {
+    for (const field of state.fields) {
       hasSelection = true;
       nestedIncludes[field] = true;
-    });
+    }
 
     return {
       ...(state.query as SelectionMap),

package/src/util/usage.ts

@@ -20,7 +20,6 @@ export function wrapWithUsageCheck<T extends Object>(obj: T): T {
     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];
@@ -47,7 +46,6 @@ export function extendWithUsage<T extends object, U extends object>(
 
   for (const key of [usageSymbol, ...Object.keys(original)]) {
     if (key in result) {
-      // eslint-disable-next-line no-continue
       continue;
     }