@pothos/plugin-prisma 0.15.0

package/src/prisma-field-builder.ts

@@ -0,0 +1,324 @@
+/* eslint-disable no-underscore-dangle */
+import { GraphQLResolveInfo } from 'graphql';
+import {
+  FieldRef,
+  InputFieldMap,
+  MaybePromise,
+  NormalizeArgs,
+  ObjectFieldBuilder,
+  ObjectRef,
+  PluginName,
+  SchemaTypes,
+} from '@pothos/core';
+import { prismaCursorConnectionQuery, wrapConnectionResult } from './cursors';
+import { getLoaderMapping, setLoaderMappings } from './loader-map';
+import { ModelLoader } from './model-loader';
+import { getDelegateFromModel, getFindUniqueForRef, getRefFromModel, getRelation } from './refs';
+import {
+  PrismaDelegate,
+  PrismaModelTypes,
+  RelatedConnectionOptions,
+  RelatedFieldOptions,
+  RelationCountOptions,
+} from './types';
+import { queryFromInfo } from './util';
+
+export class PrismaObjectFieldBuilder<
+  Types extends SchemaTypes,
+  Model extends PrismaModelTypes,
+  NeedsResolve extends boolean,
+  Shape extends object = Model['Shape'],
+> extends ObjectFieldBuilder<Types, Shape> {
+  delegate: PrismaDelegate;
+  model: string;
+
+  relatedConnection: 'relay' extends PluginName
+    ? <
+        Field extends Model['ListRelations'],
+        Nullable extends boolean,
+        Args extends InputFieldMap,
+        ResolveReturnShape,
+      >(
+        ...args: NormalizeArgs<
+          [
+            field: Field,
+            options: RelatedConnectionOptions<Types, Model, Field, Nullable, Args, NeedsResolve>,
+            connectionOptions?: PothosSchemaTypes.ConnectionObjectOptions<
+              Types,
+              ObjectRef<Shape>,
+              ResolveReturnShape
+            >,
+            edgeOptions?: PothosSchemaTypes.ConnectionEdgeObjectOptions<
+              Types,
+              ObjectRef<Shape>,
+              ResolveReturnShape
+            >,
+          ]
+        >
+      ) => FieldRef<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, Nullable>['shape']>
+    : '@pothos/plugin-relay is required to use this method' = function relatedConnection(
+    this: PrismaObjectFieldBuilder<SchemaTypes, Model, boolean>,
+    name: string,
+    {
+      maxSize,
+      defaultSize,
+      cursor,
+      query,
+      resolve,
+      extensions,
+      totalCount,
+      ...options
+    }: {
+      totalCount?: boolean;
+      maxSize?: number;
+      defaultSize?: number;
+      cursor: string;
+      extensions: {};
+      query: ((args: {}, ctx: {}) => {}) | {};
+      resolve: (query: {}, parent: unknown, args: {}, ctx: {}, info: {}) => MaybePromise<{}[]>;
+    },
+    connectionOptions = {},
+    edgeOptions = {},
+  ) {
+    const relationField = getRelation(this.model, this.builder, name);
+    const parentRef = getRefFromModel(this.model, this.builder);
+    const relationTypeName =
+      typeof relationField.type === 'string' ? relationField.type : relationField.type.name;
+    const ref = getRefFromModel(relationTypeName, this.builder);
+    const findUnique = getFindUniqueForRef(parentRef, this.builder);
+    const loaderCache = ModelLoader.forModel(this.model, this.builder);
+    let typeName: string | undefined;
+
+    const getQuery = (args: PothosSchemaTypes.DefaultConnectionArguments, ctx: {}) => ({
+      ...((typeof query === 'function' ? query(args, ctx) : query) as {}),
+      ...prismaCursorConnectionQuery({
+        column: cursor,
+        maxSize,
+        defaultSize,
+        args,
+      }),
+    });
+
+    const fieldRef = (
+      this as unknown as {
+        connection: (...args: unknown[]) => FieldRef<unknown>;
+      }
+    ).connection(
+      {
+        ...options,
+        extensions: {
+          ...extensions,
+          pothosPrismaQuery: getQuery,
+          pothosPrismaRelation: name,
+        },
+        type: ref,
+        resolve: async (
+          parent: object,
+          args: PothosSchemaTypes.DefaultConnectionArguments,
+          context: {},
+          info: GraphQLResolveInfo,
+        ) => {
+          const connectionQuery = getQuery(args, context);
+          const getResult = () => {
+            const mapping = getLoaderMapping(context, info.path);
+            const loadedValue = (parent as Record<string, unknown>)[name];
+
+            if (
+              // if we attempted to load the relation, and its missing it will be null
+              // undefined means that the query was not constructed in a way that requested the relation
+              loadedValue !== undefined &&
+              mapping
+            ) {
+              if (loadedValue !== null && loadedValue !== undefined) {
+                setLoaderMappings(context, info.path, mapping);
+              }
+
+              return loadedValue as {}[];
+            }
+
+            if (!resolve && !findUnique) {
+              throw new Error(`Missing findUnique for Prisma type ${this.model}`);
+            }
+
+            const mergedQuery = { ...queryFromInfo(context, info), ...connectionQuery };
+
+            if (resolve) {
+              return resolve(mergedQuery, parent, args, context, info);
+            }
+
+            return loaderCache(parent).loadRelation(name, mergedQuery, context) as Promise<{}[]>;
+          };
+
+          return wrapConnectionResult(
+            await getResult(),
+            args,
+            connectionQuery.take,
+            cursor,
+            (parent as { _count?: Record<string, number> })._count?.[name],
+          );
+        },
+      },
+      {
+        ...connectionOptions,
+        fields: totalCount
+          ? (t: PothosSchemaTypes.ObjectFieldBuilder<SchemaTypes, { totalCount?: number }>) => ({
+              totalCount: t.int({
+                extensions: {
+                  pothosPrismaRelationCountForParent: name,
+                },
+                resolve: (parent, args, context) => {
+                  const loadedValue = parent.totalCount;
+
+                  if (loadedValue !== undefined) {
+                    return loadedValue;
+                  }
+
+                  return loaderCache(parent).loadCount(name, context);
+                },
+              }),
+              ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
+            })
+          : (connectionOptions as { fields: undefined }).fields,
+        extensions: {
+          ...(connectionOptions as Record<string, {}> | undefined)?.extensions,
+          pothosPrismaIndirectInclude: {
+            getType: () => {
+              if (!typeName) {
+                typeName = this.builder.configStore.getTypeConfig(ref).name;
+              }
+              return typeName;
+            },
+            path: [{ name: 'edges' }, { name: 'node' }],
+          },
+        },
+      },
+      edgeOptions,
+    );
+
+    return fieldRef;
+  } as never;
+
+  constructor(name: string, builder: PothosSchemaTypes.SchemaBuilder<Types>, model: string) {
+    super(name, builder);
+
+    this.model = model;
+    this.delegate = getDelegateFromModel(builder.options.prisma.client, model);
+  }
+
+  relation<
+    Field extends Model['Fields'],
+    Nullable extends boolean,
+    Args extends InputFieldMap,
+    ResolveReturnShape,
+  >(
+    ...allArgs: NormalizeArgs<
+      [
+        name: Field,
+        options?: RelatedFieldOptions<
+          Types,
+          Model,
+          Field,
+          Nullable,
+          Args,
+          ResolveReturnShape,
+          NeedsResolve,
+          Shape
+        >,
+      ]
+    >
+  ): FieldRef<Model['Relations'][Field]['Shape'], 'Object'> {
+    const [name, options = {} as never] = allArgs;
+    const relationField = getRelation(this.model, this.builder, name);
+    const parentRef = getRefFromModel(this.model, this.builder);
+    const relationTypeName =
+      typeof relationField.type === 'string' ? relationField.type : relationField.type.name;
+    const ref = getRefFromModel(relationTypeName, this.builder);
+    const findUnique = getFindUniqueForRef(parentRef, this.builder);
+    const loaderCache = ModelLoader.forModel(this.model, this.builder);
+
+    const { query = {}, resolve, ...rest } = options;
+
+    return this.field({
+      ...rest,
+      type: relationField.isList ? [ref] : ref,
+      extensions: {
+        ...options.extensions,
+        pothosPrismaQuery: query,
+        pothosPrismaRelation: name,
+      },
+      resolve: (parent, args, context, info) => {
+        const mapping = getLoaderMapping(context, info.path);
+
+        const loadedValue = (parent as Record<string, unknown>)[name];
+
+        if (
+          // if we attempted to load the relation, and its missing it will be null
+          // undefined means that the query was not constructed in a way that requested the relation
+          loadedValue !== undefined &&
+          mapping
+        ) {
+          if (loadedValue !== null && loadedValue !== undefined) {
+            setLoaderMappings(context, info.path, mapping);
+          }
+
+          return loadedValue as never;
+        }
+
+        const queryOptions = {
+          ...((typeof query === 'function' ? query(args, context) : query) as {}),
+          ...queryFromInfo(context, info),
+        };
+
+        if (resolve) {
+          return resolve(queryOptions, parent, args as never, context, info) as never;
+        }
+
+        if (!findUnique) {
+          throw new Error(`Missing findUnique for Prisma type ${this.model}`);
+        }
+
+        return loaderCache(parent).loadRelation(name, queryOptions, context) as never;
+      },
+    }) as FieldRef<Model['Relations'][Field]['Shape'], 'Object'>;
+  }
+
+  relationCount<Field extends Model['Fields']>(
+    ...allArgs: NormalizeArgs<
+      [name: Field, options?: RelationCountOptions<Types, Shape, NeedsResolve>]
+    >
+  ): FieldRef<number, 'Object'> {
+    const [name, options = {} as never] = allArgs;
+    const parentRef = getRefFromModel(this.model, this.builder);
+    const findUnique = getFindUniqueForRef(parentRef, this.builder);
+    const loaderCache = ModelLoader.forModel(this.model, this.builder);
+
+    const { resolve, ...rest } = options;
+
+    return this.field({
+      ...rest,
+      type: 'Int',
+      nullable: false,
+      extensions: {
+        ...options.extensions,
+        pothosPrismaRelationCount: name,
+      },
+      resolve: (parent, args, context, info) => {
+        const loadedValue = (parent as { _count: Record<string, unknown> })._count?.[name];
+
+        if (loadedValue !== undefined) {
+          return loadedValue as never;
+        }
+
+        if (resolve) {
+          return resolve(parent, args, context, info) as never;
+        }
+
+        if (!findUnique) {
+          throw new Error(`Missing findUnique for Prisma type ${this.model}`);
+        }
+
+        return loaderCache(parent).loadCount(name, context) as never;
+      },
+    }) as FieldRef<number, 'Object'>;
+  }
+}

package/src/refs.ts

@@ -0,0 +1,110 @@
+import { ObjectRef, SchemaTypes } from '@pothos/core';
+import { Prisma } from '../tests/client';
+import { PrismaDelegate } from './types';
+
+export const refMap = new WeakMap<object, Map<string, ObjectRef<unknown>>>();
+export const findUniqueMap = new WeakMap<
+  object,
+  Map<ObjectRef<unknown>, ((args: unknown, ctx: {}) => unknown) | null>
+>();
+
+export const includeForRefMap = new WeakMap<
+  object,
+  Map<ObjectRef<unknown>, Record<string, unknown> | null>
+>();
+
+export function getRefFromModel<Types extends SchemaTypes>(
+  name: string,
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+): ObjectRef<unknown> {
+  if (!refMap.has(builder)) {
+    refMap.set(builder, new Map());
+  }
+  const cache = refMap.get(builder)!;
+
+  if (!cache.has(name)) {
+    cache.set(name, builder.objectRef(name));
+  }
+
+  return cache.get(name)!;
+}
+
+export function getFindUniqueForRef<Types extends SchemaTypes>(
+  ref: ObjectRef<unknown>,
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+) {
+  if (!findUniqueMap.has(builder)) {
+    findUniqueMap.set(builder, new Map());
+  }
+  const cache = findUniqueMap.get(builder)!;
+
+  if (!cache.has(ref)) {
+    return null;
+  }
+
+  return cache.get(ref)! as (args: unknown, context: Types['Context']) => unknown;
+}
+
+export function setFindUniqueForRef<Types extends SchemaTypes>(
+  ref: ObjectRef<unknown>,
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  findUnique: ((args: any, context: Types['Context']) => unknown) | null,
+) {
+  if (!findUniqueMap.has(builder)) {
+    findUniqueMap.set(builder, new Map());
+  }
+  const cache = findUniqueMap.get(builder)!;
+
+  cache.set(ref, findUnique);
+}
+
+export function getRelation<Types extends SchemaTypes>(
+  name: string,
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  relation: string,
+) {
+  const { client } = builder.options.prisma;
+  // eslint-disable-next-line no-underscore-dangle
+  const dmmf = (client as unknown as { _dmmf: { modelMap: Record<string, Prisma.DMMF.Model> } })
+    ._dmmf;
+  const modelData = dmmf.modelMap[name];
+
+  if (!modelData) {
+    throw new Error(`Model '${name}' not found in DMMF`);
+  }
+
+  const fieldData = modelData.fields.find((field) => field.name === relation);
+
+  if (!fieldData) {
+    throw new Error(`Field '${relation}' not found in model '${name}'`);
+  }
+
+  if (fieldData.kind !== 'object') {
+    throw new Error(`Field ${relation} of model '${name}' is not a relation (${fieldData.kind})`);
+  }
+
+  return fieldData;
+}
+
+export function getRelatedDelegate<Types extends SchemaTypes>(
+  name: string,
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  relation: string,
+) {
+  const fieldData = getRelation(name, builder, relation);
+
+  return fieldData.type;
+}
+
+export function getDelegateFromModel(client: Record<string, unknown>, model: string) {
+  const lowerCase = `${model.slice(0, 1).toLowerCase()}${model.slice(1)}`;
+
+  const delegate = lowerCase in client ? client[lowerCase] : null;
+
+  if (!delegate) {
+    throw new Error(`Unable to find delegate for model ${model}`);
+  }
+
+  return delegate as PrismaDelegate;
+}

package/src/schema-builder.ts

@@ -0,0 +1,124 @@
+import './global-types';
+import { GraphQLResolveInfo } from 'graphql';
+import SchemaBuilder, {
+  brandWithType,
+  FieldNullability,
+  FieldRef,
+  InterfaceRef,
+  OutputType,
+  SchemaTypes,
+  TypeParam,
+} from '@pothos/core';
+import { PrismaObjectFieldBuilder } from './field-builder';
+import PrismaNodeRef from './node-ref';
+import { getDelegateFromModel, getRefFromModel, setFindUniqueForRef } from './refs';
+import { ModelTypes, PrismaDelegate, PrismaNodeOptions } from './types';
+import { queryFromInfo } from './util';
+
+const schemaBuilderProto = SchemaBuilder.prototype as PothosSchemaTypes.SchemaBuilder<SchemaTypes>;
+
+schemaBuilderProto.prismaObject = function prismaObject(type, { fields, findUnique, ...options }) {
+  const ref = getRefFromModel(type, this);
+  const name = options.name ?? type;
+
+  ref.name = name;
+
+  setFindUniqueForRef(ref, this, findUnique);
+
+  this.objectType(ref, {
+    ...(options as {} as PothosSchemaTypes.ObjectFieldOptions<
+      SchemaTypes,
+      unknown,
+      TypeParam<SchemaTypes>,
+      FieldNullability<SchemaTypes>,
+      {},
+      unknown
+    >),
+    extensions: {
+      ...options.extensions,
+      pothosPrismaInclude: options.include,
+    },
+    name,
+    fields: fields ? () => fields(new PrismaObjectFieldBuilder(name, this, type)) : undefined,
+  });
+
+  return ref as never;
+};
+
+schemaBuilderProto.prismaNode = function prismaNode(
+  this: PothosSchemaTypes.SchemaBuilder<SchemaTypes> & {
+    nodeInterfaceRef?: () => InterfaceRef<unknown>;
+  },
+  type: keyof SchemaTypes['PrismaTypes'],
+  {
+    findUnique,
+    name,
+    ...options
+  }: PrismaNodeOptions<SchemaTypes, ModelTypes<PrismaDelegate>, [], never, {}>,
+) {
+  const interfaceRef = this.nodeInterfaceRef?.();
+
+  if (!interfaceRef) {
+    throw new TypeError('builder.prismaNode requires @pothos/plugin-relay to be installed');
+  }
+
+  const typeName = name ?? type;
+  const delegate = getDelegateFromModel(this.options.prisma.client, type);
+  const nodeRef = new PrismaNodeRef(typeName);
+  const extendedOptions = {
+    ...options,
+    interfaces: [interfaceRef, ...(options.interfaces ?? [])],
+    extensions: {
+      ...options.extensions,
+      pothosPrismaInclude: options.include,
+    },
+    isTypeOf: (val: unknown) => nodeRef.hasBrand(val),
+    findUnique: (parent: unknown, context: {}) =>
+      findUnique(options.id.resolve(parent as never, context) as string, context),
+    loadWithoutCache: async (
+      id: string,
+      context: SchemaTypes['Context'],
+      info: GraphQLResolveInfo,
+    ) => {
+      const query = queryFromInfo(context, info, typeName);
+      const record = await delegate.findUnique({
+        ...query,
+        rejectOnNotFound: true,
+        where: findUnique(id, context),
+      } as never);
+
+      brandWithType(record, typeName as OutputType<SchemaTypes>);
+
+      return record;
+    },
+  };
+
+  const ref = this.prismaObject(type, extendedOptions as never);
+
+  this.configStore.onTypeConfig(ref, (nodeConfig) => {
+    this.objectField(ref, 'id', (t) =>
+      (
+        t as unknown as {
+          globalID: (options: Record<string, unknown>) => FieldRef<unknown>;
+        }
+      ).globalID({
+        ...options.id,
+        nullable: false,
+        args: {},
+        resolve: async (
+          parent: never,
+          args: object,
+          context: object,
+          info: GraphQLResolveInfo,
+        ) => ({
+          type: nodeConfig.name,
+          id: await options.id.resolve(parent, context),
+        }),
+      }),
+    );
+  });
+
+  this.configStore.associateRefWithName(nodeRef, typeName);
+
+  return nodeRef;
+} as never;