@pothos/plugin-prisma 0.15.2 → 0.16.0

package/src/global-types.ts

@@ -13,6 +13,7 @@ import {
   ShapeFromTypeParam,
 } from '@pothos/core';
 import PrismaNodeRef from './node-ref';
+import { prismaModelKey, PrismaObjectRef } from './object-ref';
 import {
   PrismaConnectionFieldOptions,
   PrismaFieldOptions,
@@ -58,7 +59,7 @@ declare global {
       >(
         name: Name,
         options: PrismaObjectTypeOptions<Types, Model, Interfaces, FindUnique, Include, Shape>,
-      ) => ObjectRef<Shape>;
+      ) => PrismaObjectRef<Model, Shape>;
 
       prismaNode: 'relay' extends PluginName
         ? <
@@ -70,7 +71,7 @@ declare global {
           >(
             name: Name,
             options: PrismaNodeOptions<Types, Model, Interfaces, Include, Shape>,
-          ) => PrismaNodeRef<Shape>
+          ) => PrismaNodeRef<Model, Shape>
         : '@pothos/plugin-relay is required to use this method';
     }
 
@@ -81,15 +82,23 @@ declare global {
     > {
       prismaField: <
         Args extends InputFieldMap,
-        TypeParam extends keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']],
+        TypeParam extends
+          | PrismaObjectRef<PrismaModelTypes>
+          | keyof Types['PrismaTypes']
+          | [keyof Types['PrismaTypes']]
+          | [PrismaObjectRef<PrismaModelTypes>],
         Nullable extends FieldNullability<Type>,
         ResolveReturnShape,
-        Type extends TypeParam extends [keyof Types['PrismaTypes']]
+        Type extends TypeParam extends [unknown]
           ? [ObjectRef<Model['Shape']>]
           : ObjectRef<Model['Shape']>,
         Model extends PrismaModelTypes = PrismaModelTypes &
           (TypeParam extends [keyof Types['PrismaTypes']]
             ? Types['PrismaTypes'][TypeParam[0]]
+            : TypeParam extends [PrismaObjectRef<PrismaModelTypes>]
+            ? TypeParam[0][typeof prismaModelKey]
+            : TypeParam extends PrismaObjectRef<PrismaModelTypes>
+            ? TypeParam[typeof prismaModelKey]
             : TypeParam extends keyof Types['PrismaTypes']
             ? Types['PrismaTypes'][TypeParam]
             : never),
@@ -109,11 +118,13 @@ declare global {
 
       prismaConnection: 'relay' extends PluginName
         ? <
-            Type extends keyof Types['PrismaTypes'],
+            Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
             Nullable extends boolean,
             ResolveReturnShape,
             Args extends InputFieldMap = {},
-            Model extends PrismaModelTypes = PrismaModelTypes & Types['PrismaTypes'][Type],
+            Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer T>
+              ? T
+              : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
           >(
             ...args: NormalizeArgs<
               [

package/src/model-loader.ts

@@ -66,6 +66,20 @@ export class ModelLoader {
     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>;
+
+        return entry.promise;
+      }
+    }
+
+    return this.initLoad(null, include, context);
+  }
+
   async loadRelation(relation: string, include: unknown, context: {}) {
     let promise;
     for (const entry of this.staged) {
@@ -96,18 +110,21 @@ export class ModelLoader {
     return result[relation];
   }
 
-  async initLoad(relation: string, includeArg: unknown, context: {}, count = false) {
-    const include: Record<string, unknown> = count
-      ? {
-          _count: {
-            select: {
-              [relation]: true,
-            },
-          },
-        }
-      : {
-          [relation]: includeArg,
-        };
+  async initLoad(relation: string | null, includeArg: unknown, context: {}, count = false) {
+    const include: Record<string, unknown> =
+      (relation &&
+        (count
+          ? {
+              _count: {
+                select: {
+                  [relation]: true,
+                },
+              },
+            }
+          : {
+              [relation]: includeArg,
+            })) ||
+      {};
 
     const promise = new Promise<Record<string, unknown>>((resolve, reject) => {
       setTimeout(() => {
@@ -117,7 +134,7 @@ export class ModelLoader {
           this.delegate.findUnique({
             rejectOnNotFound: true,
             where: { ...(this.findUnique(this.model, context) as {}) },
-            include,
+            include: Object.keys(include).length > 0 ? include : undefined,
           } as never) as Promise<Record<string, unknown>>,
         );
       }, 0);

package/src/node-ref.ts

@@ -1,7 +1,12 @@
-import { abstractReturnShapeKey, brandWithType, ObjectRef, typeBrandKey } from '@pothos/core';
+import { abstractReturnShapeKey, brandWithType, typeBrandKey } from '@pothos/core';
+import { PrismaObjectRef } from './object-ref';
 import { WithBrand } from './types';
+import { PrismaModelTypes } from '.';
 
-export default class PrismaNodeRef<T> extends ObjectRef<T, T> {
+export default class PrismaNodeRef<Model extends PrismaModelTypes, T> extends PrismaObjectRef<
+  Model,
+  T
+> {
   [abstractReturnShapeKey]: WithBrand<T>;
 
   addBrand<V extends T | T[]>(

package/src/object-ref.ts

@@ -0,0 +1,8 @@
+import { ObjectRef } from '@pothos/core';
+import { PrismaModelTypes } from '.';
+
+export const prismaModelKey = Symbol.for('Pothos.prismaModelKey');
+
+export class PrismaObjectRef<Model extends PrismaModelTypes, T = {}> extends ObjectRef<T> {
+  [prismaModelKey]: Model;
+}

package/src/prisma-field-builder.ts

@@ -13,6 +13,7 @@ import {
 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,
@@ -21,7 +22,8 @@ import {
   RelatedFieldOptions,
   RelationCountOptions,
 } from './types';
-import { queryFromInfo } from './util';
+import { queryFromInfo, SELF_RELATION } from './util';
+import { VariantFieldOptions } from '.';
 
 export class PrismaObjectFieldBuilder<
   Types extends SchemaTypes,
@@ -69,6 +71,7 @@ export class PrismaObjectFieldBuilder<
       totalCount,
       ...options
     }: {
+      type?: ObjectRef<unknown, unknown>;
       totalCount?: boolean;
       maxSize?: number;
       defaultSize?: number;
@@ -84,7 +87,7 @@ export class PrismaObjectFieldBuilder<
     const parentRef = getRefFromModel(this.model, this.builder);
     const relationTypeName =
       typeof relationField.type === 'string' ? relationField.type : relationField.type.name;
-    const ref = getRefFromModel(relationTypeName, this.builder);
+    const ref = options.type ?? getRefFromModel(relationTypeName, this.builder);
     const findUnique = getFindUniqueForRef(parentRef, this.builder);
     const loaderCache = ModelLoader.forModel(this.model, this.builder);
     let typeName: string | undefined;
@@ -232,7 +235,7 @@ export class PrismaObjectFieldBuilder<
     const parentRef = getRefFromModel(this.model, this.builder);
     const relationTypeName =
       typeof relationField.type === 'string' ? relationField.type : relationField.type.name;
-    const ref = getRefFromModel(relationTypeName, this.builder);
+    const ref = options.type ?? getRefFromModel(relationTypeName, this.builder);
     const findUnique = getFindUniqueForRef(parentRef, this.builder);
     const loaderCache = ModelLoader.forModel(this.model, this.builder);
 
@@ -321,4 +324,50 @@ export class PrismaObjectFieldBuilder<
       },
     }) as FieldRef<number, 'Object'>;
   }
+
+  variant<Variant extends Model['Name'] | PrismaObjectRef<Model>>(
+    ...allArgs: NormalizeArgs<
+      [
+        variant: Variant,
+        options?: VariantFieldOptions<
+          Types,
+          Model,
+          Variant extends PrismaObjectRef<Model> ? Variant : PrismaObjectRef<Model>
+        >,
+      ]
+    >
+  ): FieldRef<Model['Shape'], 'Object'> {
+    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);
+
+    return this.field({
+      ...options,
+      type: ref,
+      extensions: {
+        ...options.extensions,
+        pothosPrismaRelation: SELF_RELATION,
+      },
+      resolve: (parent, args, context, info) => {
+        const mapping = getLoaderMapping(context, info.path);
+
+        if (mapping) {
+          setLoaderMappings(context, info.path, mapping);
+
+          return parent as never;
+        }
+
+        const queryOptions = queryFromInfo(context, info);
+
+        if (!findUnique) {
+          throw new Error(`Missing findUnique for Prisma type ${this.model}`);
+        }
+
+        return loaderCache(parent).loadSelf(queryOptions, context) as never;
+      },
+    }) as FieldRef<Model['Shape'], 'Object'>;
+  }
 }

package/src/refs.ts

@@ -1,8 +1,10 @@
 import { ObjectRef, SchemaTypes } from '@pothos/core';
 import { Prisma } from '../tests/client';
+import { PrismaObjectRef } from './object-ref';
 import { PrismaDelegate } from './types';
+import { PrismaModelTypes } from '.';
 
-export const refMap = new WeakMap<object, Map<string, ObjectRef<unknown>>>();
+export const refMap = new WeakMap<object, Map<string, PrismaObjectRef<PrismaModelTypes>>>();
 export const findUniqueMap = new WeakMap<
   object,
   Map<ObjectRef<unknown>, ((args: unknown, ctx: {}) => unknown) | null>
@@ -16,14 +18,14 @@ export const includeForRefMap = new WeakMap<
 export function getRefFromModel<Types extends SchemaTypes>(
   name: string,
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
-): ObjectRef<unknown> {
+): PrismaObjectRef<PrismaModelTypes> {
   if (!refMap.has(builder)) {
     refMap.set(builder, new Map());
   }
   const cache = refMap.get(builder)!;
 
   if (!cache.has(name)) {
-    cache.set(name, builder.objectRef(name));
+    cache.set(name, new PrismaObjectRef(name));
   }
 
   return cache.get(name)!;

package/src/schema-builder.ts

@@ -18,8 +18,8 @@ import { queryFromInfo } from './util';
 const schemaBuilderProto = SchemaBuilder.prototype as PothosSchemaTypes.SchemaBuilder<SchemaTypes>;
 
 schemaBuilderProto.prismaObject = function prismaObject(type, { fields, findUnique, ...options }) {
-  const ref = getRefFromModel(type, this);
-  const name = options.name ?? type;
+  const ref = options.variant ? this.objectRef(options.variant) : getRefFromModel(type, this);
+  const name = options.variant ?? options.name ?? type;
 
   ref.name = name;
 
@@ -53,6 +53,7 @@ schemaBuilderProto.prismaNode = function prismaNode(
   {
     findUnique,
     name,
+    variant,
     ...options
   }: PrismaNodeOptions<SchemaTypes, ModelTypes<PrismaDelegate>, [], never, {}>,
 ) {
@@ -62,16 +63,12 @@ schemaBuilderProto.prismaNode = function prismaNode(
     throw new TypeError('builder.prismaNode requires @pothos/plugin-relay to be installed');
   }
 
-  const typeName = name ?? type;
+  const typeName = variant ?? name ?? type;
   const delegate = getDelegateFromModel(this.options.prisma.client, type);
   const nodeRef = new PrismaNodeRef(typeName);
   const extendedOptions = {
     ...options,
     interfaces: [interfaceRef, ...(options.interfaces ?? [])],
-    extensions: {
-      ...options.extensions,
-      pothosPrismaInclude: options.include,
-    },
     isTypeOf: (val: unknown) => nodeRef.hasBrand(val),
     findUnique: (parent: unknown, context: {}) =>
       findUnique(options.id.resolve(parent as never, context) as string, context),

package/src/types.ts

@@ -20,6 +20,7 @@ import {
   TypeParam,
 } from '@pothos/core';
 import { PrismaObjectFieldBuilder } from './field-builder';
+import { PrismaObjectRef } from './object-ref';
 
 export interface PrismaDelegate {
   findUnique: (...args: any[]) => Promise<unknown>;
@@ -65,6 +66,7 @@ export type ModelTypes<Model extends {}> = Model extends {
   : never;
 
 export interface PrismaModelTypes {
+  Name: string;
   Shape: {};
   Include: unknown;
   Where: {};
@@ -126,16 +128,27 @@ export type PrismaObjectTypeOptions<
   FindUnique,
   Include extends Model['Include'],
   Shape extends object,
-> = Omit<
-  | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
-  | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
-  'fields'
-> & {
-  name?: string;
-  include?: Include;
-  fields?: PrismaObjectFieldsShape<Types, Model, FindUnique extends null ? true : false, Shape>;
-  findUnique: FindUnique & (((parent: Shape, context: Types['Context']) => Model['Where']) | null);
-};
+> = NameOrVariant &
+  Omit<
+    | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
+    | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
+    'fields'
+  > & {
+    include?: Include;
+    fields?: PrismaObjectFieldsShape<Types, Model, FindUnique extends null ? true : false, Shape>;
+    findUnique: FindUnique &
+      (((parent: Shape, context: Types['Context']) => Model['Where']) | null);
+  };
+
+export type NameOrVariant =
+  | {
+      name?: never;
+      variant?: string;
+    }
+  | {
+      name?: string;
+      variant?: never;
+    };
 
 export type PrismaNodeOptions<
   Types extends SchemaTypes,
@@ -143,31 +156,31 @@ export type PrismaNodeOptions<
   Interfaces extends InterfaceParam<Types>[],
   Include extends Model['Include'],
   Shape extends object,
-> = Omit<
-  | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
-  | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
-  'fields' | 'isTypeOf'
-> & {
-  name?: string;
-  include?: Include;
-  id: Omit<
-    FieldOptionsFromKind<
-      Types,
-      Shape,
-      'ID',
-      false,
-      {},
-      'Object',
-      OutputShape<Types, 'ID'>,
-      MaybePromise<OutputShape<Types, 'ID'>>
-    >,
-    'args' | 'nullable' | 'resolve' | 'type'
+> = NameOrVariant &
+  Omit<
+    | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
+    | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
+    'fields' | 'isTypeOf'
   > & {
-    resolve: (parent: Shape, context: Types['Context']) => MaybePromise<OutputShape<Types, 'ID'>>;
+    include?: Include;
+    id: Omit<
+      FieldOptionsFromKind<
+        Types,
+        Shape,
+        'ID',
+        false,
+        {},
+        'Object',
+        OutputShape<Types, 'ID'>,
+        MaybePromise<OutputShape<Types, 'ID'>>
+      >,
+      'args' | 'nullable' | 'resolve' | 'type'
+    > & {
+      resolve: (parent: Shape, context: Types['Context']) => MaybePromise<OutputShape<Types, 'ID'>>;
+    };
+    fields?: PrismaObjectFieldsShape<Types, Model, false, Shape>;
+    findUnique: (id: string, context: Types['Context']) => Model['Where'];
   };
-  fields?: PrismaObjectFieldsShape<Types, Model, false, Shape>;
-  findUnique: (id: string, context: Types['Context']) => Model['Where'];
-};
 
 export type QueryForField<
   Types extends SchemaTypes,
@@ -254,9 +267,19 @@ export type RelatedFieldOptions<
           ShapeWithNullability<Types, Model['Relations'][Field]['Shape'], Nullable>
         >;
       }) & {
+    type?: PrismaObjectRef<Model['Relations'][Field]['Types']>;
     query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
   };
 
+export type VariantFieldOptions<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  Variant extends PrismaObjectRef<Model>,
+> = Omit<
+  PothosSchemaTypes.ObjectFieldOptions<Types, Model['Shape'], Variant, false, {}, Model['Shape']>,
+  'resolve' | 'type'
+>;
+
 export type RelationCountOptions<
   Types extends SchemaTypes,
   Shape,
@@ -286,7 +309,11 @@ export type RelationCountOptions<
 export type PrismaFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
-  Type extends keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']],
+  Type extends
+    | PrismaObjectRef<PrismaModelTypes>
+    | keyof Types['PrismaTypes']
+    | [keyof Types['PrismaTypes']]
+    | [PrismaObjectRef<PrismaModelTypes>],
   Model extends PrismaModelTypes,
   Param extends TypeParam<Types>,
   Args extends InputFieldMap,
@@ -325,7 +352,7 @@ export type PrismaFieldOptions<
 export type PrismaConnectionFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
-  Type extends keyof Types['PrismaTypes'],
+  Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
   Model extends PrismaModelTypes,
   Param extends OutputType<Types>,
   Nullable extends boolean,
@@ -406,6 +433,7 @@ export type RelatedConnectionOptions<
     'resolve' | 'type'
   > & {
     query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
+    type?: PrismaObjectRef<Model['Relations'][Field]['Types']>;
     cursor: CursorFromRelation<Model, Field>;
     defaultSize?: number;
     maxSize?: number;

package/src/util/map-includes.ts

@@ -22,6 +22,8 @@ import {
 } from '../types';
 import { mergeIncludes, resolveIndirectType } from '.';
 
+export const SELF_RELATION = '@self';
+
 function handleField(
   ctx: object,
   info: GraphQLResolveInfo,
@@ -108,7 +110,8 @@ function handleField(
     query = query(args, ctx);
   }
 
-  const existingInclude = includes[relationName];
+  const existingInclude =
+    relationName === SELF_RELATION ? { include: includes } : includes[relationName];
 
   query = { ...(query as {}), include: newIncludes };
 
@@ -120,6 +123,10 @@ function handleField(
     }
   }
 
+  if (!mappings[relationName]) {
+    mappings[relationName] = [];
+  }
+
   const nestedIncludes = (query as { include: IncludeMap }).include;
   const nestedMappings: LoaderMappings = {};
   const nestedCounts: IncludeCounts = {
@@ -127,8 +134,33 @@ function handleField(
     parent: counts.current,
   };
 
-  if (!mappings[relationName]) {
-    mappings[relationName] = [];
+  if (relationName === SELF_RELATION) {
+    mappings[relationName].push({
+      field: selection.name.value,
+      alias: selection.alias?.value,
+      mappings: nestedMappings,
+      indirectPath: indirectMap?.path ?? [],
+    });
+
+    const { include } = query as { include: Record<string, IncludeMap> };
+
+    if (selection.selectionSet) {
+      includesFromSelectionSet(
+        ctx,
+        type,
+        info,
+        includes,
+        counts,
+        nestedMappings,
+        selection.selectionSet,
+      );
+    }
+
+    Object.keys(include).forEach((key) => {
+      includes[key] = include[key];
+    });
+
+    return;
   }
 
   mappings[relationName].push({