@pothos/plugin-prisma 3.7.0 → 3.10.0

package/src/prisma-field-builder.ts

@@ -5,6 +5,7 @@ import {
   FieldKind,
   FieldRef,
   InputFieldMap,
+  isThenable,
   MaybePromise,
   NormalizeArgs,
   ObjectRef,
@@ -136,18 +137,29 @@ export class PrismaObjectFieldBuilder<
     const relationSelect = (
       args: object,
       context: object,
-      nestedQuery: (query: unknown) => unknown,
+      nestedQuery: (query: unknown, path: unknown) => unknown,
     ) => ({
       select: {
-        [name]: nestedQuery({
-          ...((typeof query === 'function' ? query(args, context) : query) as {}),
-          ...prismaCursorConnectionQuery({
-            parseCursor,
-            maxSize,
-            defaultSize,
-            args,
-          }),
-        }),
+        [name]: nestedQuery(
+          {
+            ...((typeof query === 'function' ? query(args, context) : query) as {}),
+            ...prismaCursorConnectionQuery({
+              parseCursor,
+              maxSize,
+              defaultSize,
+              args,
+            }),
+          },
+          {
+            getType: () => {
+              if (!typeName) {
+                typeName = this.builder.configStore.getTypeConfig(ref).name;
+              }
+              return typeName;
+            },
+            path: [{ name: 'edges' }, { name: 'node' }],
+          },
+        ),
       },
     });
 
@@ -215,18 +227,6 @@ export class PrismaObjectFieldBuilder<
               ...(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,
     );
@@ -327,19 +327,26 @@ export class PrismaObjectFieldBuilder<
     }) as FieldRef<number, 'Object'>;
   }
 
-  variant<Variant extends Model['Name'] | PrismaObjectRef<Model>>(
+  variant<
+    Variant extends Model['Name'] | PrismaObjectRef<Model>,
+    Args extends InputFieldMap,
+    Nullable,
+  >(
     ...allArgs: NormalizeArgs<
       [
         variant: Variant,
         options?: VariantFieldOptions<
           Types,
           Model,
-          Variant extends PrismaObjectRef<Model> ? Variant : PrismaObjectRef<Model>
+          Variant extends PrismaObjectRef<Model> ? Variant : PrismaObjectRef<Model>,
+          Args,
+          Nullable,
+          Shape
         >,
       ]
     >
   ): FieldRef<Model['Shape'], 'Object'> {
-    const [variant, options = {} as never] = allArgs;
+    const [variant, { isNull, nullable, ...options } = {} as never] = allArgs;
     const ref: PrismaObjectRef<PrismaModelTypes> =
       typeof variant === 'string' ? getRefFromModel(variant, this.builder) : variant;
 
@@ -353,7 +360,19 @@ export class PrismaObjectFieldBuilder<
         ...options?.extensions,
         pothosPrismaSelect: selfSelect,
       },
-      resolve: (parent, args, context, info) => parent as never,
+      nullable: nullable ?? !!isNull,
+      resolve: isNull
+        ? (parent, args, context, info) => {
+            const parentIsNull = isNull(parent, args as never, context, info);
+            if (parentIsNull) {
+              if (isThenable(parentIsNull)) {
+                return parentIsNull.then((resolved) => (resolved ? null : parent)) as never;
+              }
+              return null as never;
+            }
+            return parent as never;
+          }
+        : (parent) => parent as never,
     }) as FieldRef<Model['Shape'], 'Object'>;
   }
 

package/src/schema-builder.ts

@@ -11,6 +11,7 @@ import { PrismaObjectFieldBuilder } from './field-builder';
 import { ModelLoader } from './model-loader';
 import PrismaNodeRef from './node-ref';
 import { PrismaModelTypes, PrismaNodeOptions } from './types';
+import { getDefaultIDParser, getDefaultIDSerializer } from './util/cursors';
 import { getDelegateFromModel, getRefFromModel } from './util/datamodel';
 import { getClient, getDMMF } from './util/get-client';
 import { queryFromInfo } from './util/map-query';
@@ -18,10 +19,14 @@ import { getRelationMap } from './util/relation-map';
 
 const schemaBuilderProto = SchemaBuilder.prototype as PothosSchemaTypes.SchemaBuilder<SchemaTypes>;
 
-schemaBuilderProto.prismaObject = function prismaObject(type, { fields, findUnique, ...options }) {
+schemaBuilderProto.prismaObject = function prismaObject(
+  type,
+  { fields, findUnique, select, include, ...options },
+) {
   const ref = options.variant ? this.objectRef(options.variant) : getRefFromModel(type, this);
   const name = options.variant ?? options.name ?? type;
   const fieldMap = getRelationMap(getDMMF(this)).get(type)!;
+  const idSelection = ModelLoader.getDefaultIDSelection(ref, type, this);
 
   ref.name = name;
 
@@ -29,18 +34,11 @@ schemaBuilderProto.prismaObject = function prismaObject(type, { fields, findUniq
     ...(options as {}),
     extensions: {
       ...options.extensions,
-      pothosPrismaInclude: options.include,
+      pothosPrismaInclude: include,
       pothosPrismaModel: type,
       pothosPrismaFieldMap: fieldMap,
-      pothosPrismaSelect: options.select,
-      pothosPrismaLoader: ModelLoader.forRef(
-        type,
-        (findUnique as never) ||
-          (() => {
-            throw new Error(`Missing findUnique for ${ref.name}`);
-          }),
-        this,
-      ),
+      pothosPrismaSelect: select && { ...idSelection, ...(select as {}) },
+      pothosPrismaLoader: ModelLoader.forRef(ref, type, findUnique as never, this),
     },
     name,
     fields: fields
@@ -65,26 +63,33 @@ schemaBuilderProto.prismaNode = function prismaNode(
   },
   type: keyof SchemaTypes['PrismaTypes'],
   {
-    findUnique,
+    id: { field, resolve: rawResolve, ...idOptions },
+    findUnique: rawFindUnique,
     name,
     variant,
     ...options
-  }: PrismaNodeOptions<SchemaTypes, PrismaModelTypes, [], never, {}, {}>,
+  }: PrismaNodeOptions<SchemaTypes, PrismaModelTypes, [], never, {}, {}, undefined>,
 ) {
+  const fieldName = field as unknown as string;
   const interfaceRef = this.nodeInterfaceRef?.();
+  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 findUnique = rawFindUnique
+    ? (parent: unknown, context: {}) =>
+        rawFindUnique(resolve(parent as never, context) as string, context)
+    : ModelLoader.getFindUniqueForField(nodeRef, type, fieldName, this);
 
   if (!interfaceRef) {
     throw new TypeError('builder.prismaNode requires @pothos/plugin-relay to be installed');
   }
 
-  const typeName = variant ?? name ?? type;
-  const nodeRef = new PrismaNodeRef(typeName);
   const extendedOptions = {
     ...options,
     variant,
     interfaces: [interfaceRef],
-    findUnique: (parent: unknown, context: {}) =>
-      findUnique(options.id.resolve(parent as never, context) as string, context),
+    findUnique,
     loadWithoutCache: async (
       id: string,
       context: SchemaTypes['Context'],
@@ -95,7 +100,7 @@ schemaBuilderProto.prismaNode = function prismaNode(
       const record = await delegate.findUnique({
         ...query,
         rejectOnNotFound: true,
-        where: findUnique(id, context),
+        where: rawFindUnique ? rawFindUnique(id, context) : { [fieldName]: idParser!(id) },
       } as never);
 
       brandWithType(record, typeName as OutputType<SchemaTypes>);
@@ -117,7 +122,7 @@ schemaBuilderProto.prismaNode = function prismaNode(
           globalID: (options: Record<string, unknown>) => FieldRef<unknown>;
         }
       ).globalID({
-        ...options.id,
+        ...idOptions,
         nullable: false,
         args: {},
         resolve: async (
@@ -127,7 +132,7 @@ schemaBuilderProto.prismaNode = function prismaNode(
           info: GraphQLResolveInfo,
         ) => ({
           type: nodeConfig.name,
-          id: await options.id.resolve(parent, context),
+          id: await resolve(parent, context),
         }),
       }),
     );

package/src/types.ts

@@ -89,6 +89,10 @@ export type PrismaObjectFieldOptions<
       | ((
           args: InputShapeFromFields<Args>,
           ctx: Types['Context'],
+          nestedSelection: <Selection extends boolean | {}>(
+            selection?: Selection,
+            path?: string[],
+          ) => Selection,
         ) => ExtractModel<Types, ParentShape>['Select'])
     );
 };
@@ -169,13 +173,13 @@ export type PrismaObjectTypeOptions<
     | {
         include?: Include & Model['Include'];
         select?: never;
-        findUnique: FindUnique &
+        findUnique?: FindUnique &
           (((parent: Shape, context: Types['Context']) => Model['Where']) | null);
       }
     | {
         select: Model['Select'] & Select;
         include?: never;
-        findUnique: (parent: Shape, context: Types['Context']) => Model['Where'];
+        findUnique?: (parent: Shape, context: Types['Context']) => Model['Where'];
       }
   );
 
@@ -196,6 +200,7 @@ export type PrismaNodeOptions<
   Include,
   Select,
   Shape extends object,
+  UniqueField,
 > = NameOrVariant &
   Omit<
     | PothosSchemaTypes.ObjectTypeOptions<Types, Shape>
@@ -214,9 +219,20 @@ export type PrismaNodeOptions<
         MaybePromise<OutputShape<Types, 'ID'>>
       >,
       'args' | 'nullable' | 'resolve' | 'type'
-    > & {
-      resolve: (parent: Shape, context: Types['Context']) => MaybePromise<OutputShape<Types, 'ID'>>;
-    };
+    > &
+      (
+        | {
+            field?: never;
+            resolve: (
+              parent: Shape,
+              context: Types['Context'],
+            ) => MaybePromise<OutputShape<Types, 'ID'>>;
+          }
+        | {
+            resolve?: never;
+            field: UniqueField extends keyof Model['Where'] ? UniqueField : keyof Model['Where'];
+          }
+      );
     fields?: PrismaObjectFieldsShape<
       Types,
       Model,
@@ -224,8 +240,14 @@ export type PrismaNodeOptions<
       Shape & { [prismaModelName]?: Model['Name'] },
       Select
     >;
-    findUnique: (id: string, context: Types['Context']) => Model['Where'];
-  } & (
+  } & (UniqueField extends string
+    ? {
+        findUnique?: (id: string, context: Types['Context']) => Model['Where'];
+      }
+    : {
+        findUnique: (id: string, context: Types['Context']) => Model['Where'];
+      }) &
+  (
     | {
         include?: Include & Model['Include'];
         select?: never;
@@ -330,10 +352,28 @@ export type VariantFieldOptions<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
   Variant extends PrismaObjectRef<Model>,
+  Args extends InputFieldMap,
+  isNull,
+  Shape,
 > = Omit<
-  PothosSchemaTypes.ObjectFieldOptions<Types, Model['Shape'], Variant, false, {}, Model['Shape']>,
+  PothosSchemaTypes.ObjectFieldOptions<
+    Types,
+    Shape,
+    Variant,
+    unknown extends isNull ? false : true,
+    Args,
+    Model['Shape']
+  >,
   'resolve' | 'type'
->;
+> & {
+  isNull?: isNull &
+    ((
+      parent: Shape,
+      args: InputShapeFromFields<Args>,
+      context: Types['Context'],
+      info: GraphQLResolveInfo,
+    ) => MaybePromise<boolean>);
+};
 
 export type RelationCountOptions<
   Types extends SchemaTypes,
@@ -546,8 +586,9 @@ export type FieldSelection =
   | ((
       args: object,
       context: object,
-      query: (
+      mergeNestedSelection: (
         selection: SelectionMap | boolean | ((args: object, context: object) => SelectionMap),
+        path?: string[] | IndirectInclude,
       ) => SelectionMap | boolean,
     ) => SelectionMap);
 
@@ -555,6 +596,7 @@ export type LoaderMappings = Record<
   string,
   {
     field: string;
+    type: string;
     mappings: LoaderMappings;
     indirectPath: string[];
   }

package/src/util/cursors.ts

@@ -1,5 +1,7 @@
 /* eslint-disable no-nested-ternary */
-import { MaybePromise } from '@pothos/core';
+import { MaybePromise, SchemaTypes } from '@pothos/core';
+import { getModel } from './datamodel';
+import { DMMFField } from './get-client';
 
 const DEFAULT_MAX_SIZE = 100;
 const DEFAULT_SIZE = 20;
@@ -57,6 +59,120 @@ export function parseRawCursor(cursor: unknown) {
   }
 }
 
+export function parseID(id: string, dataType: string): unknown {
+  if (!id) {
+    return id;
+  }
+
+  switch (dataType) {
+    case 'String':
+      return id;
+    case 'Int':
+      return Number.parseInt(id, 10);
+    case 'BigInt':
+      // eslint-disable-next-line node/no-unsupported-features/es-builtins
+      return BigInt(id);
+    case 'Boolean':
+      return id !== 'false';
+    case 'Float':
+    case 'Decimal':
+      return Number.parseFloat(id);
+    case 'DateTime':
+      return new Date(id);
+    case 'Json':
+      return JSON.parse(id) as unknown;
+    case 'Byte':
+      return Buffer.from(id, 'base64');
+    default:
+      return id;
+  }
+}
+
+export function getDefaultIDSerializer<Types extends SchemaTypes>(
+  modelName: string,
+  fieldName: string,
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+): (parent: Record<string, unknown>) => unknown {
+  const model = getModel(modelName, builder);
+
+  const field = model.fields.find((f) => f.name === fieldName);
+
+  if (field) {
+    return (parent) => serializeID(parent[fieldName], field.type);
+  }
+
+  if ((model.primaryKey?.name ?? model.primaryKey?.fields.join('_')) === fieldName) {
+    const fields = model.primaryKey!.fields.map((n) => model.fields.find((f) => f.name === n)!);
+    return (parent) => JSON.stringify(fields.map((f) => serializeID(parent[f.name], f.kind)));
+  }
+
+  const index = model.uniqueIndexes.find((idx) => (idx.name ?? idx.fields.join('_')) === fieldName);
+
+  if (index) {
+    const fields = index.fields.map((n) => model.fields.find((f) => f.name === n)!);
+    return (parent) => JSON.stringify(fields.map((f) => serializeID(parent[f.name], f.kind)));
+  }
+
+  throw new Error(`Unable to find ${fieldName} for model ${modelName}`);
+}
+
+export function getDefaultIDParser<Types extends SchemaTypes>(
+  modelName: string,
+  fieldName: string,
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+): (id: string) => unknown {
+  if (!fieldName) {
+    throw new Error('Missing field name');
+  }
+  const model = getModel(modelName, builder);
+
+  const field = model.fields.find((f) => f.name === fieldName);
+
+  if (field) {
+    return (id) => parseID(id, field.type);
+  }
+
+  const index = model.uniqueIndexes.find((idx) => (idx.name ?? idx.fields.join('_')) === fieldName);
+
+  let fields: DMMFField[] | undefined;
+  if ((model.primaryKey?.name ?? model.primaryKey?.fields.join('_')) === fieldName) {
+    fields = model.primaryKey!.fields.map((n) => model.fields.find((f) => f.name === n)!);
+  } else if (index) {
+    fields = index.fields.map((n) => model.fields.find((f) => f.name === n)!);
+  }
+
+  if (!fields) {
+    throw new Error(`Unable to find ${fieldName} for model ${modelName}`);
+  }
+
+  return (id) => {
+    const parts = JSON.parse(id) as unknown;
+
+    if (!Array.isArray(parts)) {
+      throw new TypeError(`Invalid id received for ${fieldName} of ${modelName}`);
+    }
+
+    const result: Record<string, unknown> = {};
+
+    for (let i = 0; i < fields!.length; i += 1) {
+      result[fields![i].name] = parseID(parts[i] as string, fields![i].type);
+    }
+
+    return result;
+  };
+}
+
+export function serializeID(id: unknown, dataType: string) {
+  switch (dataType) {
+    case 'Json':
+      return JSON.stringify(id);
+    case 'Byte':
+      return (id as Buffer).toString('base64');
+    default:
+      return String(id);
+  }
+}
+
 export function parseCompositeCursor(fields: string[]) {
   return (cursor: string) => {
     const parsed = parseRawCursor(cursor) as unknown[];

package/src/util/get-client.ts

@@ -20,7 +20,8 @@ interface DMMF {
       name: string;
       fields: DMMFField[];
       fieldMap?: Record<string, DMMFField>;
-      primaryKey: { name: string; fields: string[] } | null;
+      primaryKey: { name: string | null; fields: string[] } | null;
+      uniqueIndexes: { name: string | null; fields: string[] }[];
     }
   >;
 }

package/src/util/loader-map.ts

@@ -1,7 +1,6 @@
-import { GraphQLNamedType, GraphQLResolveInfo } from 'graphql';
+import { GraphQLResolveInfo } from 'graphql';
 import { createContextCache } from '@pothos/core';
 import { LoaderMappings } from '../types';
-import { getIndirectType } from './map-query';
 
 const cache = createContextCache((ctx) => new Map<string, LoaderMappings>());
 
@@ -23,18 +22,13 @@ export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath
   return `${type}@${key}`;
 }
 
-export function setLoaderMappings(
-  ctx: object,
-  info: GraphQLResolveInfo,
-  value: LoaderMappings,
-  type: GraphQLNamedType,
-) {
+export function setLoaderMappings(ctx: object, info: GraphQLResolveInfo, value: LoaderMappings) {
   Object.keys(value).forEach((field) => {
     const map = cache(ctx);
 
     const mapping = value[field];
     const subPath = [...mapping.indirectPath, field];
-    const key = cacheKey(getIndirectType(type, info).name, info.path, subPath);
+    const key = cacheKey(mapping.type, info.path, subPath);
 
     map.set(key, mapping.mappings);
   });

package/src/util/map-query.ts

@@ -4,6 +4,7 @@ import {
   FieldNode,
   FragmentDefinitionNode,
   getNamedType,
+  GraphQLField,
   GraphQLNamedType,
   GraphQLObjectType,
   GraphQLResolveInfo,
@@ -232,16 +233,45 @@ function addFieldSelection(
       unknown
     >;
 
-    fieldSelectionMap = fieldSelect(args, context, (rawQuery) => {
+    fieldSelectionMap = fieldSelect(args, context, (rawQuery, indirectInclude) => {
       const returnType = getNamedType(field.type);
       const query = typeof rawQuery === 'function' ? rawQuery(args, context) : rawQuery;
 
-      const fieldState = createStateForType(returnType, info, state);
+      const normalizedIndirectInclude = Array.isArray(indirectInclude)
+        ? normalizeInclude(indirectInclude, getIndirectType(returnType, info))
+        : indirectInclude;
+
+      const fieldState = createStateForType(
+        getIndirectType(
+          normalizedIndirectInclude
+            ? info.schema.getType(normalizedIndirectInclude.getType())!
+            : returnType,
+          info,
+        ),
+        info,
+        state,
+      );
 
       if (typeof query === 'object' && Object.keys(query).length > 0) {
         mergeSelection(fieldState, { select: {}, ...query });
       }
 
+      if (normalizedIndirectInclude && normalizedIndirectInclude.path.length > 0) {
+        resolveIndirectInclude(
+          returnType,
+          info,
+          selection,
+          [
+            ...((returnType.extensions?.pothosPrismaIndirectInclude as { path: [] })?.path ?? []),
+            ...normalizedIndirectInclude.path,
+          ],
+          [],
+          (resolvedType, resolvedField, path) => {
+            addTypeSelectionsForField(resolvedType, context, info, fieldState, resolvedField, path);
+          },
+        );
+      }
+
       addTypeSelectionsForField(returnType, context, info, fieldState, selection, []);
 
       // eslint-disable-next-line prefer-destructuring
@@ -257,6 +287,7 @@ function addFieldSelection(
     mergeSelection(state, fieldSelectionMap);
     state.mappings[selection.alias?.value ?? selection.name.value] = {
       field: selection.name.value,
+      type: type.name,
       mappings,
       indirectPath,
     };
@@ -268,6 +299,7 @@ function addFieldSelection(
     mergeSelection(state.parent, { select: fieldParentSelect });
     state.mappings[selection.alias?.value ?? selection.name.value] = {
       field: selection.name.value,
+      type: type.name,
       mappings,
       indirectPath,
     };
@@ -280,7 +312,7 @@ export function queryFromInfo(context: object, info: GraphQLResolveInfo, typeNam
 
   addTypeSelectionsForField(type, context, info, state, info.fieldNodes[0], []);
 
-  setLoaderMappings(context, info, state.mappings, type);
+  setLoaderMappings(context, info, state.mappings);
 
   return selectionToQuery(state);
 }
@@ -330,3 +362,34 @@ export function getIndirectType(type: GraphQLNamedType, info: GraphQLResolveInfo
 
   return targetType;
 }
+
+function normalizeInclude(path: string[], type: GraphQLNamedType) {
+  let currentType = type;
+
+  const normalized: { name: string; type: string }[] = [];
+
+  if (!isObjectType(currentType)) {
+    throw new Error(`Expected ${currentType} to be an Object type`);
+  }
+
+  for (const fieldName of path) {
+    const field: GraphQLField<unknown, unknown> = currentType.getFields()[fieldName];
+
+    if (!field) {
+      throw new Error(`Expected ${currentType} to have a field ${fieldName}`);
+    }
+
+    currentType = getNamedType(field.type);
+
+    if (!isObjectType(currentType)) {
+      throw new Error(`Expected ${currentType} to be an Object type`);
+    }
+
+    normalized.push({ name: fieldName, type: currentType.name });
+  }
+
+  return {
+    getType: () => (normalized.length > 0 ? normalized[normalized.length - 1].type : type.name),
+    path: normalized,
+  };
+}