@pothos/plugin-prisma 0.15.0 → 0.16.1

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,13 @@ 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,
+    variant,
     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, ObjectRef<Shape>>
-  | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, ObjectRef<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, ObjectRef<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({