@pothos/plugin-prisma 0.18.0 → 0.19.0

package/src/global-types.ts

@@ -11,6 +11,7 @@ import {
   PluginName,
   SchemaTypes,
   ShapeFromTypeParam,
+  TypeParam,
 } from '@pothos/core';
 import PrismaNodeRef from './node-ref';
 import { prismaModelKey, PrismaObjectRef } from './object-ref';
@@ -20,9 +21,8 @@ import {
   PrismaModelTypes,
   PrismaNodeOptions,
   PrismaObjectTypeOptions,
-  ShapeWithInclude,
 } from './types';
-import { PrismaPlugin, ShapeFromConnection } from '.';
+import { PrismaObjectFieldOptions, PrismaPlugin, ShapeFromConnection, ShapeFromSelection } from '.';
 
 declare global {
   export namespace PothosSchemaTypes {
@@ -48,30 +48,77 @@ declare global {
         : PartialTypes['PrismaTypes'] & {};
     }
 
+    export interface PothosKindToGraphQLType {
+      PrismaObject: 'Object';
+    }
+
+    export interface FieldOptionsByKind<
+      Types extends SchemaTypes,
+      ParentShape,
+      Type extends TypeParam<Types>,
+      Nullable extends FieldNullability<Type>,
+      Args extends InputFieldMap,
+      ResolveShape,
+      ResolveReturnShape,
+    > {
+      PrismaObject: PrismaObjectFieldOptions<
+        Types,
+        ParentShape,
+        Type,
+        Nullable,
+        Args,
+        ResolveShape,
+        ResolveReturnShape
+      >;
+    }
+
     export interface SchemaBuilder<Types extends SchemaTypes> {
       prismaObject: <
         Name extends keyof Types['PrismaTypes'],
         Interfaces extends InterfaceParam<Types>[],
         FindUnique,
         Model extends PrismaModelTypes & Types['PrismaTypes'][Name],
-        Include extends Model['Include'] = {},
-        Shape extends object = ShapeWithInclude<Model, Include>,
+        Include = unknown,
+        Select = unknown,
       >(
         name: Name,
-        options: PrismaObjectTypeOptions<Types, Model, Interfaces, FindUnique, Include, Shape>,
-      ) => PrismaObjectRef<Model, Shape>;
+        options: PrismaObjectTypeOptions<
+          Types,
+          Model,
+          Interfaces,
+          FindUnique,
+          Include,
+          Select,
+          ShapeFromSelection<Model, { select: Select; include: Include }>
+        >,
+      ) => PrismaObjectRef<Model, ShapeFromSelection<Model, { select: Select; include: Include }>>;
 
       prismaNode: 'relay' extends PluginName
         ? <
             Name extends keyof Types['PrismaTypes'],
-            Interfaces extends InterfaceParam<Types>[],
-            Model extends PrismaModelTypes & Types['PrismaTypes'][Name],
-            Include extends Model['Include'] = {},
-            Shape extends object = ShapeWithInclude<Model, Include>,
+            Interfaces extends InterfaceParam<Types>[] = [],
+            Include = unknown,
+            Select = unknown,
           >(
             name: Name,
-            options: PrismaNodeOptions<Types, Model, Interfaces, Include, Shape>,
-          ) => PrismaNodeRef<Model, Shape>
+            options: PrismaNodeOptions<
+              Types,
+              Types['PrismaTypes'][Name] & PrismaModelTypes,
+              Interfaces,
+              Include,
+              Select,
+              ShapeFromSelection<
+                PrismaModelTypes & Types['PrismaTypes'][Name],
+                { select: Select; include: Include }
+              >
+            >,
+          ) => PrismaNodeRef<
+            Types['PrismaTypes'][Name] & PrismaModelTypes,
+            ShapeFromSelection<
+              PrismaModelTypes & Types['PrismaTypes'][Name],
+              { select: Select; include: Include }
+            >
+          >
         : '@pothos/plugin-relay is required to use this method';
     }
 

package/src/index.ts

@@ -1,7 +1,16 @@
 import './global-types';
 import './field-builder';
 import './schema-builder';
-import SchemaBuilder, { BasePlugin, BuildCache, SchemaTypes } from '@pothos/core';
+import { getNamedType, GraphQLFieldResolver } from 'graphql';
+import SchemaBuilder, {
+  BasePlugin,
+  BuildCache,
+  PothosOutputFieldConfig,
+  SchemaTypes,
+} from '@pothos/core';
+import { ModelLoader } from './model-loader';
+import { getLoaderMapping, setLoaderMappings } from './util/loader-map';
+import { queryFromInfo, selectionStateFromInfo } from './util/map-query';
 
 export * from './types';
 
@@ -13,6 +22,71 @@ export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
   constructor(cache: BuildCache<Types>) {
     super(cache, pluginName);
   }
+
+  override onOutputFieldConfig(
+    fieldConfig: PothosOutputFieldConfig<Types>,
+  ): PothosOutputFieldConfig<Types> | null {
+    if (fieldConfig.kind === 'PrismaObject' && fieldConfig.pothosOptions.select) {
+      return {
+        ...fieldConfig,
+        extensions: {
+          ...fieldConfig.extensions,
+          pothosPrismaSelect: fieldConfig.pothosOptions.select,
+        },
+      };
+    }
+
+    return fieldConfig;
+  }
+
+  override wrapResolve(
+    resolver: GraphQLFieldResolver<unknown, Types['Context'], object, unknown>,
+    fieldConfig: PothosOutputFieldConfig<Types>,
+  ): GraphQLFieldResolver<unknown, Types['Context'], object> {
+    if (fieldConfig.kind !== 'PrismaObject' || !fieldConfig.extensions?.pothosPrismaSelect) {
+      return resolver;
+    }
+
+    const parentConfig = this.buildCache.getTypeConfig(fieldConfig.parentType, 'Object');
+    const loadedCheck = fieldConfig.extensions.pothosPrismaLoaded as
+      | undefined
+      | ((val: unknown) => boolean);
+    const loaderCache = parentConfig.extensions?.pothosPrismaLoader as (
+      model: unknown,
+    ) => ModelLoader;
+
+    const fallback = fieldConfig.extensions.pothosPrismaFallback as
+      | undefined
+      | ((query: {}, parent: unknown, args: {}, context: {}, info: {}) => unknown);
+
+    return (parent, args, context, info) => {
+      const mapping = getLoaderMapping(context, info.path, info.parentType.name);
+
+      if ((!loadedCheck || loadedCheck(parent)) && mapping) {
+        setLoaderMappings(context, info, mapping, getNamedType(info.returnType));
+
+        return resolver(parent, args, context, info);
+      }
+
+      if (fallback) {
+        return fallback(queryFromInfo(context, info), parent, args, context, info);
+      }
+
+      const selectionState = selectionStateFromInfo(context, info);
+
+      return loaderCache(parent)
+        .loadSelection(selectionState, context)
+        .then((result) => {
+          const mappings = selectionState.mappings[info.path.key];
+
+          if (mappings) {
+            setLoaderMappings(context, info, mappings.mappings, getNamedType(info.returnType));
+          }
+
+          return resolver(result, args, context, info);
+        });
+    };
+  }
 }
 
 SchemaBuilder.registerPlugin(pluginName, PrismaPlugin);

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