@pothos/plugin-prisma 3.54.0 → 3.56.0

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/cursors.ts

@@ -8,6 +8,7 @@ import {
 } from '@pothos/core';
 import { getModel } from './datamodel';
 import { DMMFField } from './get-client';
+import { extendWithUsage } from './usage';
 
 const DEFAULT_MAX_SIZE = 100;
 const DEFAULT_SIZE = 20;
@@ -339,10 +340,7 @@ export async function resolvePrismaCursorConnection<T extends {}>(
   }) => MaybePromise<readonly T[]>,
 ) {
   const query = prismaCursorConnectionQuery(options);
-  const results = await resolve({
-    ...options.query,
-    ...query,
-  });
+  const results = await resolve(extendWithUsage(options.query, query));
 
   if (!results) {
     return results;

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

package/src/util/usage.ts

@@ -8,6 +8,9 @@ export function wrapWithUsageCheck<T extends Object>(obj: T): T {
     get() {
       return used;
     },
+    set(value: boolean) {
+      used = value;
+    },
     enumerable: false,
   });
 
@@ -31,3 +34,31 @@ export function wrapWithUsageCheck<T extends Object>(obj: T): T {
 export function isUsed(obj: object): boolean {
   return !(usageSymbol in obj) || (obj as { [usageSymbol]: boolean })[usageSymbol];
 }
+
+export function extendWithUsage<T extends object, U extends object>(
+  original: T,
+  extension: U,
+): T & U {
+  if (!(usageSymbol in original)) {
+    return { ...original, ...extension };
+  }
+
+  const result = { ...extension };
+
+  for (const key of [usageSymbol, ...Object.keys(original)]) {
+    if (key in result) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    Object.defineProperty(result, key, {
+      enumerable: key !== usageSymbol,
+      configurable: key !== usageSymbol,
+      get() {
+        return original[key as keyof T];
+      },
+    });
+  }
+
+  return result as T & U;
+}