@pothos/plugin-prisma 3.58.0 → 3.59.1

package/src/model-loader.ts

@@ -1,3 +1,4 @@
+import { GraphQLResolveInfo } from 'graphql';
 import {
   createContextCache,
   InterfaceRef,
@@ -5,8 +6,11 @@ import {
   PothosSchemaError,
   SchemaTypes,
 } from '@pothos/core';
+import { 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 {
   mergeSelection,
   selectionCompatible,
@@ -14,31 +18,49 @@ import {
   selectionToQuery,
 } from './util/selections';
 
+interface ResolvablePromise<T> {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (err: unknown) => void;
+}
 export class ModelLoader {
-  model: object;
+  context: object;
+
   builder: PothosSchemaTypes.SchemaBuilder<never>;
+
   findUnique: (model: Record<string, unknown>, ctx: {}) => unknown;
+
   modelName: string;
 
+  queryCache = new Map<string, { selection: SelectionState; query: SelectionMap }>();
+
   staged = new Set<{
-    promise: Promise<Record<string, unknown>>;
     state: SelectionState;
+    models: Map<object, ResolvablePromise<Record<string, unknown> | null>>;
   }>();
 
+  delegate: PrismaDelegate;
+
+  tick = Promise.resolve();
+
   constructor(
-    model: object,
+    context: object,
     builder: PothosSchemaTypes.SchemaBuilder<never>,
     modelName: string,
     findUnique: (model: Record<string, unknown>, ctx: {}) => unknown,
   ) {
-    this.model = model;
+    this.context = context;
     this.builder = builder;
     this.findUnique = findUnique;
     this.modelName = modelName;
+    this.delegate = getDelegateFromModel(
+      getClient(this.builder, this.context as never),
+      this.modelName,
+    );
   }
 
   static forRef<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
+    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
     modelName: string,
     findUnique: ((model: Record<string, unknown>, ctx: {}) => unknown) | undefined,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
@@ -60,11 +82,11 @@ export class ModelLoader {
 
   static getFindUnique(
     findBy:
+      | string
       | {
           name: string | null;
           fields: string[];
-        }
-      | string,
+        },
   ): (model: Record<string, unknown>) => {} {
     if (typeof findBy === 'string') {
       return (parent) => ({ [findBy]: parent[findBy] });
@@ -84,7 +106,7 @@ export class ModelLoader {
   }
 
   static getDefaultFindBy<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
+    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ) {
@@ -96,11 +118,11 @@ export class ModelLoader {
     );
 
     let findBy:
+      | string
       | {
           name: string | null;
           fields: string[];
         }
-      | string
       | undefined;
 
     if (model.primaryKey) {
@@ -121,7 +143,7 @@ export class ModelLoader {
   }
 
   static getDefaultFindUnique<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
+    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ): (model: Record<string, unknown>) => {} {
@@ -131,7 +153,7 @@ export class ModelLoader {
   }
 
   static getDefaultIDSelection<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
+    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ): Record<string, boolean> {
@@ -151,7 +173,7 @@ export class ModelLoader {
   }
 
   static getCursorSelection<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
+    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
     modelName: string,
     cursor: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
@@ -180,7 +202,7 @@ export class ModelLoader {
   }
 
   static getFindUniqueForField<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
+    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
     modelName: string,
     fieldName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
@@ -192,11 +214,11 @@ export class ModelLoader {
     );
 
     let findBy:
+      | string
       | {
           name: string | null;
           fields: string[];
         }
-      | string
       | undefined;
 
     if (model.fields.some((field) => field.name === fieldName)) {
@@ -217,48 +239,103 @@ export class ModelLoader {
     return this.getFindUnique(findBy);
   }
 
-  async loadSelection(selection: SelectionState, context: object) {
-    const query = selectionToQuery(selection);
+  getSelection(info: GraphQLResolveInfo) {
+    const key = cacheKey(info.parentType.name, info.path);
+    if (!this.queryCache.has(key)) {
+      const selection = selectionStateFromInfo(this.context, info);
+      this.queryCache.set(key, {
+        selection,
+        query: selectionToQuery(selection),
+      });
+    }
+
+    return this.queryCache.get(key)!;
+  }
+
+  async loadSelection(info: GraphQLResolveInfo, model: object) {
+    const { selection, query } = this.getSelection(info);
+
+    const result = await this.stageQuery(selection, query, model);
 
+    if (result) {
+      const mappings = selection.mappings[info.path.key];
+
+      if (mappings) {
+        setLoaderMappings(this.context, info, mappings.mappings);
+      }
+    }
+
+    return result;
+  }
+
+  async stageQuery(selection: SelectionState, query: SelectionMap, model: object) {
     for (const entry of this.staged) {
       if (selectionCompatible(entry.state, query)) {
         mergeSelection(entry.state, query);
 
-        return entry.promise;
+        if (!entry.models.has(model)) {
+          entry.models.set(model, createResolvablePromise<Record<string, unknown> | null>());
+        }
+
+        return entry.models.get(model)!.promise;
       }
     }
 
-    return this.initLoad(selection, context);
+    return this.initLoad(selection, model);
   }
 
-  async initLoad(state: SelectionState, context: {}) {
-    const entry = {
-      promise: Promise.resolve().then(() => {
-        this.staged.delete(entry);
-
-        const delegate = getDelegateFromModel(
-          getClient(this.builder, context as never),
-          this.modelName,
-        );
-
-        if (delegate.findUniqueOrThrow) {
-          return delegate.findUniqueOrThrow({
-            ...selectionToQuery(state),
-            where: { ...(this.findUnique(this.model as Record<string, unknown>, context) as {}) },
-          } as never) as Promise<Record<string, unknown>>;
-        }
+  async initLoad(state: SelectionState, initialModel: {}) {
+    const models = new Map<object, ResolvablePromise<Record<string, unknown> | null>>();
+
+    const promise = createResolvablePromise<Record<string, unknown> | null>();
+    models.set(initialModel, promise);
 
-        return delegate.findUnique({
-          rejectOnNotFound: true,
-          ...selectionToQuery(state),
-          where: { ...(this.findUnique(this.model as Record<string, unknown>, context) as {}) },
-        } as never) as Promise<Record<string, unknown>>;
-      }),
+    const entry = {
+      models,
       state,
     };
 
     this.staged.add(entry);
 
-    return entry.promise;
+    const nextTick = createResolvablePromise<void>();
+    void this.tick.then(() => {
+      this.staged.delete(entry);
+
+      for (const [model, { resolve, reject }] of entry.models) {
+        if (this.delegate.findUniqueOrThrow) {
+          void 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
+            .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);
+    this.tick = nextTick.promise;
+
+    return promise.promise;
   }
 }
+
+function createResolvablePromise<T = unknown>(): ResolvablePromise<T> {
+  let resolveFn!: (value: T) => void;
+  let rejectFn!: (reason?: unknown) => void;
+  const promise = new Promise<T>((resolve, reject) => {
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+
+  return { promise, resolve: resolveFn, reject: rejectFn };
+}

package/src/object-ref.ts

@@ -5,7 +5,9 @@ export const prismaModelKey = Symbol.for('Pothos.prismaModelKey');
 
 export class PrismaObjectRef<Model extends PrismaModelTypes, T = {}> extends ObjectRef<T> {
   [prismaModelKey]!: Model;
+
   [abstractReturnShapeKey]!: WithBrand<T>;
+
   modelName: string;
 
   constructor(name: string, modelName: string) {

package/src/prisma-field-builder.ts

@@ -80,17 +80,27 @@ export class PrismaObjectFieldBuilder<
   Shape extends object = Model['Shape'],
 > extends RootBuilder<Types, Shape, 'PrismaObject'> {
   model: string;
+
   prismaFieldMap: FieldMap;
 
   exposeBoolean = this.createExpose('Boolean');
+
   exposeFloat = this.createExpose('Float');
+
   exposeInt = this.createExpose('Int');
+
   exposeID = this.createExpose('ID');
+
   exposeString = this.createExpose('String');
+
   exposeBooleanList = this.createExpose(['Boolean']);
+
   exposeFloatList = this.createExpose(['Float']);
+
   exposeIntList = this.createExpose(['Int']);
+
   exposeIDList = this.createExpose(['ID']);
+
   exposeStringList = this.createExpose(['String']);
 
   withAuth: 'scopeAuth' extends PluginName
@@ -117,6 +127,9 @@ export class PrismaObjectFieldBuilder<
         ...args: NormalizeArgs<
           [
             connectionOptions:
+              | ObjectRef<
+                  ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, false>>
+                >
               | PothosSchemaTypes.ConnectionObjectOptions<
                   Types,
                   ObjectRef<
@@ -139,11 +152,12 @@ export class PrismaObjectFieldBuilder<
                     Args
                   >,
                   ConnectionInterfaces
-                >
-              | ObjectRef<
-                  ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, false>>
                 >,
             edgeOptions:
+              | ObjectRef<{
+                  cursor: string;
+                  node?: ShapeFromTypeParam<Types, Model['Shape'], false>;
+                }>
               | PothosSchemaTypes.ConnectionEdgeObjectOptions<
                   Types,
                   ObjectRef<
@@ -165,11 +179,7 @@ export class PrismaObjectFieldBuilder<
                     Args
                   >,
                   EdgeInterfaces
-                >
-              | ObjectRef<{
-                  cursor: string;
-                  node?: ShapeFromTypeParam<Types, Model['Shape'], false>;
-                }>,
+                >,
           ],
           0
         >
@@ -528,18 +538,18 @@ export class PrismaObjectFieldBuilder<
     name: Name,
     ...args: NormalizeArgs<
       [
-        options: Omit<
-          PothosSchemaTypes.ObjectFieldOptions<
-            Types,
-            Shape,
-            Type,
-            Nullable,
-            {},
-            ResolveReturnShape
-          >,
-          'resolve' | 'select' | 'description' | 'nullable'
-        > &
-          ExposeNullability<Types, Type, Model['Shape'], Name, Nullable> & {
+        options: ExposeNullability<Types, Type, Model['Shape'], Name, Nullable> &
+          Omit<
+            PothosSchemaTypes.ObjectFieldOptions<
+              Types,
+              Shape,
+              Type,
+              Nullable,
+              {},
+              ResolveReturnShape
+            >,
+            'description' | 'nullable' | 'resolve' | 'select'
+          > & {
             description?: string | false;
           },
       ]
@@ -577,18 +587,18 @@ export class PrismaObjectFieldBuilder<
       name: Name,
       ...args: NormalizeArgs<
         [
-          options: Omit<
-            PothosSchemaTypes.ObjectFieldOptions<
-              Types,
-              Shape,
-              Type,
-              Nullable,
-              {},
-              ResolveReturnShape
-            >,
-            'resolve' | 'type' | 'select' | 'description' | 'nullable'
-          > &
-            ExposeNullability<Types, Type, Model['Shape'], Name, Nullable> & {
+          options: ExposeNullability<Types, Type, Model['Shape'], Name, Nullable> &
+            Omit<
+              PothosSchemaTypes.ObjectFieldOptions<
+                Types,
+                Shape,
+                Type,
+                Nullable,
+                {},
+                ResolveReturnShape
+              >,
+              'description' | 'nullable' | 'resolve' | 'select' | 'type'
+            > & {
               description?: string | false;
             },
         ]

package/src/types.ts

@@ -155,7 +155,7 @@ export type TypesForRelation<
   Relation extends keyof Model['Relations'],
 > = Model['Relations'][Relation]['Name'] extends infer Name
   ? Name extends keyof Types['PrismaTypes']
-    ? Types['PrismaTypes'][Name] & PrismaModelTypes
+    ? PrismaModelTypes & Types['PrismaTypes'][Name]
     : never
   : never;
 
@@ -205,7 +205,7 @@ export type PrismaObjectImplementationOptions<
 > = Omit<
   | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
   | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
-  'fields' | 'description'
+  'description' | 'fields'
 > & {
   description?: string | false;
   fields?: PrismaObjectFieldsShape<
@@ -225,8 +225,8 @@ export type PrismaObjectTypeOptions<
   Include,
   Select,
   Shape extends object,
-> = PrismaObjectRefOptions<Types, Model, FindUnique, Include, Select, Shape> &
-  PrismaObjectImplementationOptions<Types, Model, Interfaces, FindUnique, Select, Shape>;
+> = PrismaObjectImplementationOptions<Types, Model, Interfaces, FindUnique, Select, Shape> &
+  PrismaObjectRefOptions<Types, Model, FindUnique, Include, Select, Shape>;
 
 export type PrismaInterfaceRefOptions<
   Types extends SchemaTypes,
@@ -259,7 +259,7 @@ export type PrismaInterfaceImplementationOptions<
   Shape extends object,
 > = Omit<
   PothosSchemaTypes.InterfaceTypeOptions<Types, Shape, Interfaces>,
-  'fields' | 'description'
+  'description' | 'fields'
 > & {
   description?: string | false;
   fields?: PrismaObjectFieldsShape<
@@ -279,8 +279,8 @@ export type PrismaInterfaceTypeOptions<
   Include,
   Select,
   Shape extends object,
-> = PrismaInterfaceRefOptions<Types, Model, FindUnique, Include, Select, Shape> &
-  PrismaInterfaceImplementationOptions<Types, Model, Interfaces, FindUnique, Select, Shape>;
+> = PrismaInterfaceImplementationOptions<Types, Model, Interfaces, FindUnique, Select, Shape> &
+  PrismaInterfaceRefOptions<Types, Model, FindUnique, Include, Select, Shape>;
 
 type NameOrVariant =
   | {
@@ -305,7 +305,14 @@ export type PrismaNodeOptions<
     | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
     | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
     'fields' | 'isTypeOf'
-  > & {
+  > &
+  (UniqueField extends string
+    ? {
+        findUnique?: (id: string, context: Types['Context']) => Model['WhereUnique'];
+      }
+    : {
+        findUnique: (id: string, context: Types['Context']) => Model['WhereUnique'];
+      }) & {
     id: Omit<
       FieldOptionsFromKind<
         Types,
@@ -341,14 +348,9 @@ export type PrismaNodeOptions<
       Shape & { [prismaModelName]?: Model['Name'] },
       Select
     >;
-  } & (UniqueField extends string
-    ? {
-        findUnique?: (id: string, context: Types['Context']) => Model['WhereUnique'];
-      }
-    : {
-        findUnique: (id: string, context: Types['Context']) => Model['WhereUnique'];
-      }) &
-  (
+  } & {
+    nullable?: boolean;
+  } & (
     | {
         include?: Include & Model['Include'];
         select?: never;
@@ -357,9 +359,7 @@ export type PrismaNodeOptions<
         select: Model['Select'] & Select;
         include?: never;
       }
-  ) & {
-    nullable?: boolean;
-  };
+  );
 
 type QueryForField<
   Types extends SchemaTypes,
@@ -425,7 +425,7 @@ export type RelatedFieldOptions<
     Args,
     ResolveReturnShape
   >,
-  'resolve' | 'type' | 'description'
+  'description' | 'resolve' | 'type'
 > &
   (NeedsResolve extends false
     ? {
@@ -569,11 +569,11 @@ export type PrismaFieldWithInputOptions<
     Type,
     Model,
     Param,
-    {
+    Args & {
       [K in InputName]: InputFieldRef<
         InputShapeFromFields<Fields> | (true extends ArgRequired ? never : null | undefined)
       >;
-    } & Args,
+    },
     Nullable,
     ResolveShape,
     ResolveReturnShape,
@@ -583,11 +583,11 @@ export type PrismaFieldWithInputOptions<
 > &
   PothosSchemaTypes.FieldWithInputBaseOptions<
     Types,
-    {
+    Args & {
       [K in InputName]: InputFieldRef<
         InputShapeFromFields<Fields> | (true extends ArgRequired ? never : null | undefined)
       >;
-    } & Args,
+    },
     Fields,
     InputName,
     ArgRequired
@@ -620,8 +620,8 @@ export type PrismaConnectionFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
   Type extends
-    | PrismaRef<PrismaModelTypes>
     | PrismaInterfaceRef<PrismaModelTypes>
+    | PrismaRef<PrismaModelTypes>
     | keyof Types['PrismaTypes'],
   Model extends PrismaModelTypes,
   Param extends OutputType<Types>,
@@ -629,32 +629,33 @@ export type PrismaConnectionFieldOptions<
   Args extends InputFieldMap,
   ResolveReturnShape,
   Kind extends FieldKind,
+  // eslint-disable-next-line @typescript-eslint/sort-type-constituents
 > = Omit<
-  PothosSchemaTypes.ConnectionFieldOptions<
+  FieldOptionsFromKind<
     Types,
     ParentShape,
     Param,
     Nullable,
-    false,
-    false,
-    Args,
+    InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments> &
+      (InputFieldMap extends Args ? {} : Args),
+    Kind,
+    ParentShape,
     ResolveReturnShape
   >,
-  'resolve' | 'type'
+  'args' | 'resolve' | 'type'
 > &
   Omit<
-    FieldOptionsFromKind<
+    PothosSchemaTypes.ConnectionFieldOptions<
       Types,
       ParentShape,
       Param,
       Nullable,
-      (InputFieldMap extends Args ? {} : Args) &
-        InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>,
-      Kind,
-      ParentShape,
+      false,
+      false,
+      Args,
       ResolveReturnShape
     >,
-    'args' | 'resolve' | 'type'
+    'resolve' | 'type'
   > &
   (InputShapeFromFields<Args> &
     PothosSchemaTypes.DefaultConnectionArguments extends infer ConnectionArgs
@@ -695,17 +696,18 @@ export type RelatedConnectionOptions<
   Nullable extends boolean,
   Args extends InputFieldMap,
   NeedsResolve extends boolean,
+  // eslint-disable-next-line @typescript-eslint/sort-type-constituents
 > = Omit<
   PothosSchemaTypes.ObjectFieldOptions<
     Types,
     Model['Shape'],
     ObjectRef<unknown>,
     Nullable,
-    (InputFieldMap extends Args ? {} : Args) &
-      InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>,
+    InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments> &
+      (InputFieldMap extends Args ? {} : Args),
     unknown
   >,
-  'resolve' | 'type' | 'args' | 'description'
+  'args' | 'description' | 'resolve' | 'type'
 > &
   Omit<
     PothosSchemaTypes.ConnectionFieldOptions<
@@ -722,15 +724,7 @@ export type RelatedConnectionOptions<
   > &
   (InputShapeFromFields<Args> &
     PothosSchemaTypes.DefaultConnectionArguments extends infer ConnectionArgs
-    ? {
-        description?: string | false;
-        query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
-        type?: PrismaRef<TypesForRelation<Types, Model, Field>>;
-        cursor: CursorFromRelation<Model, Field>;
-        defaultSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
-        maxSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
-        totalCount?: NeedsResolve extends false ? boolean : false;
-      } & (NeedsResolve extends false
+    ? (NeedsResolve extends false
         ? {
             resolve?: (
               query: {
@@ -770,7 +764,15 @@ export type RelatedConnectionOptions<
                 Nullable
               >
             >;
-          })
+          }) & {
+        description?: string | false;
+        query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
+        type?: PrismaRef<TypesForRelation<Types, Model, Field>>;
+        cursor: CursorFromRelation<Model, Field>;
+        defaultSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
+        maxSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
+        totalCount?: NeedsResolve extends false ? boolean : false;
+      }
     : never);
 
 export type WithBrand<T> = T & { [typeBrandKey]: string };
@@ -790,7 +792,7 @@ export type FieldSelection =
       context: object,
       mergeNestedSelection: (
         selection: SelectionMap | boolean | ((args: object, context: object) => SelectionMap),
-        path?: string[] | IndirectInclude,
+        path?: IndirectInclude | string[],
       ) => SelectionMap | boolean,
       resolveSelection: (path: string[]) => FieldNode | null,
     ) => SelectionMap);

package/src/util/loader-map.ts

@@ -4,7 +4,7 @@ import { LoaderMappings } from '../types';
 
 const cache = createContextCache((ctx) => new Map<string, LoaderMappings>());
 
-export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath: string[]) {
+export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath: string[] = []) {
   let key = '';
   let current: GraphQLResolveInfo['path'] | undefined = path;