@pothos/plugin-prisma 4.0.5 → 4.2.0

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';
@@ -49,36 +47,32 @@ function addTypeSelectionsForField(
     return;
   }
 
-  const {
-    pothosPrismaInclude,
-    pothosPrismaSelect,
-    pothosPrismaIndirectInclude,
-    pothosPrismaModel,
-  } = (type.extensions ?? {}) as {
-    pothosPrismaModel?: string;
-    pothosPrismaInclude?: IncludeMap;
-    pothosPrismaSelect?: IncludeMap;
-    pothosPrismaIndirectInclude?: IndirectInclude;
-  };
+  const { pothosPrismaInclude, pothosPrismaSelect, pothosIndirectInclude, pothosPrismaModel } =
+    (type.extensions ?? {}) as {
+      pothosPrismaModel?: string;
+      pothosPrismaInclude?: IncludeMap;
+      pothosPrismaSelect?: IncludeMap;
+      pothosIndirectInclude?: IndirectInclude;
+    };
 
   if (
-    (!!pothosPrismaIndirectInclude?.path && pothosPrismaIndirectInclude.path.length > 0) ||
-    (!!pothosPrismaIndirectInclude?.paths && pothosPrismaIndirectInclude.paths.length === 0)
+    (!!pothosIndirectInclude?.path && pothosIndirectInclude.path.length > 0) ||
+    (!!pothosIndirectInclude?.paths && pothosIndirectInclude.paths.length === 0)
   ) {
     resolveIndirectIncludePaths(
       type,
       info,
       selection,
       [],
-      pothosPrismaIndirectInclude.paths ?? [pothosPrismaIndirectInclude.path!],
+      pothosIndirectInclude.paths ?? [pothosIndirectInclude.path!],
       indirectPath,
       (resolvedType, field, path) => {
         addTypeSelectionsForField(resolvedType, context, info, state, field, path);
       },
     );
-  } else if (pothosPrismaIndirectInclude) {
+  } else if (pothosIndirectInclude) {
     addTypeSelectionsForField(
-      info.schema.getType(pothosPrismaIndirectInclude.getType())!,
+      info.schema.getType(pothosIndirectInclude.getType())!,
       context,
       info,
       state,
@@ -335,7 +329,7 @@ function addFieldSelection(
             returnType,
             info,
             selection,
-            (returnType.extensions?.pothosPrismaIndirectInclude as { path: [] })?.path ?? [],
+            (returnType.extensions?.pothosIndirectInclude as { path: [] })?.path ?? [],
             normalizedIndirectInclude?.paths ??
               (normalizedIndirectInclude?.path ? [normalizedIndirectInclude.path] : []),
             [],
@@ -359,7 +353,6 @@ function addFieldSelection(
 
         addTypeSelectionsForField(returnType, context, info, fieldState, selection, []);
 
-        // eslint-disable-next-line prefer-destructuring
         mappings = fieldState.mappings;
 
         return selectionToQuery(fieldState);
@@ -403,11 +396,15 @@ function addFieldSelection(
   }
 }
 
-export function queryFromInfo<T extends SelectionMap['select'] | undefined = undefined>({
+export function queryFromInfo<
+  Select extends SelectionMap['select'] | undefined = undefined,
+  Include extends SelectionMap['select'] | undefined = undefined,
+>({
   context,
   info,
   typeName,
   select,
+  include,
   path = [],
   paths = [],
   withUsageCheck = false,
@@ -415,27 +412,33 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   context: object;
   info: GraphQLResolveInfo;
   typeName?: string;
-  select?: T;
   path?: string[];
   paths?: string[][];
   withUsageCheck?: boolean;
-}): { include?: {} } | { select: T } {
+} & (
+  | { include?: Include; select?: never }
+  | { select?: Select; include?: never }
+)): undefined extends Include
+  ? {
+      select: Select;
+    }
+  : { include: Include } {
   const returnType = getNamedType(info.returnType);
   const type = typeName ? info.schema.getTypeMap()[typeName] : returnType;
 
   let state: SelectionState | undefined;
-  const initialSelection = select ? { select } : undefined;
+  const initialSelection = select ? { select } : include ? { include } : undefined;
 
   if (path.length > 0 || paths.length > 0) {
-    const { pothosPrismaIndirectInclude } = (returnType.extensions ?? {}) as {
-      pothosPrismaIndirectInclude?: IndirectInclude;
+    const { pothosIndirectInclude } = (returnType.extensions ?? {}) as {
+      pothosIndirectInclude?: IndirectInclude;
     };
 
     resolveIndirectInclude(
       returnType,
       info,
       info.fieldNodes[0],
-      pothosPrismaIndirectInclude?.path ?? [],
+      pothosIndirectInclude?.path ?? [],
       [],
       (indirectType, indirectField, subPath) => {
         resolveIndirectIncludePaths(
@@ -479,7 +482,7 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
 
   setLoaderMappings(context, info, state.mappings);
 
-  const query = selectionToQuery(state) as { select: T };
+  const query = selectionToQuery(state) as { select: Select; include: Include };
 
   return withUsageCheck ? wrapWithUsageCheck(query) : query;
 }
@@ -530,9 +533,9 @@ function createStateForType(
 export function getIndirectType(type: GraphQLNamedType, info: GraphQLResolveInfo) {
   let targetType = type;
 
-  while (targetType.extensions?.pothosPrismaIndirectInclude) {
+  while (targetType.extensions?.pothosIndirectInclude) {
     targetType = info.schema.getType(
-      (targetType.extensions?.pothosPrismaIndirectInclude as IndirectInclude).getType(),
+      (targetType.extensions?.pothosIndirectInclude as IndirectInclude).getType(),
     )!;
   }
 

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;
     }