@pothos/plugin-prisma 3.35.7 → 3.36.0

package/src/prisma-field-builder.ts

@@ -111,19 +111,28 @@ export class PrismaObjectFieldBuilder<
         options: RelatedConnectionOptions<Types, Model, Field, Nullable, Args, NeedsResolve>,
         ...args: NormalizeArgs<
           [
-            connectionOptions: PothosSchemaTypes.ConnectionObjectOptions<
-              Types,
-              ObjectRef<Shape>,
-              false,
-              false,
-              ResolveReturnShape
-            >,
-            edgeOptions: PothosSchemaTypes.ConnectionEdgeObjectOptions<
-              Types,
-              ObjectRef<Shape>,
-              false,
-              ResolveReturnShape
-            >,
+            connectionOptions:
+              | PothosSchemaTypes.ConnectionObjectOptions<
+                  Types,
+                  ObjectRef<Shape>,
+                  false,
+                  false,
+                  ResolveReturnShape
+                >
+              | ObjectRef<
+                  ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, false>>
+                >,
+            edgeOptions:
+              | PothosSchemaTypes.ConnectionEdgeObjectOptions<
+                  Types,
+                  ObjectRef<Shape>,
+                  false,
+                  ResolveReturnShape
+                >
+              | ObjectRef<{
+                  cursor: string;
+                  node?: ShapeFromTypeParam<Types, Model['Shape'], false>;
+                }>,
           ],
           0
         >
@@ -272,18 +281,22 @@ export class PrismaObjectFieldBuilder<
           );
         },
       },
-      {
-        ...connectionOptions,
-        fields: totalCount
-          ? (t: PothosSchemaTypes.ObjectFieldBuilder<SchemaTypes, { totalCount?: number }>) => ({
-              totalCount: t.int({
-                nullable: false,
-                resolve: (parent, args, context) => parent.totalCount,
-              }),
-              ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
-            })
-          : (connectionOptions as { fields: undefined }).fields,
-      },
+      connectionOptions instanceof ObjectRef
+        ? connectionOptions
+        : {
+            ...connectionOptions,
+            fields: totalCount
+              ? (
+                  t: PothosSchemaTypes.ObjectFieldBuilder<SchemaTypes, { totalCount?: number }>,
+                ) => ({
+                  totalCount: t.int({
+                    nullable: false,
+                    resolve: (parent, args, context) => parent.totalCount,
+                  }),
+                  ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
+                })
+              : (connectionOptions as { fields: undefined }).fields,
+          },
       edgeOptions,
     );
 

package/src/schema-builder.ts

@@ -9,7 +9,8 @@ import SchemaBuilder, {
 } from '@pothos/core';
 import { PrismaObjectFieldBuilder } from './field-builder';
 import { ModelLoader } from './model-loader';
-import PrismaNodeRef from './node-ref';
+import { PrismaNodeRef } from './node-ref';
+import { PrismaObjectRef } from './object-ref';
 import { PrismaModelTypes, PrismaNodeOptions } from './types';
 import { getDefaultIDParser, getDefaultIDSerializer } from './util/cursors';
 import { getDelegateFromModel, getRefFromModel } from './util/datamodel';
@@ -24,7 +25,9 @@ schemaBuilderProto.prismaObject = function prismaObject(
   type,
   { fields, findUnique, select, include, description, ...options },
 ) {
-  const ref = options.variant ? this.objectRef(options.variant) : getRefFromModel(type, this);
+  const ref = options.variant
+    ? new PrismaObjectRef(options.variant, type)
+    : getRefFromModel(type, this);
   const name = options.variant ?? options.name ?? type;
   const fieldMap = getRelationMap(getDMMF(this)).get(type)!;
   const idSelection = ModelLoader.getDefaultIDSelection(ref, type, this);
@@ -77,7 +80,7 @@ schemaBuilderProto.prismaNode = function prismaNode(
   const resolve = rawResolve ?? getDefaultIDSerializer(type, fieldName, this);
   const idParser = fieldName ? getDefaultIDParser(type, fieldName, this) : undefined;
   const typeName = variant ?? name ?? type;
-  const nodeRef = new PrismaNodeRef(typeName);
+  const nodeRef = new PrismaNodeRef(typeName, type);
   const findUnique = rawFindUnique
     ? (parent: unknown, context: {}) =>
         rawFindUnique(resolve(parent as never, context) as string, context)
@@ -156,3 +159,35 @@ schemaBuilderProto.prismaNode = function prismaNode(
 
   return nodeRef;
 } as never;
+
+schemaBuilderProto.prismaObjectField = function prismaObjectField(type, fieldName, field) {
+  const ref = typeof type === 'string' ? getRefFromModel(type, this) : type;
+  this.configStore.onTypeConfig(ref, ({ name }) => {
+    this.configStore.addFields(ref, () => ({
+      [fieldName]: field(
+        new PrismaObjectFieldBuilder(
+          name,
+          this,
+          ref.modelName,
+          getRelationMap(getDMMF(this)).get(ref.modelName)!,
+        ),
+      ),
+    }));
+  });
+};
+
+schemaBuilderProto.prismaObjectFields = function prismaObjectFields(type, fields) {
+  const ref = typeof type === 'string' ? getRefFromModel(type, this) : type;
+  this.configStore.onTypeConfig(ref, ({ name }) => {
+    this.configStore.addFields(ref, () =>
+      fields(
+        new PrismaObjectFieldBuilder(
+          name,
+          this,
+          ref.modelName,
+          getRelationMap(getDMMF(this)).get(ref.modelName)!,
+        ),
+      ),
+    );
+  });
+};

package/src/types.ts

@@ -151,29 +151,15 @@ type RelationShapeFromInclude<Model extends PrismaModelTypes, Include> = Normali
     : unknown;
 }>;
 
-export type PrismaObjectTypeOptions<
+export type PrismaObjectRefOptions<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
-  Interfaces extends InterfaceParam<Types>[],
   FindUnique,
   Include,
   Select,
   Shape extends object,
 > = NameOrVariant &
-  Omit<
-    | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
-    | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<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
-    >;
-  } & (
+  (
     | {
         include?: Include & Model['Include'];
         select?: never;
@@ -187,6 +173,39 @@ export type PrismaObjectTypeOptions<
       }
   );
 
+export type PrismaObjectImplementationOptions<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  Interfaces extends InterfaceParam<Types>[],
+  FindUnique,
+  Select,
+  Shape extends object,
+> = Omit<
+  | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
+  | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<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 PrismaObjectTypeOptions<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  Interfaces extends InterfaceParam<Types>[],
+  FindUnique,
+  Include,
+  Select,
+  Shape extends object,
+> = PrismaObjectRefOptions<Types, Model, FindUnique, Include, Select, Shape> &
+  PrismaObjectImplementationOptions<Types, Model, Interfaces, FindUnique, Select, Shape>;
+
 type NameOrVariant =
   | {
       name?: never;

package/src/util/datamodel.ts

@@ -24,7 +24,7 @@ export function getRefFromModel<Types extends SchemaTypes>(
   const cache = refMap.get(builder)!;
 
   if (!cache.has(name)) {
-    cache.set(name, new PrismaObjectRef(name));
+    cache.set(name, new PrismaObjectRef(name, name));
   }
 
   return cache.get(name)!;

package/src/util/map-query.ts

@@ -96,6 +96,11 @@ function resolveIndirectInclude(
   path: string[],
   resolve: (type: GraphQLNamedType, field: FieldNode, path: string[]) => void,
 ) {
+  if (includePath.length === 0) {
+    resolve(type, selection as FieldNode, path);
+    return;
+  }
+
   const [include, ...rest] = includePath;
   if (!selection.selectionSet || !include) {
     return;
@@ -107,18 +112,14 @@ function resolveIndirectInclude(
         if (sel.name.value === include.name && isObjectType(type)) {
           const returnType = getNamedType(type.getFields()[sel.name.value].type);
 
-          if (rest.length === 0) {
-            resolve(returnType, sel, [...path, sel.alias?.value ?? sel.name.value]);
-          } else {
-            resolveIndirectInclude(
-              returnType,
-              info,
-              sel,
-              rest,
-              [...path, sel.alias?.value ?? sel.name.value],
-              resolve,
-            );
-          }
+          resolveIndirectInclude(
+            returnType,
+            info,
+            sel,
+            rest,
+            [...path, sel.alias?.value ?? sel.name.value],
+            resolve,
+          );
         }
         continue;
       case Kind.FRAGMENT_SPREAD:
@@ -334,7 +335,8 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   select?: T;
   path?: string[];
 }): { select: T } | { include?: {} } {
-  const type = typeName ? info.schema.getTypeMap()[typeName] : getNamedType(info.returnType);
+  const returnType = getNamedType(info.returnType);
+  const type = typeName ? info.schema.getTypeMap()[typeName] : returnType;
   const state = createStateForType(type, info);
 
   if (select) {
@@ -342,14 +344,27 @@ export function queryFromInfo<T extends SelectionMap['select'] | undefined = und
   }
 
   if (path.length > 0) {
+    const { pothosPrismaIndirectInclude } = (returnType.extensions ?? {}) as {
+      pothosPrismaIndirectInclude?: IndirectInclude;
+    };
+
     resolveIndirectInclude(
-      getNamedType(info.returnType),
+      returnType,
       info,
       info.fieldNodes[0],
-      path.map((n) => (typeof n === 'string' ? { name: n } : n)),
+      pothosPrismaIndirectInclude?.path ?? [],
       [],
-      (resolvedType, resolvedField, nested) => {
-        addTypeSelectionsForField(resolvedType, context, info, state, resolvedField, nested);
+      (indirectType, indirectField, subPath) => {
+        resolveIndirectInclude(
+          indirectType,
+          info,
+          indirectField,
+          path.map((n) => (typeof n === 'string' ? { name: n } : n)),
+          subPath,
+          (resolvedType, resolvedField, nested) => {
+            addTypeSelectionsForField(resolvedType, context, info, state, resolvedField, nested);
+          },
+        );
       },
     );
   } else {