@pothos/plugin-prisma 3.53.0 → 3.55.0

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,
@@ -31,6 +33,7 @@ import {
   SelectionState,
   selectionToQuery,
 } from './selections';
+import { wrapWithUsageCheck } from './usage';
 
 function addTypeSelectionsForField(
   type: GraphQLNamedType,
@@ -83,7 +86,7 @@ function addTypeSelectionsForField(
     return;
   }
 
-  if (!isObjectType(type)) {
+  if (!(isObjectType(type) || isInterfaceType(type))) {
     return;
   }
 
@@ -142,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(
@@ -195,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:
@@ -209,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,
@@ -225,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;
 
@@ -242,7 +260,7 @@ function addNestedSelections(
 }
 
 function addFieldSelection(
-  type: GraphQLObjectType,
+  type: GraphQLObjectType | GraphQLInterfaceType,
   context: object,
   info: GraphQLResolveInfo,
   state: SelectionState,
@@ -370,6 +388,7 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   select,
   path = [],
   paths = [],
+  withUsageCheck = false,
 }: {
   context: object;
   info: GraphQLResolveInfo;
@@ -377,6 +396,7 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   select?: T;
   path?: string[];
   paths?: string[][];
+  withUsageCheck?: boolean;
 }): { select: T } | { include?: {} } {
   const returnType = getNamedType(info.returnType);
   const type = typeName ? info.schema.getTypeMap()[typeName] : returnType;
@@ -437,7 +457,9 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
 
   setLoaderMappings(context, info, state.mappings);
 
-  return selectionToQuery(state) as { select: T };
+  const query = selectionToQuery(state) as { select: T };
+
+  return withUsageCheck ? wrapWithUsageCheck(query) : query;
 }
 
 export function selectionStateFromInfo(
@@ -449,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], []);
@@ -498,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`);
   }
 
@@ -511,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

@@ -0,0 +1,33 @@
+export const usageSymbol = Symbol.for('Pothos.isUsed');
+
+export function wrapWithUsageCheck<T extends Object>(obj: T): T {
+  const result = {};
+  let used = true;
+
+  Object.defineProperty(result, usageSymbol, {
+    get() {
+      return used;
+    },
+    enumerable: false,
+  });
+
+  for (const key of Object.keys(obj)) {
+    // only set to false if the object has keys
+    used = false;
+    Object.defineProperty(result, key, {
+      enumerable: true,
+      configurable: true,
+      // eslint-disable-next-line @typescript-eslint/no-loop-func
+      get() {
+        used = true;
+        return obj[key as keyof T];
+      },
+    });
+  }
+
+  return result as T;
+}
+
+export function isUsed(obj: object): boolean {
+  return !(usageSymbol in obj) || (obj as { [usageSymbol]: boolean })[usageSymbol];
+}