@pothos/plugin-prisma 3.54.0 → 3.55.0

package/src/index.ts

@@ -6,6 +6,8 @@ import SchemaBuilder, {
   BasePlugin,
   BuildCache,
   PothosOutputFieldConfig,
+  PothosSchemaError,
+  PothosTypeConfig,
   SchemaTypes,
 } from '@pothos/core';
 import { ModelLoader } from './model-loader';
@@ -17,6 +19,7 @@ import { getLoaderMapping, setLoaderMappings } from './util/loader-map';
 import { queryFromInfo, selectionStateFromInfo } from './util/map-query';
 
 export { prismaConnectionHelpers } from './connection-helpers';
+export { PrismaInterfaceRef } from './interface-ref';
 export { PrismaNodeRef } from './node-ref';
 export { PrismaObjectRef } from './object-ref';
 export * from './types';
@@ -47,6 +50,37 @@ export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
     super(cache, pluginName);
   }
 
+  override onTypeConfig(typeConfig: PothosTypeConfig): PothosTypeConfig {
+    if (typeConfig.kind !== 'Object' && typeConfig.kind !== 'Interface') {
+      return typeConfig;
+    }
+
+    let model = typeConfig.extensions?.pothosPrismaModel as string | undefined;
+
+    typeConfig.interfaces.forEach((iface) => {
+      const interfaceModel = this.buildCache.getTypeConfig(iface, 'Interface').extensions
+        ?.pothosPrismaModel as string | undefined;
+
+      if (interfaceModel) {
+        if (model && model !== interfaceModel) {
+          throw new PothosSchemaError(
+            `PrismaObjects must be based on the same prisma model as any PrismaInterfaces they extend. ${typeConfig.name} uses ${model} and ${iface.name} uses ${interfaceModel}`,
+          );
+        }
+
+        model = interfaceModel;
+      }
+    });
+
+    return {
+      ...typeConfig,
+      extensions: {
+        ...typeConfig.extensions,
+        pothosPrismaModel: model,
+      },
+    };
+  }
+
   override onOutputFieldConfig(
     fieldConfig: PothosOutputFieldConfig<Types>,
   ): PothosOutputFieldConfig<Types> | null {
@@ -85,7 +119,7 @@ export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
       return resolver;
     }
 
-    const parentConfig = this.buildCache.getTypeConfig(fieldConfig.parentType, 'Object');
+    const parentConfig = this.buildCache.getTypeConfig(fieldConfig.parentType);
     const loadedCheck = fieldConfig.extensions?.pothosPrismaLoaded as
       | undefined
       | ((val: unknown) => boolean);
@@ -97,8 +131,28 @@ export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
       | undefined
       | ((query: {}, parent: unknown, args: {}, context: {}, info: {}) => unknown);
 
+    const parentTypes = new Set([fieldConfig.parentType]);
+
+    if (parentConfig.kind === 'Interface' || parentConfig.kind === 'Object') {
+      parentConfig.interfaces.forEach((iface) => {
+        const interfaceConfig = this.buildCache.getTypeConfig(iface, 'Interface');
+        if (interfaceConfig.extensions?.pothosPrismaModel) {
+          parentTypes.add(interfaceConfig.name);
+        }
+      });
+    }
+
     return (parent, args, context, info) => {
-      const mapping = getLoaderMapping(context, info.path, info.parentType.name);
+      let mapping = getLoaderMapping(context, info.path, info.parentType.name);
+
+      if (!mapping) {
+        for (const parentType of parentTypes) {
+          mapping = getLoaderMapping(context, info.path, parentType);
+          if (mapping) {
+            break;
+          }
+        }
+      }
 
       if ((!loadedCheck || loadedCheck(parent)) && mapping) {
         setLoaderMappings(context, info, mapping);

package/src/interface-ref.ts

@@ -0,0 +1,18 @@
+import { InterfaceRef } from '@pothos/core';
+import { prismaModelKey, PrismaObjectRef } from './object-ref';
+import type { PrismaModelTypes } from './types';
+
+export type PrismaRef<Model extends PrismaModelTypes, T = {}> =
+  | PrismaObjectRef<Model, T>
+  | PrismaInterfaceRef<Model, T>;
+
+export class PrismaInterfaceRef<Model extends PrismaModelTypes, T = {}> extends InterfaceRef<T> {
+  [prismaModelKey]!: Model;
+  modelName: string;
+
+  constructor(name: string, modelName: string) {
+    super(name);
+
+    this.modelName = modelName;
+  }
+}

package/src/model-loader.ts

@@ -1,4 +1,10 @@
-import { createContextCache, ObjectRef, PothosSchemaError, SchemaTypes } from '@pothos/core';
+import {
+  createContextCache,
+  InterfaceRef,
+  ObjectRef,
+  PothosSchemaError,
+  SchemaTypes,
+} from '@pothos/core';
 import { getDelegateFromModel, getModel } from './util/datamodel';
 import { getClient } from './util/get-client';
 import {
@@ -32,7 +38,7 @@ export class ModelLoader {
   }
 
   static forRef<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown>,
+    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
     modelName: string,
     findUnique: ((model: Record<string, unknown>, ctx: {}) => unknown) | undefined,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
@@ -78,7 +84,7 @@ export class ModelLoader {
   }
 
   static getDefaultFindBy<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown>,
+    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ) {
@@ -115,7 +121,7 @@ export class ModelLoader {
   }
 
   static getDefaultFindUnique<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown>,
+    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ): (model: Record<string, unknown>) => {} {
@@ -125,7 +131,7 @@ export class ModelLoader {
   }
 
   static getDefaultIDSelection<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown>,
+    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ): Record<string, boolean> {
@@ -145,7 +151,7 @@ export class ModelLoader {
   }
 
   static getCursorSelection<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown>,
+    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
     modelName: string,
     cursor: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
@@ -174,7 +180,7 @@ export class ModelLoader {
   }
 
   static getFindUniqueForField<Types extends SchemaTypes>(
-    ref: ObjectRef<unknown>,
+    ref: ObjectRef<unknown> | InterfaceRef<unknown>,
     modelName: string,
     fieldName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,

package/src/prisma-field-builder.ts

@@ -18,8 +18,8 @@ import {
   ShapeFromTypeParam,
   TypeParam,
 } from '@pothos/core';
+import { PrismaRef } from './interface-ref';
 import { ModelLoader } from './model-loader';
-import { PrismaObjectRef } from './object-ref';
 import {
   PrismaConnectionShape,
   PrismaModelTypes,
@@ -367,8 +367,9 @@ export class PrismaObjectFieldBuilder<
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
     model: string,
     fieldMap: FieldMap,
+    graphqlKind: PothosSchemaTypes.PothosKindToGraphQLType[FieldKind] = 'Object',
   ) {
-    super(name, builder, 'PrismaObject', 'Object');
+    super(name, builder, 'PrismaObject', graphqlKind);
 
     this.model = model;
     this.prismaFieldMap = fieldMap;
@@ -473,18 +474,14 @@ export class PrismaObjectFieldBuilder<
     }) as FieldRef<number, 'Object'>;
   }
 
-  variant<
-    Variant extends Model['Name'] | PrismaObjectRef<Model>,
-    Args extends InputFieldMap,
-    Nullable,
-  >(
+  variant<Variant extends Model['Name'] | PrismaRef<Model>, Args extends InputFieldMap, Nullable>(
     variant: Variant,
     ...allArgs: NormalizeArgs<
       [
         options: VariantFieldOptions<
           Types,
           Model,
-          Variant extends PrismaObjectRef<Model> ? Variant : PrismaObjectRef<Model>,
+          Variant extends PrismaRef<Model> ? Variant : PrismaRef<Model>,
           Args,
           Nullable,
           Shape
@@ -493,7 +490,7 @@ export class PrismaObjectFieldBuilder<
     >
   ): FieldRef<Model['Shape'], 'Object'> {
     const [{ isNull, nullable, ...options } = {} as never] = allArgs;
-    const ref: PrismaObjectRef<PrismaModelTypes> =
+    const ref: PrismaRef<PrismaModelTypes> =
       typeof variant === 'string' ? getRefFromModel(variant, this.builder) : variant;
 
     const selfSelect = (args: object, context: object, nestedQuery: (query: unknown) => unknown) =>
@@ -550,7 +547,7 @@ export class PrismaObjectFieldBuilder<
   ) {
     const [name, options = {} as never] = args;
 
-    const typeConfig = this.builder.configStore.getTypeConfig(this.typename, 'Object');
+    const typeConfig = this.builder.configStore.getTypeConfig(this.typename);
     const usingSelect = !!typeConfig.extensions?.pothosPrismaSelect;
 
     return this.exposeField<Type, Nullable, never>(name as never, {

package/src/schema-builder.ts

@@ -9,6 +9,7 @@ import SchemaBuilder, {
   PothosError,
   SchemaTypes,
 } from '@pothos/core';
+import { PrismaInterfaceRef } from './interface-ref';
 import { ModelLoader } from './model-loader';
 import { PrismaNodeRef } from './node-ref';
 import { PrismaObjectRef } from './object-ref';
@@ -29,7 +30,7 @@ schemaBuilderProto.prismaObject = function prismaObject(
 ) {
   const ref = options.variant
     ? new PrismaObjectRef(options.variant, type)
-    : getRefFromModel(type, this);
+    : (getRefFromModel(type, this) as PrismaObjectRef<PrismaModelTypes>);
   const name = options.variant ?? options.name ?? type;
   const fieldMap = getRelationMap(getDMMF(this)).get(type)!;
   const idSelection = ModelLoader.getDefaultIDSelection(ref, type, this);
@@ -64,6 +65,48 @@ schemaBuilderProto.prismaObject = function prismaObject(
   return ref as never;
 };
 
+schemaBuilderProto.prismaInterface = function prismaInterface(
+  type,
+  { fields, findUnique, select, include, description, ...options },
+) {
+  const ref = options.variant
+    ? new PrismaInterfaceRef(options.variant, type)
+    : (getRefFromModel(type, this, 'interface') as PrismaInterfaceRef<PrismaModelTypes>);
+  const name = options.variant ?? options.name ?? type;
+  const fieldMap = getRelationMap(getDMMF(this)).get(type)!;
+  const idSelection = ModelLoader.getDefaultIDSelection(ref, type, this);
+
+  ref.name = name;
+
+  this.interfaceType(ref, {
+    ...(options as {}),
+    description: getModelDescription(type, this, description),
+    extensions: {
+      ...options.extensions,
+      pothosPrismaInclude: include,
+      pothosPrismaModel: type,
+      pothosPrismaFieldMap: fieldMap,
+      pothosPrismaSelect: select && { ...idSelection, ...(select as {}) },
+      pothosPrismaLoader: ModelLoader.forRef(ref, type, findUnique as never, this),
+    },
+    name,
+    fields: fields
+      ? () =>
+          fields(
+            new PrismaObjectFieldBuilder(
+              name,
+              this,
+              type,
+              getRelationMap(getDMMF(this)).get(type)!,
+              'Interface',
+            ),
+          )
+      : undefined,
+  });
+
+  return ref as never;
+};
+
 schemaBuilderProto.prismaNode = function prismaNode(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes> & {
     nodeInterfaceRef?: () => InterfaceRef<unknown>;

package/src/types.ts

@@ -21,7 +21,7 @@ import {
   typeBrandKey,
   TypeParam,
 } from '@pothos/core';
-import { PrismaObjectRef } from './object-ref';
+import { PrismaInterfaceRef, PrismaRef } from './interface-ref';
 import type { PrismaObjectFieldBuilder } from './prisma-field-builder';
 
 export interface PrismaDelegate {
@@ -228,6 +228,60 @@ export type PrismaObjectTypeOptions<
 > = PrismaObjectRefOptions<Types, Model, FindUnique, Include, Select, Shape> &
   PrismaObjectImplementationOptions<Types, Model, Interfaces, FindUnique, Select, Shape>;
 
+export type PrismaInterfaceRefOptions<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  FindUnique,
+  Include,
+  Select,
+  Shape extends object,
+> = NameOrVariant &
+  (
+    | {
+        include?: Include & Model['Include'];
+        select?: never;
+        findUnique?: FindUnique &
+          (((parent: Shape, context: Types['Context']) => Model['WhereUnique']) | null);
+      }
+    | {
+        select: Model['Select'] & Select;
+        include?: never;
+        findUnique?: (parent: Shape, context: Types['Context']) => Model['WhereUnique'];
+      }
+  );
+
+export type PrismaInterfaceImplementationOptions<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  Interfaces extends InterfaceParam<Types>[],
+  FindUnique,
+  Select,
+  Shape extends object,
+> = Omit<
+  PothosSchemaTypes.InterfaceTypeOptions<Types, Shape, Interfaces>,
+  'fields' | 'description'
+> & {
+  description?: string | false;
+  fields?: PrismaObjectFieldsShape<
+    Types,
+    Model,
+    FindUnique extends null ? true : false,
+    Shape & (FindUnique extends null ? {} : { [prismaModelName]?: Model['Name'] }),
+    Select
+  >;
+};
+
+export type PrismaInterfaceTypeOptions<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  Interfaces extends InterfaceParam<Types>[],
+  FindUnique,
+  Include,
+  Select,
+  Shape extends object,
+> = PrismaInterfaceRefOptions<Types, Model, FindUnique, Include, Select, Shape> &
+  PrismaInterfaceImplementationOptions<Types, Model, Interfaces, FindUnique, Select, Shape>;
+
 type NameOrVariant =
   | {
       name?: never;
@@ -394,14 +448,14 @@ export type RelatedFieldOptions<
         >;
       }) & {
     description?: string | false;
-    type?: PrismaObjectRef<TypesForRelation<Types, Model, Field>>;
+    type?: PrismaRef<TypesForRelation<Types, Model, Field>>;
     query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
   };
 
 export type VariantFieldOptions<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
-  Variant extends PrismaObjectRef<Model>,
+  Variant extends PrismaRef<Model>,
   Args extends InputFieldMap,
   isNull,
   Shape,
@@ -458,10 +512,10 @@ export type PrismaFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
   Type extends
-    | PrismaObjectRef<PrismaModelTypes>
+    | PrismaRef<PrismaModelTypes>
     | keyof Types['PrismaTypes']
     | [keyof Types['PrismaTypes']]
-    | [PrismaObjectRef<PrismaModelTypes>],
+    | [PrismaRef<PrismaModelTypes>],
   Model extends PrismaModelTypes,
   Param extends TypeParam<Types>,
   Args extends InputFieldMap,
@@ -494,10 +548,10 @@ export type PrismaFieldWithInputOptions<
   Args extends Record<string, InputFieldRef<unknown, 'Arg'>>,
   Fields extends Record<string, InputFieldRef<unknown, 'InputObject'>>,
   Type extends
-    | PrismaObjectRef<PrismaModelTypes>
+    | PrismaRef<PrismaModelTypes>
     | keyof Types['PrismaTypes']
     | [keyof Types['PrismaTypes']]
-    | [PrismaObjectRef<PrismaModelTypes>],
+    | [PrismaRef<PrismaModelTypes>],
   Model extends PrismaModelTypes,
   Param extends TypeParam<Types>,
   Nullable extends FieldNullability<Param>,
@@ -562,7 +616,10 @@ export type PrismaFieldResolver<
 export type PrismaConnectionFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
-  Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
+  Type extends
+    | PrismaRef<PrismaModelTypes>
+    | PrismaInterfaceRef<PrismaModelTypes>
+    | keyof Types['PrismaTypes'],
   Model extends PrismaModelTypes,
   Param extends OutputType<Types>,
   Nullable extends boolean,
@@ -665,7 +722,7 @@ export type RelatedConnectionOptions<
     ? {
         description?: string | false;
         query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
-        type?: PrismaObjectRef<TypesForRelation<Types, Model, Field>>;
+        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);

package/src/util/datamodel.ts

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

package/src/util/map-query.ts

@@ -6,10 +6,12 @@ import {
   getArgumentValues,
   getNamedType,
   GraphQLField,
+  GraphQLInterfaceType,
   GraphQLNamedType,
   GraphQLObjectType,
   GraphQLResolveInfo,
   InlineFragmentNode,
+  isInterfaceType,
   isObjectType,
   Kind,
   SelectionSetNode,
@@ -84,7 +86,7 @@ function addTypeSelectionsForField(
     return;
   }
 
-  if (!isObjectType(type)) {
+  if (!(isObjectType(type) || isInterfaceType(type))) {
     return;
   }
 
@@ -143,7 +145,7 @@ function resolveIndirectInclude(
   for (const sel of selection.selectionSet.selections) {
     switch (sel.kind) {
       case Kind.FIELD:
-        if (sel.name.value === include.name && isObjectType(type)) {
+        if (sel.name.value === include.name && (isObjectType(type) || isInterfaceType(type))) {
           const returnType = getNamedType(type.getFields()[sel.name.value].type);
 
           resolveIndirectInclude(
@@ -196,13 +198,14 @@ function resolveIndirectInclude(
 }
 
 function addNestedSelections(
-  type: GraphQLObjectType,
+  type: GraphQLObjectType | GraphQLInterfaceType,
   context: object,
   info: GraphQLResolveInfo,
   state: SelectionState,
   selections: SelectionSetNode,
   indirectPath: string[],
 ) {
+  let parentType = type;
   for (const selection of selections.selections) {
     switch (selection.kind) {
       case Kind.FIELD:
@@ -210,12 +213,19 @@ function addNestedSelections(
 
         continue;
       case Kind.FRAGMENT_SPREAD:
-        if (info.fragments[selection.name.value].typeCondition.name.value !== type.name) {
+        parentType = info.schema.getType(
+          info.fragments[selection.name.value].typeCondition.name.value,
+        )! as GraphQLObjectType;
+        if (
+          isObjectType(type)
+            ? parentType.name !== type.name
+            : parentType.extensions?.pothosPrismaModel !== type.extensions.pothosPrismaModel
+        ) {
           continue;
         }
 
         addNestedSelections(
-          type,
+          parentType,
           context,
           info,
           state,
@@ -226,11 +236,18 @@ function addNestedSelections(
         continue;
 
       case Kind.INLINE_FRAGMENT:
-        if (selection.typeCondition && selection.typeCondition.name.value !== type.name) {
+        parentType = selection.typeCondition
+          ? (info.schema.getType(selection.typeCondition.name.value) as GraphQLObjectType)
+          : type;
+        if (
+          isObjectType(type)
+            ? parentType.name !== type.name
+            : parentType.extensions?.pothosPrismaModel !== type.extensions.pothosPrismaModel
+        ) {
           continue;
         }
 
-        addNestedSelections(type, context, info, state, selection.selectionSet, indirectPath);
+        addNestedSelections(parentType, context, info, state, selection.selectionSet, indirectPath);
 
         continue;
 
@@ -243,7 +260,7 @@ function addNestedSelections(
 }
 
 function addFieldSelection(
-  type: GraphQLObjectType,
+  type: GraphQLObjectType | GraphQLInterfaceType,
   context: object,
   info: GraphQLResolveInfo,
   state: SelectionState,
@@ -454,8 +471,10 @@ export function selectionStateFromInfo(
 
   const state = createStateForType(type, info);
 
-  if (!isObjectType(type)) {
-    throw new PothosValidationError('Prisma plugin can only resolve includes for object types');
+  if (!(isObjectType(type) || isInterfaceType(type))) {
+    throw new PothosValidationError(
+      'Prisma plugin can only resolve includes for object and interface types',
+    );
   }
 
   addFieldSelection(type, context, info, state, info.fieldNodes[0], []);
@@ -503,7 +522,7 @@ function normalizeInclude(path: string[], type: GraphQLNamedType): IndirectInclu
 
   const normalized: { name: string; type: string }[] = [];
 
-  if (!isObjectType(currentType)) {
+  if (!(isObjectType(currentType) || isInterfaceType(currentType))) {
     throw new PothosValidationError(`Expected ${currentType} to be an Object type`);
   }
 
@@ -516,8 +535,8 @@ function normalizeInclude(path: string[], type: GraphQLNamedType): IndirectInclu
 
     currentType = getNamedType(field.type);
 
-    if (!isObjectType(currentType)) {
-      throw new PothosValidationError(`Expected ${currentType} to be an Object type`);
+    if (!(isObjectType(currentType) || isInterfaceType(currentType))) {
+      throw new PothosValidationError(`Expected ${currentType} to be an Object or Interface type`);
     }
 
     normalized.push({ name: fieldName, type: currentType.name });