@pothos/plugin-prisma 3.8.0 → 3.11.0

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;
@@ -564,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);
 
@@ -573,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,
+  };
+}