@pothos/plugin-prisma 3.65.2 → 4.0.0-next.0

package/src/generator.ts

@@ -5,6 +5,7 @@ import { mkdir, writeFile } from 'node:fs';
 import { dirname, join, resolve as resolvePath, posix } from 'node:path';
 import ts, { ListFormat, ScriptKind, ScriptTarget, SyntaxKind, version } from 'typescript';
 import { DMMF, generatorHandler } from '@prisma/generator-helper';
+import { PothosPrismaDatamodel } from './types';
 
 const MIN_TS_VERSION = [4, 5, 2];
 
@@ -28,6 +29,14 @@ function checkTSVersion() {
 
 const defaultOutput = resolvePath(__dirname, '../generated.ts');
 
+interface GeneratorConfig {
+  clientOutput?: string;
+  prismaUtils?: string;
+  pluginPath?: string;
+  generateDatamodel?: string;
+  documentation?: string;
+}
+
 generatorHandler({
   onManifest: () => ({
     prettyName: 'Pothos integration',
@@ -36,7 +45,7 @@ generatorHandler({
   }),
   onGenerate: async (options) => {
     checkTSVersion();
-    const config = options.generator.config as { clientOutput?: string; prismaUtils?: string };
+    const config = options.generator.config as GeneratorConfig;
     const prismaLocation =
       config.clientOutput ??
       options.otherGenerators.find((gen) => gen.provider.value === 'prisma-client-js')!.output!
@@ -45,7 +54,7 @@ generatorHandler({
     const outputLocation = options.generator.output?.value ?? defaultOutput;
     const prismaTypes = buildTypes(options.dmmf, config);
 
-    await generateOutput(options.dmmf, prismaTypes, prismaLocation, outputLocation);
+    await generateOutput(options.dmmf, prismaTypes, prismaLocation, outputLocation, config);
 
     if (outputLocation === defaultOutput) {
       await generateOutput(
@@ -53,18 +62,57 @@ generatorHandler({
         prismaTypes,
         prismaLocation.startsWith('@') ? prismaLocation : posix.join(prismaLocation, 'index.js'),
         join(outputLocation, '../esm/generated.ts'),
+        config,
       );
     }
   },
 });
 
+function trimDmmf(dmmf: DMMF.Document, documentation = false): PothosPrismaDatamodel {
+  const trimmed: PothosPrismaDatamodel = {
+    datamodel: {
+      models: {},
+    },
+  };
+
+  dmmf.datamodel.models.forEach((model) => {
+    trimmed.datamodel.models[model.name] = {
+      fields: model.fields.map((field) => ({
+        type: field.type,
+        kind: field.kind,
+        name: field.name,
+        isRequired: field.isRequired,
+        isList: field.isList,
+        hasDefaultValue: field.hasDefaultValue,
+        isUnique: field.isUnique,
+        isId: field.isId,
+        relationName: field.relationName,
+        relationFromFields: field.relationFromFields,
+        isUpdatedAt: field.isUpdatedAt,
+        documentation: documentation ? field.documentation : undefined,
+      })),
+      primaryKey: model.primaryKey
+        ? { name: model.primaryKey.name, fields: model.primaryKey.fields }
+        : null,
+      uniqueIndexes: model.uniqueIndexes.map((index) => ({
+        name: index.name,
+        fields: index.fields,
+      })),
+      documentation: documentation ? model.documentation : undefined,
+    };
+  });
+
+  return trimmed;
+}
+
 async function generateOutput(
   dmmf: DMMF.Document,
   prismaTypes: ts.InterfaceDeclaration,
   prismaLocation: string,
   outputLocation: string,
+  config: GeneratorConfig,
 ) {
-  const importStatement = ts.factory.createImportDeclaration(
+  const prismaImportStatement = ts.factory.createImportDeclaration(
     ...modifiersArg,
     [],
     ts.factory.createImportClause(
@@ -84,6 +132,23 @@ async function generateOutput(
     ts.factory.createStringLiteral(prismaLocation),
   );
 
+  const dmmfImportStatement = ts.factory.createImportDeclaration(
+    ...modifiersArg,
+    [],
+    ts.factory.createImportClause(
+      true,
+      undefined,
+      ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(
+          false,
+          undefined,
+          ts.factory.createIdentifier('PothosPrismaDatamodel'),
+        ),
+      ]),
+    ),
+    ts.factory.createStringLiteral(config.pluginPath ?? '@pothos/plugin-prisma'),
+  );
+
   const printer = ts.createPrinter({});
 
   const sourcefile = ts.createSourceFile(
@@ -94,7 +159,31 @@ async function generateOutput(
     ScriptKind.TS,
   );
 
-  const nodes = ts.factory.createNodeArray([importStatement, prismaTypes]);
+  const trimmedDatamodel = trimDmmf(dmmf, config.documentation === 'true');
+
+  const dmmfExport = ts.factory.createFunctionDeclaration(
+    [ts.factory.createModifier(SyntaxKind.ExportKeyword)],
+    undefined,
+    'getDatamodel',
+    [],
+    [],
+    ts.factory.createTypeReferenceNode('PothosPrismaDatamodel'),
+    ts.factory.createBlock([
+      ts.factory.createReturnStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('JSON'), 'parse'),
+          [],
+          [ts.factory.createStringLiteral(JSON.stringify(trimmedDatamodel))],
+        ),
+      ),
+    ]),
+  );
+
+  const nodes = ts.factory.createNodeArray(
+    config.generateDatamodel === 'true'
+      ? [prismaImportStatement, dmmfImportStatement, prismaTypes, dmmfExport]
+      : [prismaImportStatement, prismaTypes],
+  );
 
   const result = printer.printList(ListFormat.SourceFileStatements, nodes, sourcefile);
 

package/src/global-types.ts

@@ -2,6 +2,7 @@
 /* eslint-disable @typescript-eslint/no-empty-interface */
 import { GraphQLResolveInfo } from 'graphql';
 import {
+  ArgumentRef,
   FieldKind,
   FieldMap,
   FieldNullability,
@@ -36,12 +37,12 @@ import {
   ShapeFromSelection,
 } from './types';
 
-import type { PrismaPlugin } from '.';
+import type { PothosPrismaPlugin } from '.';
 
 declare global {
   export namespace PothosSchemaTypes {
     export interface Plugins<Types extends SchemaTypes> {
-      prisma: PrismaPlugin<Types>;
+      prisma: PothosPrismaPlugin<Types>;
     }
 
     export interface SchemaBuilderOptions<Types extends SchemaTypes> {
@@ -111,7 +112,6 @@ declare global {
       prismaObject: <
         Name extends keyof Types['PrismaTypes'],
         Interfaces extends InterfaceParam<Types>[],
-        FindUnique,
         Model extends PrismaModelTypes & Types['PrismaTypes'][Name],
         Include = unknown,
         Select = unknown,
@@ -121,12 +121,12 @@ declare global {
           Types,
           Model,
           Interfaces,
-          FindUnique,
           Include,
           Select,
           ShapeFromSelection<Types, Model, { select: Select; include: Include }>
         >,
       ) => PrismaObjectRef<
+        Types,
         Model,
         ShapeFromSelection<Types, Model, { select: Select; include: Include }>
       >;
@@ -134,7 +134,6 @@ declare global {
       prismaInterface: <
         Name extends keyof Types['PrismaTypes'],
         Interfaces extends InterfaceParam<Types>[],
-        FindUnique,
         Model extends PrismaModelTypes & Types['PrismaTypes'][Name],
         Include = unknown,
         Select = unknown,
@@ -144,22 +143,22 @@ declare global {
           Types,
           Model,
           Interfaces,
-          FindUnique,
           Include,
           Select,
           ShapeFromSelection<Types, Model, { select: Select; include: Include }>
         >,
       ) => PrismaInterfaceRef<
+        Types,
         Model,
         ShapeFromSelection<Types, Model, { select: Select; include: Include }>
       >;
 
       prismaObjectField: <
-        Type extends PrismaObjectRef<PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
-        Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer M, {}>
+        Type extends PrismaObjectRef<Types, PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
+        Model extends PrismaModelTypes = Type extends PrismaObjectRef<Types, infer M, {}>
           ? M
           : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
-        Shape extends {} = Type extends PrismaObjectRef<PrismaModelTypes, infer S>
+        Shape extends {} = Type extends PrismaObjectRef<Types, PrismaModelTypes, infer S>
           ? S & { [prismaModelName]?: Model['Name'] }
           : Model['Shape'] & {
               [prismaModelName]?: Type;
@@ -167,15 +166,15 @@ declare global {
       >(
         type: Type,
         fieldName: string,
-        field: (t: PrismaObjectFieldBuilder<Types, Model, false, Shape>) => FieldRef,
+        field: (t: PrismaObjectFieldBuilder<Types, Model, Shape>) => FieldRef<Types>,
       ) => void;
 
       prismaInterfaceField: <
-        Type extends PrismaInterfaceRef<PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
-        Model extends PrismaModelTypes = Type extends PrismaInterfaceRef<infer M, {}>
+        Type extends PrismaInterfaceRef<Types, PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
+        Model extends PrismaModelTypes = Type extends PrismaInterfaceRef<Types, infer M, {}>
           ? M
           : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
-        Shape extends {} = Type extends PrismaInterfaceRef<PrismaModelTypes, infer S>
+        Shape extends {} = Type extends PrismaInterfaceRef<Types, PrismaModelTypes, infer S>
           ? S & { [prismaModelName]?: Model['Name'] }
           : Model['Shape'] & {
               [prismaModelName]?: Type;
@@ -183,37 +182,37 @@ declare global {
       >(
         type: Type,
         fieldName: string,
-        field: (t: PrismaObjectFieldBuilder<Types, Model, false, Shape>) => FieldRef,
+        field: (t: PrismaObjectFieldBuilder<Types, Model, Shape>) => FieldRef<Types>,
       ) => void;
 
       prismaObjectFields: <
-        Type extends PrismaObjectRef<PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
-        Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer M, {}>
+        Type extends PrismaObjectRef<Types, PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
+        Model extends PrismaModelTypes = Type extends PrismaObjectRef<Types, infer M, {}>
           ? M
           : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
-        Shape extends {} = Type extends PrismaObjectRef<PrismaModelTypes, infer S>
+        Shape extends {} = Type extends PrismaObjectRef<Types, PrismaModelTypes, infer S>
           ? S & { [prismaModelName]?: Model['Name'] }
           : Model['Shape'] & {
               [prismaModelName]?: Type;
             },
       >(
         type: Type,
-        fields: (t: PrismaObjectFieldBuilder<Types, Model, false, Shape>) => FieldMap,
+        fields: (t: PrismaObjectFieldBuilder<Types, Model, Shape>) => FieldMap,
       ) => void;
 
       prismaInterfaceFields: <
-        Type extends PrismaInterfaceRef<PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
-        Model extends PrismaModelTypes = Type extends PrismaInterfaceRef<infer M, {}>
+        Type extends PrismaInterfaceRef<Types, PrismaModelTypes, {}> | keyof Types['PrismaTypes'],
+        Model extends PrismaModelTypes = Type extends PrismaInterfaceRef<Types, infer M, {}>
           ? M
           : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
-        Shape extends {} = Type extends PrismaInterfaceRef<PrismaModelTypes, infer S>
+        Shape extends {} = Type extends PrismaInterfaceRef<Types, PrismaModelTypes, infer S>
           ? S & { [prismaModelName]?: Model['Name'] }
           : Model['Shape'] & {
               [prismaModelName]?: Type;
             },
       >(
         type: Type,
-        fields: (t: PrismaObjectFieldBuilder<Types, Model, false, Shape>) => FieldMap,
+        fields: (t: PrismaObjectFieldBuilder<Types, Model, Shape>) => FieldMap,
       ) => void;
 
       prismaNode: 'relay' extends PluginName
@@ -239,6 +238,7 @@ declare global {
               UniqueField
             >,
           ) => PrismaNodeRef<
+            Types,
             PrismaModelTypes & Types['PrismaTypes'][Name],
             ShapeFromSelection<
               Types,
@@ -257,22 +257,22 @@ declare global {
       prismaField: <
         Args extends InputFieldMap,
         TypeParam extends
-          | PrismaRef<PrismaModelTypes>
+          | PrismaRef<Types, PrismaModelTypes>
           | keyof Types['PrismaTypes']
           | [keyof Types['PrismaTypes']]
-          | [PrismaRef<PrismaModelTypes>],
+          | [PrismaRef<Types, PrismaModelTypes>],
         Nullable extends FieldNullability<Type>,
         ResolveShape,
         ResolveReturnShape,
         Type extends TypeParam extends [unknown]
-          ? [ObjectRef<Model['Shape']>]
-          : ObjectRef<Model['Shape']>,
+          ? [ObjectRef<Types, Model['Shape']>]
+          : ObjectRef<Types, Model['Shape']>,
         Model extends PrismaModelTypes = PrismaModelTypes &
           (TypeParam extends [keyof Types['PrismaTypes']]
             ? Types['PrismaTypes'][TypeParam[0]]
-            : TypeParam extends [PrismaRef<PrismaModelTypes>]
+            : TypeParam extends [PrismaRef<Types, PrismaModelTypes>]
               ? TypeParam[0][typeof prismaModelKey]
-              : TypeParam extends PrismaRef<PrismaModelTypes>
+              : TypeParam extends PrismaRef<Types, PrismaModelTypes>
                 ? TypeParam[typeof prismaModelKey]
                 : TypeParam extends keyof Types['PrismaTypes']
                   ? Types['PrismaTypes'][TypeParam]
@@ -290,18 +290,18 @@ declare global {
           ResolveReturnShape,
           Kind
         >,
-      ) => FieldRef<ShapeFromTypeParam<Types, Type, Nullable>>;
+      ) => FieldRef<Types, ShapeFromTypeParam<Types, Type, Nullable>>;
 
       prismaConnection: 'relay' extends PluginName
         ? <
-            Type extends PrismaRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
+            Type extends PrismaRef<Types, PrismaModelTypes> | keyof Types['PrismaTypes'],
             Nullable extends boolean,
             ResolveReturnShape,
             Args extends InputFieldMap = {},
-            Model extends PrismaModelTypes = Type extends PrismaRef<infer T>
+            Model extends PrismaModelTypes = Type extends PrismaRef<Types, infer T>
               ? T
               : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']],
-            Shape = Type extends PrismaRef<PrismaModelTypes, infer S> ? S : Model['Shape'],
+            Shape = Type extends PrismaRef<Types, PrismaModelTypes, infer S> ? S : Model['Shape'],
             ConnectionInterfaces extends InterfaceParam<Types>[] = [],
             EdgeInterfaces extends InterfaceParam<Types>[] = [],
           >(
@@ -310,7 +310,7 @@ declare global {
               ParentShape,
               Type,
               Model,
-              ObjectRef<Model['Shape']>,
+              ObjectRef<Types, Model['Shape']>,
               Nullable,
               Args,
               ResolveReturnShape,
@@ -321,54 +321,63 @@ declare global {
                 connectionOptions:
                   | ConnectionObjectOptions<
                       Types,
-                      ObjectRef<Shape>,
+                      ObjectRef<Types, Shape>,
                       false,
                       false,
                       PrismaConnectionShape<Types, Shape, ParentShape, Args>,
                       ConnectionInterfaces
                     >
-                  | ObjectRef<ShapeFromConnection<ConnectionShapeHelper<Types, Shape, false>>>,
+                  | ObjectRef<
+                      Types,
+                      ShapeFromConnection<ConnectionShapeHelper<Types, Shape, false>>
+                    >,
                 edgeOptions:
                   | ConnectionEdgeObjectOptions<
                       Types,
-                      ObjectRef<Shape>,
+                      ObjectRef<Types, Shape>,
                       false,
                       PrismaConnectionShape<Types, Shape, ParentShape, Args>,
                       EdgeInterfaces
                     >
-                  | ObjectRef<{
-                      cursor: string;
-                      node?: Shape | null | undefined;
-                    }>,
+                  | ObjectRef<
+                      Types,
+                      {
+                        cursor: string;
+                        node?: Shape | null | undefined;
+                      }
+                    >,
               ],
               0
             >
-          ) => FieldRef<ShapeFromConnection<ConnectionShapeHelper<Types, Model['Shape'], Nullable>>>
+          ) => FieldRef<
+            Types,
+            ShapeFromConnection<ConnectionShapeHelper<Types, Model['Shape'], Nullable>>
+          >
         : '@pothos/plugin-relay is required to use this method';
 
       prismaFieldWithInput: 'prisma' extends PluginName
         ? <
-            Fields extends Record<string, InputFieldRef<unknown, 'InputObject'>>,
+            Fields extends Record<string, InputFieldRef<Types, unknown>>,
             TypeParam extends
-              | PrismaRef<PrismaModelTypes>
+              | PrismaRef<Types, PrismaModelTypes>
               | keyof Types['PrismaTypes']
               | [keyof Types['PrismaTypes']]
-              | [PrismaRef<PrismaModelTypes>],
+              | [PrismaRef<Types, PrismaModelTypes>],
             Type extends TypeParam extends [unknown]
-              ? [ObjectRef<Model['Shape']>]
-              : ObjectRef<Model['Shape']>,
+              ? [ObjectRef<Types, Model['Shape']>]
+              : ObjectRef<Types, Model['Shape']>,
             ResolveShape,
             ResolveReturnShape,
             ArgRequired extends boolean,
-            Args extends Record<string, InputFieldRef<unknown, 'Arg'>> = {},
+            Args extends Record<string, ArgumentRef<Types, unknown>> = {},
             Nullable extends FieldNullability<Type> = Types['DefaultFieldNullability'],
             InputName extends string = 'input',
             Model extends PrismaModelTypes = PrismaModelTypes &
               (TypeParam extends [keyof Types['PrismaTypes']]
                 ? Types['PrismaTypes'][TypeParam[0]]
-                : TypeParam extends [PrismaRef<PrismaModelTypes>]
+                : TypeParam extends [PrismaRef<Types, PrismaModelTypes>]
                   ? TypeParam[0][typeof prismaModelKey]
-                  : TypeParam extends PrismaRef<PrismaModelTypes>
+                  : TypeParam extends PrismaRef<Types, PrismaModelTypes>
                     ? TypeParam[typeof prismaModelKey]
                     : TypeParam extends keyof Types['PrismaTypes']
                       ? Types['PrismaTypes'][TypeParam]
@@ -391,7 +400,7 @@ declare global {
                 ? (Types & { WithInputArgRequired: boolean })['WithInputArgRequired']
                 : ArgRequired
             >,
-          ) => FieldRef<ShapeFromTypeParam<Types, Type, Nullable>>
+          ) => FieldRef<Types, ShapeFromTypeParam<Types, Type, Nullable>>
         : '@pothos/plugin-prisma is required to use this method';
     }
 
@@ -442,15 +451,14 @@ declare global {
     export interface PrismaObjectFieldBuilder<
       Types extends SchemaTypes,
       Model extends PrismaModelTypes,
-      NeedsResolve extends boolean,
       Shape extends object = Model['Shape'],
-    > extends InternalPrismaObjectFieldBuilder<Types, Model, NeedsResolve, Shape>,
+    > extends InternalPrismaObjectFieldBuilder<Types, Model, Shape>,
         RootFieldBuilder<Types, Shape, 'PrismaObject'> {}
 
     export interface FieldWithInputBaseOptions<
       Types extends SchemaTypes,
-      Args extends Record<string, InputFieldRef<unknown, 'Arg'>>,
-      Fields extends Record<string, InputFieldRef<unknown, 'InputObject'>>,
+      Args extends Record<string, ArgumentRef<Types, unknown>>,
+      Fields extends Record<string, InputFieldRef<Types, unknown>>,
       InputName extends string,
       ArgRequired extends boolean,
     > {}

package/src/index.ts

@@ -38,14 +38,13 @@ export type PrismaObjectFieldBuilder<
 export const ObjectFieldBuilder = InternalPrismaObjectFieldBuilder as new <
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
-  NeedsResolve extends boolean,
   Shape extends object = Model['Shape'],
 >(
-  name: string,
+  typename: string,
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
-) => PothosSchemaTypes.PrismaObjectFieldBuilder<Types, Model, NeedsResolve, Shape>;
+) => PothosSchemaTypes.PrismaObjectFieldBuilder<Types, Model, Shape>;
 
-export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
+export class PothosPrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
   constructor(cache: BuildCache<Types>) {
     super(cache, pluginName);
   }
@@ -171,4 +170,11 @@ export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
   }
 }
 
-SchemaBuilder.registerPlugin(pluginName, PrismaPlugin);
+SchemaBuilder.registerPlugin(pluginName, PothosPrismaPlugin, {
+  v3: (options) => ({
+    prisma: {
+      ...options.prisma,
+      filterConnectionTotalCount: options.prisma?.filterConnectionTotalCount ?? false,
+    },
+  }),
+});

package/src/interface-ref.ts

@@ -1,12 +1,16 @@
-import { InterfaceRef } from '@pothos/core';
+import { InterfaceRef, SchemaTypes } from '@pothos/core';
 import { prismaModelKey, PrismaObjectRef } from './object-ref';
 import type { PrismaModelTypes } from './types';
 
-export type PrismaRef<Model extends PrismaModelTypes, T = {}> =
-  | PrismaInterfaceRef<Model, T>
-  | PrismaObjectRef<Model, T>;
+export type PrismaRef<Types extends SchemaTypes, Model extends PrismaModelTypes, T = {}> =
+  | PrismaInterfaceRef<Types, Model, T>
+  | PrismaObjectRef<Types, Model, T>;
 
-export class PrismaInterfaceRef<Model extends PrismaModelTypes, T = {}> extends InterfaceRef<T> {
+export class PrismaInterfaceRef<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  T = {},
+> extends InterfaceRef<Types, T> {
   [prismaModelKey]!: Model;
 
   modelName: string;

package/src/model-loader.ts

@@ -60,7 +60,7 @@ export class ModelLoader {
   }
 
   static forRef<Types extends SchemaTypes>(
-    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
+    ref: InterfaceRef<Types, unknown> | ObjectRef<Types, unknown>,
     modelName: string,
     findUnique: ((model: Record<string, unknown>, ctx: {}) => unknown) | undefined,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
@@ -106,7 +106,7 @@ export class ModelLoader {
   }
 
   static getDefaultFindBy<Types extends SchemaTypes>(
-    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
+    ref: InterfaceRef<Types, unknown> | ObjectRef<Types, unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ) {
@@ -143,7 +143,7 @@ export class ModelLoader {
   }
 
   static getDefaultFindUnique<Types extends SchemaTypes>(
-    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
+    ref: InterfaceRef<Types, unknown> | ObjectRef<Types, unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ): (model: Record<string, unknown>) => {} {
@@ -153,7 +153,7 @@ export class ModelLoader {
   }
 
   static getDefaultIDSelection<Types extends SchemaTypes>(
-    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
+    ref: InterfaceRef<Types, unknown> | ObjectRef<Types, unknown>,
     modelName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
   ): Record<string, boolean> {
@@ -173,7 +173,7 @@ export class ModelLoader {
   }
 
   static getCursorSelection<Types extends SchemaTypes>(
-    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
+    ref: InterfaceRef<Types, unknown> | ObjectRef<Types, unknown>,
     modelName: string,
     cursor: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
@@ -202,7 +202,7 @@ export class ModelLoader {
   }
 
   static getFindUniqueForField<Types extends SchemaTypes>(
-    ref: InterfaceRef<unknown> | ObjectRef<unknown>,
+    ref: InterfaceRef<Types, unknown> | ObjectRef<Types, unknown>,
     modelName: string,
     fieldName: string,
     builder: PothosSchemaTypes.SchemaBuilder<Types>,

package/src/node-ref.ts

@@ -1,4 +1,9 @@
+import { SchemaTypes } from '@pothos/core';
 import { PrismaObjectRef } from './object-ref';
 import type { PrismaModelTypes } from './types';
 
-export class PrismaNodeRef<Model extends PrismaModelTypes, T> extends PrismaObjectRef<Model, T> {}
+export class PrismaNodeRef<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  T,
+> extends PrismaObjectRef<Types, Model, T> {}

package/src/object-ref.ts

@@ -1,9 +1,19 @@
-import { abstractReturnShapeKey, brandWithType, ObjectRef, typeBrandKey } from '@pothos/core';
+import {
+  abstractReturnShapeKey,
+  brandWithType,
+  ObjectRef,
+  SchemaTypes,
+  typeBrandKey,
+} from '@pothos/core';
 import type { PrismaModelTypes, WithBrand } from './types';
 
 export const prismaModelKey = Symbol.for('Pothos.prismaModelKey');
 
-export class PrismaObjectRef<Model extends PrismaModelTypes, T = {}> extends ObjectRef<T> {
+export class PrismaObjectRef<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  T = {},
+> extends ObjectRef<Types, T> {
   [prismaModelKey]!: Model;
 
   [abstractReturnShapeKey]!: WithBrand<T>;