@pothos/plugin-prisma 0.17.1 → 0.19.0

package/src/model-loader.ts

@@ -1,11 +1,12 @@
-/* eslint-disable prefer-destructuring */
-/* eslint-disable no-underscore-dangle */
 import { createContextCache, SchemaTypes } from '@pothos/core';
-import { getDelegateFromModel, getFindUniqueForRef, getRefFromModel } from './refs';
 import { PrismaDelegate } from './types';
-import { mergeIncludes } from './util';
-
-const loaderCache = new WeakMap<object, (model: object) => ModelLoader>();
+import { getDelegateFromModel } from './util/datamodel';
+import {
+  mergeSelection,
+  selectionCompatible,
+  SelectionState,
+  selectionToQuery,
+} from './util/selections';
 
 export class ModelLoader {
   model: object;
@@ -14,7 +15,7 @@ export class ModelLoader {
 
   staged = new Set<{
     promise: Promise<Record<string, unknown>>;
-    include: Record<string, unknown>;
+    state: SelectionState;
   }>();
 
   constructor(
@@ -27,105 +28,31 @@ export class ModelLoader {
     this.findUnique = findUnique;
   }
 
-  static forModel<Types extends SchemaTypes>(
+  static forRef<Types extends SchemaTypes>(
     modelName: string,
+    findUnique: (args: unknown, ctx: {}) => unknown,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ) {
     const delegate = getDelegateFromModel(builder.options.prisma.client, modelName);
 
-    if (!loaderCache.has(delegate)) {
-      const ref = getRefFromModel(modelName, builder);
-
-      const findUnique = getFindUniqueForRef(ref, builder);
-      loaderCache.set(
-        delegate,
-        createContextCache((model) => new ModelLoader(model, delegate, findUnique!)),
-      );
-    }
-
-    return loaderCache.get(delegate)!;
+    return createContextCache((model) => new ModelLoader(model, delegate, findUnique));
   }
 
-  async loadCount(relation: string, context: {}): Promise<number> {
-    let promise;
-    const entry = [...this.staged][0];
-
-    if (entry) {
-      if (!entry.include._count) {
-        entry.include._count = { select: {} };
-      }
-
-      (entry.include._count as { select: Record<string, boolean> }).select[relation] = true;
-      promise = entry.promise;
-    } else {
-      promise = this.initLoad(relation, null, context, true);
-    }
-
-    const result = await promise;
+  async loadSelection(selection: SelectionState, context: object) {
+    const query = selectionToQuery(selection);
 
-    return (result._count as Record<string, number>)[relation];
-  }
-
-  async loadSelf(include: unknown, context: {}) {
     for (const entry of this.staged) {
-      const merged = mergeIncludes(entry.include, include as Record<string, unknown>);
-
-      if (merged) {
-        entry.include = merged as Record<string, unknown>;
+      if (selectionCompatible(entry.state, query)) {
+        mergeSelection(entry.state, query);
 
         return entry.promise;
       }
     }
 
-    return this.initLoad(null, include, context);
+    return this.initLoad(selection, context);
   }
 
-  async loadRelation(relation: string, include: unknown, context: {}) {
-    let promise;
-    for (const entry of this.staged) {
-      if (entry.include[relation] === undefined) {
-        promise = entry.promise;
-        entry.include[relation] = include;
-
-        break;
-      }
-
-      const merged = mergeIncludes(
-        entry.include[relation] as Record<string, unknown>,
-        include as Record<string, unknown>,
-      );
-
-      if (merged) {
-        entry.include[relation] = merged;
-        break;
-      }
-    }
-
-    if (!promise) {
-      promise = this.initLoad(relation, include, context);
-    }
-
-    const result = await promise;
-
-    return result[relation];
-  }
-
-  async initLoad(relation: string | null, includeArg: unknown, context: {}, count = false) {
-    const include: Record<string, unknown> =
-      (relation &&
-        (count
-          ? {
-              _count: {
-                select: {
-                  [relation]: true,
-                },
-              },
-            }
-          : {
-              [relation]: includeArg,
-            })) ||
-      {};
-
+  async initLoad(state: SelectionState, context: {}) {
     const promise = new Promise<Record<string, unknown>>((resolve, reject) => {
       setTimeout(() => {
         this.staged.delete(entry);
@@ -133,8 +60,8 @@ export class ModelLoader {
         resolve(
           this.delegate.findUnique({
             rejectOnNotFound: true,
+            ...selectionToQuery(state),
             where: { ...(this.findUnique(this.model, context) as {}) },
-            include: Object.keys(include).length > 0 ? include : undefined,
           } as never) as Promise<Record<string, unknown>>,
         );
       }, 0);
@@ -142,7 +69,7 @@ export class ModelLoader {
 
     const entry = {
       promise,
-      include,
+      state,
     };
 
     this.staged.add(entry);

package/src/prisma-field-builder.ts

@@ -1,39 +1,66 @@
 /* eslint-disable no-underscore-dangle */
 import { GraphQLResolveInfo } from 'graphql';
 import {
+  CompatibleTypes,
+  FieldKind,
   FieldRef,
   InputFieldMap,
   MaybePromise,
   NormalizeArgs,
-  ObjectFieldBuilder,
   ObjectRef,
   PluginName,
+  RootFieldBuilder,
   SchemaTypes,
+  TypeParam,
 } from '@pothos/core';
-import { prismaCursorConnectionQuery, wrapConnectionResult } from './cursors';
-import { getLoaderMapping, setLoaderMappings } from './loader-map';
-import { ModelLoader } from './model-loader';
 import { PrismaObjectRef } from './object-ref';
-import { getDelegateFromModel, getFindUniqueForRef, getRefFromModel, getRelation } from './refs';
 import {
-  PrismaDelegate,
   PrismaModelTypes,
   RelatedConnectionOptions,
   RelatedFieldOptions,
   RelationCountOptions,
   ShapeFromConnection,
+  VariantFieldOptions,
 } from './types';
-import { queryFromInfo, SELF_RELATION } from './util';
-import { VariantFieldOptions } from '.';
+import { prismaCursorConnectionQuery, wrapConnectionResult } from './util/cursors';
+import {
+  getCursorFormatter,
+  getCursorParser,
+  getRefFromModel,
+  getRelation,
+} from './util/datamodel';
+import { 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
+  new <Types extends SchemaTypes, Shape, Kind extends FieldKind>(
+    name: string,
+    builder: PothosSchemaTypes.SchemaBuilder<Types>,
+    kind: FieldKind,
+    graphqlKind: PothosSchemaTypes.PothosKindToGraphQLType[FieldKind],
+  ): PothosSchemaTypes.RootFieldBuilder<Types, Shape, Kind>;
+} = RootFieldBuilder as never;
 
 export class PrismaObjectFieldBuilder<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
   NeedsResolve extends boolean,
   Shape extends object = Model['Shape'],
-> extends ObjectFieldBuilder<Types, Shape> {
-  delegate: PrismaDelegate;
+> 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']);
 
   relatedConnection: 'relay' extends PluginName
     ? <
@@ -90,22 +117,40 @@ export class PrismaObjectFieldBuilder<
     edgeOptions = {},
   ) {
     const relationField = getRelation(this.model, this.builder, name);
-    const parentRef = getRefFromModel(this.model, this.builder);
     const ref = options.type ?? getRefFromModel(relationField.type, this.builder);
-    const findUnique = getFindUniqueForRef(parentRef, this.builder);
-    const loaderCache = ModelLoader.forModel(this.model, this.builder);
     let typeName: string | undefined;
 
+    const formatCursor = getCursorFormatter(relationField.type, this.builder, cursor);
+    const parseCursor = getCursorParser(relationField.type, this.builder, cursor);
+
     const getQuery = (args: PothosSchemaTypes.DefaultConnectionArguments, ctx: {}) => ({
       ...((typeof query === 'function' ? query(args, ctx) : query) as {}),
       ...prismaCursorConnectionQuery({
-        column: cursor,
+        parseCursor,
         maxSize,
         defaultSize,
         args,
       }),
     });
 
+    const relationSelect = (
+      args: object,
+      context: object,
+      nestedQuery: (query: unknown) => unknown,
+    ) => ({
+      select: {
+        [name]: nestedQuery({
+          ...((typeof query === 'function' ? query(args, context) : query) as {}),
+          ...prismaCursorConnectionQuery({
+            parseCursor,
+            maxSize,
+            defaultSize,
+            args,
+          }),
+        }),
+      },
+    });
+
     const fieldRef = (
       this as unknown as {
         connection: (...args: unknown[]) => FieldRef<unknown>;
@@ -115,52 +160,43 @@ export class PrismaObjectFieldBuilder<
         ...options,
         extensions: {
           ...extensions,
-          pothosPrismaQuery: getQuery,
-          pothosPrismaRelation: name,
+          pothosPrismaLoaded: (value: Record<string, unknown>) => value[name] !== undefined,
+          pothosPrismaFallback:
+            resolve &&
+            ((
+              q: { take: number },
+              parent: unknown,
+              args: PothosSchemaTypes.DefaultConnectionArguments,
+              context: {},
+              info: GraphQLResolveInfo,
+            ) =>
+              Promise.resolve(
+                resolve(
+                  {
+                    ...q,
+                    ...(typeof query === 'function' ? query(args, context) : query),
+                  } as never,
+                  parent,
+                  args,
+                  context,
+                  info,
+                ),
+              ).then((result) => wrapConnectionResult(result, args, q.take, formatCursor))),
         },
         type: ref,
-        resolve: async (
-          parent: object,
+        select: relationSelect as never,
+        resolve: (
+          parent: unknown,
           args: PothosSchemaTypes.DefaultConnectionArguments,
           context: {},
-          info: GraphQLResolveInfo,
         ) => {
           const connectionQuery = getQuery(args, context);
-          const getResult = () => {
-            const mapping = getLoaderMapping(context, info.path);
-            const loadedValue = (parent as Record<string, unknown>)[name];
-
-            if (
-              // if we attempted to load the relation, and its missing it will be null
-              // undefined means that the query was not constructed in a way that requested the relation
-              loadedValue !== undefined &&
-              mapping
-            ) {
-              if (loadedValue !== null && loadedValue !== undefined) {
-                setLoaderMappings(context, info.path, mapping);
-              }
-
-              return loadedValue as {}[];
-            }
-
-            if (!resolve && !findUnique) {
-              throw new Error(`Missing findUnique for Prisma type ${this.model}`);
-            }
-
-            const mergedQuery = { ...queryFromInfo(context, info), ...connectionQuery };
-
-            if (resolve) {
-              return resolve(mergedQuery, parent, args, context, info);
-            }
-
-            return loaderCache(parent).loadRelation(name, mergedQuery, context) as Promise<{}[]>;
-          };
 
           return wrapConnectionResult(
-            await getResult(),
+            (parent as Record<string, never>)[name],
             args,
             connectionQuery.take,
-            cursor,
+            formatCursor,
             (parent as { _count?: Record<string, number> })._count?.[name],
           );
         },
@@ -171,17 +207,9 @@ export class PrismaObjectFieldBuilder<
           ? (t: PothosSchemaTypes.ObjectFieldBuilder<SchemaTypes, { totalCount?: number }>) => ({
               totalCount: t.int({
                 extensions: {
-                  pothosPrismaRelationCountForParent: name,
-                },
-                resolve: (parent, args, context) => {
-                  const loadedValue = parent.totalCount;
-
-                  if (loadedValue !== undefined) {
-                    return loadedValue;
-                  }
-
-                  return loaderCache(parent).loadCount(name, context);
+                  pothosPrismaParentSelect: { _count: { select: { [name]: true } } },
                 },
+                resolve: (parent, args, context) => parent.totalCount,
               }),
               ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
             })
@@ -205,11 +233,16 @@ export class PrismaObjectFieldBuilder<
     return fieldRef;
   } as never;
 
-  constructor(name: string, builder: PothosSchemaTypes.SchemaBuilder<Types>, model: string) {
-    super(name, builder);
+  constructor(
+    name: string,
+    builder: PothosSchemaTypes.SchemaBuilder<Types>,
+    model: string,
+    fieldMap: FieldMap,
+  ) {
+    super(name, builder, 'PrismaObject', 'Object');
 
     this.model = model;
-    this.delegate = getDelegateFromModel(builder.options.prisma.client, model);
+    this.prismaFieldMap = fieldMap;
   }
 
   relation<
@@ -236,54 +269,35 @@ export class PrismaObjectFieldBuilder<
   ): FieldRef<Model['Relations'][Field]['Shape'], 'Object'> {
     const [name, options = {} as never] = allArgs;
     const relationField = getRelation(this.model, this.builder, name);
-    const parentRef = getRefFromModel(this.model, this.builder);
     const ref = options.type ?? getRefFromModel(relationField.type, this.builder);
-    const findUnique = getFindUniqueForRef(parentRef, this.builder);
-    const loaderCache = ModelLoader.forModel(this.model, this.builder);
 
-    const { query = {}, resolve, ...rest } = options;
+    const { query = {}, resolve, extensions, ...rest } = options;
+
+    const relationSelect = (
+      args: object,
+      context: object,
+      nestedQuery: (query: unknown) => unknown,
+    ) => ({ select: { [name]: nestedQuery(query) } });
 
     return this.field({
       ...rest,
       type: relationField.isList ? [ref] : ref,
       extensions: {
-        ...options.extensions,
-        pothosPrismaQuery: query,
-        pothosPrismaRelation: name,
-      },
-      resolve: (parent, args, context, info) => {
-        const mapping = getLoaderMapping(context, info.path);
-
-        const loadedValue = (parent as Record<string, unknown>)[name];
-
-        if (
-          // if we attempted to load the relation, and its missing it will be null
-          // undefined means that the query was not constructed in a way that requested the relation
-          loadedValue !== undefined &&
-          mapping
-        ) {
-          if (loadedValue !== null && loadedValue !== undefined) {
-            setLoaderMappings(context, info.path, mapping);
-          }
-
-          return loadedValue as never;
-        }
-
-        const queryOptions = {
-          ...((typeof query === 'function' ? query(args, context) : query) as {}),
-          ...queryFromInfo(context, info),
-        };
-
-        if (resolve) {
-          return resolve(queryOptions, parent, args as never, context, info) as never;
-        }
-
-        if (!findUnique) {
-          throw new Error(`Missing findUnique for Prisma type ${this.model}`);
-        }
-
-        return loaderCache(parent).loadRelation(name, queryOptions, context) as never;
+        ...extensions,
+        pothosPrismaLoaded: (value: Record<string, unknown>) => value[name] !== undefined,
+        pothosPrismaFallback:
+          resolve &&
+          ((q: {}, parent: Shape, args: {}, context: {}, info: GraphQLResolveInfo) =>
+            resolve(
+              { ...q, ...(typeof query === 'function' ? query(args, context) : query) } as never,
+              parent,
+              args as never,
+              context,
+              info,
+            )),
       },
+      select: relationSelect as never,
+      resolve: (parent) => (parent as Record<string, never>)[name],
     }) as FieldRef<Model['Relations'][Field]['Shape'], 'Object'>;
   }
 
@@ -293,37 +307,22 @@ export class PrismaObjectFieldBuilder<
     >
   ): FieldRef<number, 'Object'> {
     const [name, options = {} as never] = allArgs;
-    const parentRef = getRefFromModel(this.model, this.builder);
-    const findUnique = getFindUniqueForRef(parentRef, this.builder);
-    const loaderCache = ModelLoader.forModel(this.model, this.builder);
 
     const { resolve, ...rest } = options;
 
+    const countSelect = {
+      _count: {
+        select: { [name]: true },
+      },
+    };
+
     return this.field({
       ...rest,
       type: 'Int',
       nullable: false,
-      extensions: {
-        ...options.extensions,
-        pothosPrismaRelationCount: name,
-      },
-      resolve: (parent, args, context, info) => {
-        const loadedValue = (parent as { _count: Record<string, unknown> })._count?.[name];
-
-        if (loadedValue !== undefined) {
-          return loadedValue as never;
-        }
-
-        if (resolve) {
-          return resolve(parent, args, context, info) as never;
-        }
-
-        if (!findUnique) {
-          throw new Error(`Missing findUnique for Prisma type ${this.model}`);
-        }
-
-        return loaderCache(parent).loadCount(name, context) as never;
-      },
+      select: countSelect as never,
+      resolve: (parent, args, context, info) =>
+        (parent as unknown as { _count: Record<string, never> })._count?.[name],
     }) as FieldRef<number, 'Object'>;
   }
 
@@ -342,34 +341,87 @@ export class PrismaObjectFieldBuilder<
     const [variant, options = {} as never] = allArgs;
     const ref: PrismaObjectRef<PrismaModelTypes> =
       typeof variant === 'string' ? getRefFromModel(variant, this.builder) : variant;
-    const parentRef = getRefFromModel(this.model, this.builder);
-    const findUnique = getFindUniqueForRef(parentRef, this.builder);
-    const loaderCache = ModelLoader.forModel(this.model, this.builder);
+
+    const selfSelect = (args: object, context: object, nestedQuery: (query: unknown) => unknown) =>
+      nestedQuery({});
 
     return this.field({
       ...options,
       type: ref,
-      extensions: {
-        ...options.extensions,
-        pothosPrismaRelation: SELF_RELATION,
-      },
-      resolve: (parent, args, context, info) => {
-        const mapping = getLoaderMapping(context, info.path);
+      select: selfSelect as never,
+      resolve: (parent, args, context, info) => parent,
+    }) as FieldRef<Model['Shape'], 'Object'>;
+  }
 
-        if (mapping) {
-          setLoaderMappings(context, info.path, mapping);
+  expose<
+    Type extends TypeParam<Types>,
+    Nullable extends boolean,
+    ResolveReturnShape,
+    Name extends CompatibleTypes<Types, Model['Shape'], Type, Nullable>,
+  >(
+    ...args: NormalizeArgs<
+      [
+        name: Name,
+        options?: Omit<
+          PothosSchemaTypes.ObjectFieldOptions<
+            Types,
+            Shape,
+            Type,
+            Nullable,
+            {},
+            ResolveReturnShape
+          >,
+          'resolve' | 'select'
+        >,
+      ]
+    >
+  ) {
+    const [name, options = {} as never] = args;
 
-          return parent as never;
-        }
+    const typeConfig = this.builder.configStore.getTypeConfig(this.typename, 'Object');
+    const usingSelect = !!typeConfig.extensions?.pothosPrismaSelect;
 
-        const queryOptions = queryFromInfo(context, info);
+    return this.exposeField(name as never, {
+      ...options,
+      extensions: {
+        ...options.extensions,
+        pothosPrismaVariant: name,
+        pothosPrismaSelect: usingSelect && {
+          [name]: true,
+        },
+      },
+    });
+  }
 
-        if (!findUnique) {
-          throw new Error(`Missing findUnique for Prisma type ${this.model}`);
-        }
+  private createExpose<Type extends TypeParam<Types>>(type: Type) {
+    return <
+      Nullable extends boolean,
+      ResolveReturnShape,
+      Name extends CompatibleTypes<Types, Model['Shape'], Type, Nullable>,
+    >(
+      ...args: NormalizeArgs<
+        [
+          name: Name,
+          options?: Omit<
+            PothosSchemaTypes.ObjectFieldOptions<
+              Types,
+              Shape,
+              Type,
+              Nullable,
+              {},
+              ResolveReturnShape
+            >,
+            'resolve' | 'type' | 'select'
+          >,
+        ]
+      >
+    ) => {
+      const [name, options = {} as never] = args;
 
-        return loaderCache(parent).loadSelf(queryOptions, context) as never;
-      },
-    }) as FieldRef<Model['Shape'], 'Object'>;
+      return this.expose(name as never, {
+        ...options,
+        type,
+      });
+    };
   }
 }