@pothos/plugin-prisma 3.53.0 → 3.55.0

package/src/connection-helpers.ts

@@ -1,6 +1,6 @@
 import { ObjectRef, SchemaTypes } from '@pothos/core';
+import { PrismaRef } from './interface-ref';
 import { ModelLoader } from './model-loader';
-import { PrismaObjectRef } from './object-ref';
 import type { PrismaModelTypes, ShapeFromSelection, UniqueFieldsFromWhereUnique } from './types';
 import {
   getCursorFormatter,
@@ -17,12 +17,12 @@ export const prismaModelKey = Symbol.for('Pothos.prismaModelKey');
 
 export function prismaConnectionHelpers<
   Types extends SchemaTypes,
-  RefOrType extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
+  RefOrType extends PrismaRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
   Select extends Model['Select'] & {},
-  Model extends PrismaModelTypes = RefOrType extends PrismaObjectRef<infer T>
+  Model extends PrismaModelTypes = RefOrType extends PrismaRef<infer T>
     ? T & PrismaModelTypes
     : Types['PrismaTypes'][RefOrType & keyof Types['PrismaTypes']] & PrismaModelTypes,
-  Shape = RefOrType extends PrismaObjectRef<PrismaModelTypes, infer T> ? T : Model['Shape'],
+  Shape = RefOrType extends PrismaRef<PrismaModelTypes, infer T> ? T : Model['Shape'],
   EdgeShape = Model['Include'] extends Select
     ? Shape
     : ShapeFromSelection<Types, Model, { select: Select }>,
@@ -41,7 +41,7 @@ export function prismaConnectionHelpers<
   },
 ) {
   const modelName =
-    typeof refOrType === 'string' ? refOrType : (refOrType as PrismaObjectRef<Model>).modelName;
+    typeof refOrType === 'string' ? refOrType : (refOrType as PrismaRef<Model>).modelName;
   const ref =
     typeof refOrType === 'string'
       ? getRefFromModel(modelName, builder)
@@ -119,7 +119,7 @@ export function prismaConnectionHelpers<
   return {
     ref: (typeof refOrType === 'string'
       ? getRefFromModel(refOrType, builder)
-      : refOrType) as PrismaObjectRef<Model>,
+      : refOrType) as PrismaRef<Model>,
     resolve,
     select: options.select ?? {},
     getQuery,

package/src/field-builder.ts

@@ -3,8 +3,10 @@ import {
   FieldKind,
   FieldRef,
   InputFieldMap,
+  isThenable,
   MaybePromise,
   ObjectRef,
+  PothosError,
   RootFieldBuilder,
   SchemaTypes,
 } from '@pothos/core';
@@ -13,6 +15,7 @@ import { PrismaConnectionFieldOptions, PrismaModelTypes } from './types';
 import { getCursorFormatter, getCursorParser, resolvePrismaCursorConnection } from './util/cursors';
 import { getRefFromModel } from './util/datamodel';
 import { queryFromInfo } from './util/map-query';
+import { isUsed } from './util/usage';
 
 const fieldBuilderProto = RootFieldBuilder.prototype as PothosSchemaTypes.RootFieldBuilder<
   SchemaTypes,
@@ -32,9 +35,18 @@ fieldBuilderProto.prismaField = function prismaField({ type, resolve, ...options
     ...(options as {}),
     type: typeParam,
     resolve: (parent: never, args: unknown, context: {}, info: GraphQLResolveInfo) => {
-      const query = queryFromInfo({ context, info });
+      const query = queryFromInfo({
+        context,
+        info,
+        withUsageCheck: !!this.builder.options.prisma?.onUnusedQuery,
+      });
 
-      return resolve(query, parent, args as never, context, info) as never;
+      return checkIfQueryIsUsed(
+        this.builder,
+        query,
+        info,
+        resolve(query, parent, args as never, context, info) as never,
+      );
     },
   }) as never;
 };
@@ -57,9 +69,18 @@ fieldBuilderProto.prismaFieldWithInput = function prismaFieldWithInput({
     ...(options as {}),
     type: typeParam,
     resolve: (parent: never, args: unknown, context: {}, info: GraphQLResolveInfo) => {
-      const query = queryFromInfo({ context, info });
+      const query = queryFromInfo({
+        context,
+        info,
+        withUsageCheck: !!this.builder.options.prisma?.onUnusedQuery,
+      });
 
-      return resolve(query, parent, args as never, context, info) as never;
+      return checkIfQueryIsUsed(
+        this.builder,
+        query,
+        info,
+        resolve(query, parent, args as never, context, info) as never,
+      );
     },
   }) as never;
 };
@@ -114,17 +135,20 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
         args: PothosSchemaTypes.DefaultConnectionArguments,
         context: {},
         info: GraphQLResolveInfo,
-      ) =>
-        resolvePrismaCursorConnection(
+      ) => {
+        const query = queryFromInfo({
+          context,
+          info,
+          select: cursorSelection as {},
+          paths: [['nodes'], ['edges', 'node']],
+          typeName,
+          withUsageCheck: !!this.builder.options.prisma?.onUnusedQuery,
+        });
+
+        return resolvePrismaCursorConnection(
           {
             parent,
-            query: queryFromInfo({
-              context,
-              info,
-              select: cursorSelection as {},
-              paths: [['nodes'], ['edges', 'node']],
-              typeName,
-            }),
+            query,
             ctx: context,
             parseCursor,
             maxSize,
@@ -133,8 +157,15 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
             totalCount: totalCount && (() => totalCount(parent, args as never, context, info)),
           },
           formatCursor,
-          (query) => resolve(query as never, parent, args as never, context, info) as never,
-        ),
+          (q) =>
+            checkIfQueryIsUsed(
+              this.builder,
+              query,
+              info,
+              resolve(q as never, parent, args as never, context, info) as never,
+            ),
+        );
+      },
     },
     connectionOptions instanceof ObjectRef
       ? connectionOptions
@@ -163,3 +194,47 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
 
   return fieldRef;
 } as never;
+
+function checkIfQueryIsUsed<Types extends SchemaTypes, T>(
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  query: object,
+  info: GraphQLResolveInfo,
+  result: T,
+): T {
+  const { onUnusedQuery } = builder.options.prisma || {};
+  if (!onUnusedQuery) {
+    return result;
+  }
+
+  if (isThenable(result)) {
+    return result.then((resolved) => {
+      if (!isUsed(query)) {
+        onUnused();
+      }
+
+      return resolved;
+    }) as T;
+  }
+
+  if (!isUsed(query)) {
+    onUnused();
+  }
+
+  return result;
+
+  function onUnused() {
+    if (typeof onUnusedQuery === 'function') {
+      onUnusedQuery(info);
+      return;
+    }
+
+    const message = `Prisma query was unused in resolver for ${info.parentType.name}.${info.fieldName}`;
+
+    if (onUnusedQuery === 'error') {
+      throw new PothosError(message);
+    } else if (onUnusedQuery === 'warn') {
+      // eslint-disable-next-line no-console
+      console.warn(message);
+    }
+  }
+}

package/src/global-types.ts

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-interface */
+import { GraphQLResolveInfo } from 'graphql';
 import {
   FieldKind,
   FieldMap,
@@ -15,6 +16,7 @@ import {
   ShapeFromTypeParam,
   TypeParam,
 } from '@pothos/core';
+import { PrismaInterfaceRef, PrismaRef } from './interface-ref';
 import { PrismaNodeRef } from './node-ref';
 import { prismaModelKey, PrismaObjectRef } from './object-ref';
 import { PrismaObjectFieldBuilder as InternalPrismaObjectFieldBuilder } from './prisma-field-builder';
@@ -24,6 +26,7 @@ import {
   PrismaConnectionShape,
   PrismaFieldOptions,
   PrismaFieldWithInputOptions,
+  PrismaInterfaceTypeOptions,
   prismaModelName,
   PrismaModelTypes,
   PrismaNodeOptions,
@@ -52,6 +55,7 @@ declare global {
                   models?: boolean;
                   fields?: boolean;
                 };
+            onUnusedQuery?: null | 'warn' | 'error' | ((info: GraphQLResolveInfo) => void);
           }
         | {
             filterConnectionTotalCount?: boolean;
@@ -63,6 +67,7 @@ declare global {
                   models?: boolean;
                   fields?: boolean;
                 };
+            onUnusedQuery?: null | 'warn' | 'error' | ((info: GraphQLResolveInfo) => void);
           };
     }
 
@@ -122,6 +127,29 @@ declare global {
         ShapeFromSelection<Types, Model, { select: Select; include: Include }>
       >;
 
+      prismaInterface: <
+        Name extends keyof Types['PrismaTypes'],
+        Interfaces extends InterfaceParam<Types>[],
+        FindUnique,
+        Model extends PrismaModelTypes & Types['PrismaTypes'][Name],
+        Include = unknown,
+        Select = unknown,
+      >(
+        name: Name,
+        options: PrismaInterfaceTypeOptions<
+          Types,
+          Model,
+          Interfaces,
+          FindUnique,
+          Include,
+          Select,
+          ShapeFromSelection<Types, Model, { select: Select; include: Include }>
+        >,
+      ) => PrismaInterfaceRef<
+        Model,
+        ShapeFromSelection<Types, Model, { select: Select; include: Include }>
+      >;
+
       prismaObjectField: <
         Type extends PrismaObjectRef<PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
         Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer M, {}>
@@ -194,10 +222,10 @@ declare global {
       prismaField: <
         Args extends InputFieldMap,
         TypeParam extends
-          | PrismaObjectRef<PrismaModelTypes>
+          | PrismaRef<PrismaModelTypes>
           | keyof Types['PrismaTypes']
           | [keyof Types['PrismaTypes']]
-          | [PrismaObjectRef<PrismaModelTypes>],
+          | [PrismaRef<PrismaModelTypes>],
         Nullable extends FieldNullability<Type>,
         ResolveShape,
         ResolveReturnShape,
@@ -207,9 +235,9 @@ declare global {
         Model extends PrismaModelTypes = PrismaModelTypes &
           (TypeParam extends [keyof Types['PrismaTypes']]
             ? Types['PrismaTypes'][TypeParam[0]]
-            : TypeParam extends [PrismaObjectRef<PrismaModelTypes>]
+            : TypeParam extends [PrismaRef<PrismaModelTypes>]
             ? TypeParam[0][typeof prismaModelKey]
-            : TypeParam extends PrismaObjectRef<PrismaModelTypes>
+            : TypeParam extends PrismaRef<PrismaModelTypes>
             ? TypeParam[typeof prismaModelKey]
             : TypeParam extends keyof Types['PrismaTypes']
             ? Types['PrismaTypes'][TypeParam]
@@ -231,14 +259,14 @@ declare global {
 
       prismaConnection: 'relay' extends PluginName
         ? <
-            Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
+            Type extends PrismaRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
             Nullable extends boolean,
             ResolveReturnShape,
             Args extends InputFieldMap = {},
-            Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer T>
+            Model extends PrismaModelTypes = Type extends PrismaRef<infer T>
               ? T
               : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
-            Shape = Type extends PrismaObjectRef<PrismaModelTypes, infer S> ? S : Model['Shape'],
+            Shape = Type extends PrismaRef<PrismaModelTypes, infer S> ? S : Model['Shape'],
             ConnectionInterfaces extends InterfaceParam<Types>[] = [],
             EdgeInterfaces extends InterfaceParam<Types>[] = [],
           >(
@@ -287,10 +315,10 @@ declare global {
         ? <
             Fields extends Record<string, InputFieldRef<unknown, 'InputObject'>>,
             TypeParam extends
-              | PrismaObjectRef<PrismaModelTypes>
+              | PrismaRef<PrismaModelTypes>
               | keyof Types['PrismaTypes']
               | [keyof Types['PrismaTypes']]
-              | [PrismaObjectRef<PrismaModelTypes>],
+              | [PrismaRef<PrismaModelTypes>],
             Type extends TypeParam extends [unknown]
               ? [ObjectRef<Model['Shape']>]
               : ObjectRef<Model['Shape']>,
@@ -303,9 +331,9 @@ declare global {
             Model extends PrismaModelTypes = PrismaModelTypes &
               (TypeParam extends [keyof Types['PrismaTypes']]
                 ? Types['PrismaTypes'][TypeParam[0]]
-                : TypeParam extends [PrismaObjectRef<PrismaModelTypes>]
+                : TypeParam extends [PrismaRef<PrismaModelTypes>]
                 ? TypeParam[0][typeof prismaModelKey]
-                : TypeParam extends PrismaObjectRef<PrismaModelTypes>
+                : TypeParam extends PrismaRef<PrismaModelTypes>
                 ? TypeParam[typeof prismaModelKey]
                 : TypeParam extends keyof Types['PrismaTypes']
                 ? Types['PrismaTypes'][TypeParam]

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