@pothos/plugin-prisma 0.17.1 → 0.19.0

package/src/schema-builder.ts

@@ -10,21 +10,22 @@ import SchemaBuilder, {
   TypeParam,
 } from '@pothos/core';
 import { PrismaObjectFieldBuilder } from './field-builder';
+import { ModelLoader } from './model-loader';
 import PrismaNodeRef from './node-ref';
-import { getDelegateFromModel, getRefFromModel, setFindUniqueForRef } from './refs';
-import { ModelTypes, PrismaDelegate, PrismaNodeOptions } from './types';
-import { queryFromInfo } from './util';
+import { PrismaModelTypes, PrismaNodeOptions } from './types';
+import { getDelegateFromModel, getRefFromModel } from './util/datamodel';
+import { queryFromInfo } from './util/map-query';
+import { getRelationMap } from './util/relation-map';
 
 const schemaBuilderProto = SchemaBuilder.prototype as PothosSchemaTypes.SchemaBuilder<SchemaTypes>;
 
 schemaBuilderProto.prismaObject = function prismaObject(type, { fields, findUnique, ...options }) {
   const ref = options.variant ? this.objectRef(options.variant) : getRefFromModel(type, this);
   const name = options.variant ?? options.name ?? type;
+  const fieldMap = getRelationMap(this.options.prisma.client).get(type)!;
 
   ref.name = name;
 
-  setFindUniqueForRef(ref, this, findUnique);
-
   this.objectType(ref, {
     ...(options as {} as PothosSchemaTypes.ObjectFieldOptions<
       SchemaTypes,
@@ -37,9 +38,30 @@ schemaBuilderProto.prismaObject = function prismaObject(type, { fields, findUniq
     extensions: {
       ...options.extensions,
       pothosPrismaInclude: options.include,
+      pothosPrismaModel: type,
+      pothosPrismaFieldMap: fieldMap,
+      pothosPrismaSelect: options.select,
+      pothosPrismaLoader: ModelLoader.forRef(
+        type,
+        (findUnique as never) ||
+          (() => {
+            throw new Error(`Missing findUnique for ${ref.name}`);
+          }),
+        this,
+      ),
     },
     name,
-    fields: fields ? () => fields(new PrismaObjectFieldBuilder(name, this, type)) : undefined,
+    fields: fields
+      ? () =>
+          fields(
+            new PrismaObjectFieldBuilder(
+              name,
+              this,
+              type,
+              getRelationMap(this.options.prisma.client).get(type)!,
+            ),
+          )
+      : undefined,
   });
 
   return ref as never;
@@ -55,7 +77,7 @@ schemaBuilderProto.prismaNode = function prismaNode(
     name,
     variant,
     ...options
-  }: PrismaNodeOptions<SchemaTypes, ModelTypes<PrismaDelegate>, [], never, {}>,
+  }: PrismaNodeOptions<SchemaTypes, PrismaModelTypes, [], never, {}, {}>,
 ) {
   const interfaceRef = this.nodeInterfaceRef?.();
 

package/src/types.ts

@@ -10,6 +10,7 @@ import {
   InterfaceParam,
   ListResolveValue,
   MaybePromise,
+  Normalize,
   ObjectRef,
   OutputShape,
   OutputType,
@@ -26,52 +27,17 @@ export interface PrismaDelegate {
   findUnique: (...args: any[]) => Promise<unknown>;
 }
 
-type RelationKeys<T> = {
-  [K in keyof T]: T[K] extends (args: {}) => {
-    then: (cb: (result: unknown) => unknown) => unknown;
-  }
-    ? K
-    : never;
-}[keyof T];
-
-export type ModelTypes<Model extends {}> = Model extends {
-  findUnique: (
-    options: infer UniqueOptions & {
-      where?: infer Where | null | undefined;
-      select?: infer Select | null | undefined;
-    } & (
-        | {
-            include?: infer Include | null | undefined;
-          }
-        | {}
-      ),
-  ) => infer Chain & {
-    then: (cb: (result: infer Shape | null) => unknown) => unknown;
-  };
-}
-  ? PrismaModelTypes & {
-      Shape: Shape;
-      Include: unknown extends Include ? never : Include;
-      Where: Where;
-      Fields: keyof Select;
-      ListRelation: ListRelationFields<Include> & string;
-      Relations: {
-        [RelationName in RelationKeys<Chain>]: Chain[RelationName] extends (args: {}) => {
-          then: (cb: (result: infer Relation) => unknown) => unknown;
-        }
-          ? { Shape: Relation; Types: PrismaModelTypes }
-          : never;
-      };
-    }
-  : never;
+export const prismaModelName = Symbol.for('Pothos.prismaModelName');
 
 export interface PrismaModelTypes {
   Name: string;
   Shape: {};
   Include: unknown;
+  Select: unknown;
   Where: {};
   Fields: string;
   ListRelations: string;
+  RelationName: string;
   Relations: Record<
     string,
     {
@@ -81,52 +47,86 @@ export interface PrismaModelTypes {
   >;
 }
 
-export type ListRelationFields<T> = {
-  [K in keyof T]: T[K] extends infer Option
-    ? Option extends { orderBy?: unknown }
-      ? K
+type ExtractModel<Types extends SchemaTypes, ParentShape> = ParentShape extends {
+  [prismaModelName]?: infer Name;
+}
+  ? Types['PrismaTypes'][Name & keyof Types['PrismaTypes']] extends infer Model
+    ? Model extends PrismaModelTypes
+      ? Model
       : never
-    : never;
-}[keyof T];
+    : never
+  : never;
 
-export type PrismaObjectFieldsShape<
+export type PrismaObjectFieldOptions<
+  Types extends SchemaTypes,
+  ParentShape,
+  Type extends TypeParam<Types>,
+  Nullable extends FieldNullability<Type>,
+  Args extends InputFieldMap,
+  Select,
+  ResolveReturnShape,
+> = PothosSchemaTypes.ObjectFieldOptions<
+  Types,
+  unknown extends Select
+    ? ParentShape
+    : ParentShape & ShapeFromSelection<ExtractModel<Types, ParentShape>, { select: Select }>,
+  Type,
+  Nullable,
+  Args,
+  ResolveReturnShape
+> & {
+  select?: ExtractModel<Types, ParentShape>['Select'] & Select;
+};
+
+type PrismaObjectFieldsShape<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
   NeedsResolve extends boolean,
   Shape extends object,
-> = (t: PrismaObjectFieldBuilder<Types, Model, NeedsResolve, Shape>) => FieldMap;
-
-export type ShapeFromInclude<Model extends PrismaModelTypes, Include> = {} extends Include
-  ? Model['Shape']
-  : {
-      [K in keyof Include &
-        keyof Model['Relations']]: Model['Relations'][K]['Shape'] extends infer RelationShape
-        ? RelationShape extends (infer ItemShape)[]
-          ? (ItemShape &
-              (Include[K] extends { include?: infer NestedInclude & object }
-                ? ShapeFromInclude<Model['Relations'][K]['Types'], NestedInclude>
-                : {}))[]
-          : RelationShape &
-              (
-                | (Include[K] extends { include?: infer NestedInclude & object }
-                    ? ShapeFromInclude<Model['Relations'][K]['Types'], NestedInclude>
-                    : {})
-                | null
-              )
-        : never;
-    };
+  Select,
+> = Model['Select'] extends Select
+  ? (t: PrismaObjectFieldBuilder<Types, Model, NeedsResolve, Shape>) => FieldMap
+  : (t: PrismaSelectionFieldBuilder<Types, Model, Shape>) => FieldMap;
 
-export type ShapeWithInclude<
+type PrismaSelectionFieldBuilder<
+  Types extends SchemaTypes,
   Model extends PrismaModelTypes,
-  Include extends Model['Include'],
-> = Model['Shape'] & ([Include] extends [never] ? {} : ShapeFromInclude<Model, Include>);
+  Shape extends object,
+> = PrismaObjectFieldBuilder<Types, Model, false, Shape>;
+
+interface BaseSelection {
+  include?: unknown;
+  select?: unknown;
+}
+
+export type SelectedKeys<T> = { [K in keyof T]: T[K] extends false ? never : K }[keyof T];
+
+export type ShapeFromSelection<Model extends PrismaModelTypes, Selection> = Normalize<
+  Selection extends BaseSelection
+    ? unknown extends Selection['select']
+      ? Model['Shape'] & RelationShapeFromInclude<Model, Selection['include']>
+      : Pick<Model['Shape'], SelectedKeys<Selection['select']>> &
+          RelationShapeFromInclude<Model, Selection['select']>
+    : Model['Shape']
+>;
+
+type RelationShapeFromInclude<Model extends PrismaModelTypes, Include> = Normalize<{
+  [K in SelectedKeys<Include> as K extends Model['RelationName']
+    ? K
+    : never]: K extends keyof Model['Relations']
+    ? Model['Relations'][K]['Shape'] extends unknown[]
+      ? ShapeFromSelection<Model['Relations'][K]['Types'], Include[K]>[]
+      : ShapeFromSelection<Model['Relations'][K]['Types'], Include[K]>
+    : unknown;
+}>;
 
 export type PrismaObjectTypeOptions<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
   Interfaces extends InterfaceParam<Types>[],
   FindUnique,
-  Include extends Model['Include'],
+  Include,
+  Select,
   Shape extends object,
 > = NameOrVariant &
   Omit<
@@ -134,13 +134,28 @@ export type PrismaObjectTypeOptions<
     | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
     'fields'
   > & {
-    include?: Include;
-    fields?: PrismaObjectFieldsShape<Types, Model, FindUnique extends null ? true : false, Shape>;
-    findUnique: FindUnique &
-      (((parent: Shape, context: Types['Context']) => Model['Where']) | null);
-  };
+    fields?: PrismaObjectFieldsShape<
+      Types,
+      Model,
+      FindUnique extends null ? true : false,
+      Shape & (FindUnique extends null ? {} : { [prismaModelName]?: Model['Name'] }),
+      Select
+    >;
+  } & (
+    | {
+        include?: Include & Model['Include'];
+        select?: never;
+        findUnique: FindUnique &
+          (((parent: Shape, context: Types['Context']) => Model['Where']) | null);
+      }
+    | {
+        select: Model['Select'] & Select;
+        include?: never;
+        findUnique: (parent: Shape, context: Types['Context']) => Model['Where'];
+      }
+  );
 
-export type NameOrVariant =
+type NameOrVariant =
   | {
       name?: never;
       variant?: string;
@@ -154,7 +169,8 @@ export type PrismaNodeOptions<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
   Interfaces extends InterfaceParam<Types>[],
-  Include extends Model['Include'],
+  Include,
+  Select,
   Shape extends object,
 > = NameOrVariant &
   Omit<
@@ -162,7 +178,6 @@ export type PrismaNodeOptions<
     | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>,
     'fields' | 'isTypeOf'
   > & {
-    include?: Include;
     id: Omit<
       FieldOptionsFromKind<
         Types,
@@ -178,11 +193,26 @@ export type PrismaNodeOptions<
     > & {
       resolve: (parent: Shape, context: Types['Context']) => MaybePromise<OutputShape<Types, 'ID'>>;
     };
-    fields?: PrismaObjectFieldsShape<Types, Model, false, Shape>;
+    fields?: PrismaObjectFieldsShape<
+      Types,
+      Model,
+      false,
+      Shape & { [prismaModelName]?: Model['Name'] },
+      Select
+    >;
     findUnique: (id: string, context: Types['Context']) => Model['Where'];
-  };
+  } & (
+    | {
+        include?: Include & Model['Include'];
+        select?: never;
+      }
+    | {
+        select: Model['Select'] & Select;
+        include?: never;
+      }
+  );
 
-export type QueryForField<
+type QueryForField<
   Types extends SchemaTypes,
   Args extends InputFieldMap,
   Include,
@@ -195,18 +225,19 @@ export type QueryForField<
         ) => Omit<Include, 'include' | 'select'>)
   : never;
 
-export type IncludeFromRelation<
+type QueryFromRelation<
   Model extends PrismaModelTypes,
   Field extends keyof Model['Include'],
 > = Model['Include'][Field] extends infer Include
   ? Include extends {
-      include?: infer T;
+      include?: infer I;
+      select?: infer S;
     }
-    ? NonNullable<T>
+    ? { include?: NonNullable<I>; select?: NonNullable<S> }
     : never
   : never;
 
-export type CursorFromRelation<
+type CursorFromRelation<
   Model extends PrismaModelTypes,
   Field extends Model['ListRelations'],
 > = Field extends keyof Model['Include']
@@ -217,7 +248,7 @@ export type CursorFromRelation<
     : never
   : never;
 
-export type RefForRelation<
+type RefForRelation<
   Model extends PrismaModelTypes,
   Field extends keyof Model['Relations'],
 > = Model['Relations'][Field] extends unknown[]
@@ -247,7 +278,7 @@ export type RelatedFieldOptions<
   (NeedsResolve extends false
     ? {
         resolve?: (
-          query: { include?: IncludeFromRelation<Model, Field & keyof Model['Include']> },
+          query: QueryFromRelation<Model, Field & keyof Model['Include']>,
           parent: Shape,
           args: InputShapeFromFields<Args>,
           context: Types['Context'],
@@ -258,7 +289,7 @@ export type RelatedFieldOptions<
       }
     : {
         resolve: (
-          query: { include?: IncludeFromRelation<Model, Field & keyof Model['Include']> },
+          query: QueryFromRelation<Model, Field & keyof Model['Include']>,
           parent: Shape,
           args: InputShapeFromFields<Args>,
           context: Types['Context'],
@@ -472,31 +503,36 @@ export type RelatedConnectionOptions<
 
 export type WithBrand<T> = T & { [typeBrandKey]: string };
 
-export type IncludeMap = Record<string, Record<string, unknown> | boolean>;
+export type IncludeMap = Record<string, SelectionMap | boolean>;
 
-export interface IncludeCounts {
-  current: Record<string, boolean>;
-  parent: Record<string, boolean>;
+export interface SelectionMap {
+  select?: Record<string, SelectionMap | boolean>;
+  include?: Record<string, SelectionMap | boolean>;
+  where?: {};
 }
 
+export type FieldSelection =
+  | Record<string, SelectionMap | boolean>
+  | ((
+      args: object,
+      context: object,
+      query: (
+        selection: SelectionMap | boolean | ((args: object, context: object) => SelectionMap),
+      ) => SelectionMap | boolean,
+    ) => SelectionMap);
+
 export type LoaderMappings = Record<
   string,
   {
     field: string;
-    alias?: string;
     mappings: LoaderMappings;
     indirectPath: string[];
-  }[]
+  }
 >;
 
-export interface SubFieldInclude {
-  type?: string;
-  name: string;
-}
-
-export interface IndirectLoadMap {
-  subFields: SubFieldInclude[];
-  path: string[];
+export interface IndirectInclude {
+  getType: () => string;
+  path: { type?: string; name: string }[];
 }
 
 export type ShapeFromConnection<T> = T extends { shape: unknown } ? T['shape'] : never;

package/src/{cursors.ts → util/cursors.ts}

@@ -4,22 +4,34 @@ import { MaybePromise } from '@pothos/core';
 const DEFAULT_MAX_SIZE = 100;
 const DEFAULT_SIZE = 20;
 
-function formatCursor(value: unknown): string {
+export function formatCursorChunk(value: unknown) {
   if (value instanceof Date) {
-    return Buffer.from(`GPC:D:${String(Number(value))}`).toString('base64');
+    return `D:${String(Number(value))}`;
   }
 
   switch (typeof value) {
     case 'number':
-      return Buffer.from(`GPC:N:${value}`).toString('base64');
+      return `N:${value}`;
     case 'string':
-      return Buffer.from(`GPC:S:${value}`).toString('base64');
+      return `S:${value}`;
     default:
       throw new TypeError(`Unsupported cursor type ${typeof value}`);
   }
 }
 
-function parseCursor(cursor: unknown) {
+export function formatCursor(fields: string | string[]) {
+  return (value: Record<string, unknown>) => {
+    if (typeof fields === 'string') {
+      return Buffer.from(`GPC:${formatCursorChunk(value[fields])}`).toString('base64');
+    }
+
+    return Buffer.from(`GPC:J:${JSON.stringify(fields.map((name) => value[name]))}`).toString(
+      'base64',
+    );
+  };
+}
+
+export function parseRawCursor(cursor: unknown) {
   if (typeof cursor !== 'string') {
     throw new TypeError('Cursor must be a string');
   }
@@ -35,6 +47,8 @@ function parseCursor(cursor: unknown) {
         return Number.parseInt(value, 10);
       case 'D':
         return new Date(Number.parseInt(value, 10));
+      case 'J':
+        return JSON.parse(value) as unknown;
       default:
         throw new TypeError(`Invalid cursor type ${type}`);
     }
@@ -43,11 +57,29 @@ function parseCursor(cursor: unknown) {
   }
 }
 
-interface PrismaCursorConnectionQueryOptions {
+export function parseCompositeCursor(fields: string[]) {
+  return (cursor: string) => {
+    const parsed = parseRawCursor(cursor) as unknown[];
+
+    if (!Array.isArray(parsed)) {
+      throw new TypeError(`Expected compound cursor to contain an array, but got ${parsed}`);
+    }
+
+    const record: Record<string, unknown> = {};
+
+    fields.forEach((field, i) => {
+      record[field] = parsed[i];
+    });
+
+    return record;
+  };
+}
+
+export interface PrismaCursorConnectionQueryOptions {
   args: PothosSchemaTypes.DefaultConnectionArguments;
   defaultSize?: number;
   maxSize?: number;
-  column: string;
+  parseCursor: (cursor: string) => Record<string, unknown>;
 }
 
 interface ResolvePrismaCursorConnectionOptions extends PrismaCursorConnectionQueryOptions {
@@ -59,7 +91,7 @@ export function prismaCursorConnectionQuery({
   args: { before, after, first, last },
   maxSize = DEFAULT_MAX_SIZE,
   defaultSize = DEFAULT_SIZE,
-  column,
+  parseCursor,
 }: PrismaCursorConnectionQueryOptions) {
   if (first != null && first < 0) {
     throw new TypeError('Argument "first" must be a non-negative integer');
@@ -96,9 +128,7 @@ export function prismaCursorConnectionQuery({
   return cursor == null
     ? { take, skip: 0 }
     : {
-        cursor: {
-          [column]: parseCursor(cursor),
-        },
+        cursor: parseCursor(cursor),
         take,
         skip: 1,
       };
@@ -108,7 +138,7 @@ export function wrapConnectionResult<T extends {}>(
   results: T[],
   args: PothosSchemaTypes.DefaultConnectionArguments,
   take: number,
-  column: string,
+  cursor: (node: T) => string,
   totalCount?: number,
 ) {
   const gotFullResults = results.length === Math.abs(take);
@@ -122,7 +152,7 @@ export function wrapConnectionResult<T extends {}>(
     value == null
       ? null
       : {
-          cursor: formatCursor((value as Record<string, string>)[column]),
+          cursor: cursor(value),
           node: value,
         },
   );
@@ -141,6 +171,7 @@ export function wrapConnectionResult<T extends {}>(
 
 export async function resolvePrismaCursorConnection<T extends {}>(
   options: ResolvePrismaCursorConnectionOptions,
+  cursor: (node: T) => string,
   resolve: (query: { include?: {}; cursor?: {}; take: number; skip: number }) => MaybePromise<T[]>,
 ) {
   const query = prismaCursorConnectionQuery(options);
@@ -149,11 +180,5 @@ export async function resolvePrismaCursorConnection<T extends {}>(
     ...query,
   });
 
-  return wrapConnectionResult(
-    results,
-    options.args,
-    query.take,
-    options.column,
-    options.totalCount,
-  );
+  return wrapConnectionResult(results, options.args, query.take, cursor, options.totalCount);
 }

package/src/{refs.ts → util/datamodel.ts}

@@ -1,8 +1,8 @@
 import { ObjectRef, SchemaTypes } from '@pothos/core';
-import { Prisma } from '../tests/client';
-import { PrismaObjectRef } from './object-ref';
-import { PrismaDelegate } from './types';
-import { PrismaModelTypes } from '.';
+import { Prisma } from '../../tests/client';
+import { PrismaObjectRef } from '../object-ref';
+import { PrismaDelegate, PrismaModelTypes } from '../types';
+import { formatCursor, parseCompositeCursor, parseRawCursor } from './cursors';
 
 export const refMap = new WeakMap<object, Map<string, PrismaObjectRef<PrismaModelTypes>>>();
 export const findUniqueMap = new WeakMap<
@@ -31,40 +31,29 @@ export function getRefFromModel<Types extends SchemaTypes>(
   return cache.get(name)!;
 }
 
-export function getFindUniqueForRef<Types extends SchemaTypes>(
-  ref: ObjectRef<unknown>,
+export function getRelation<Types extends SchemaTypes>(
+  name: string,
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  relation: string,
 ) {
-  if (!findUniqueMap.has(builder)) {
-    findUniqueMap.set(builder, new Map());
-  }
-  const cache = findUniqueMap.get(builder)!;
+  const modelData = getModel(name, builder);
 
-  if (!cache.has(ref)) {
-    return null;
-  }
+  const fieldData = modelData.fields.find((field) => field.name === relation);
 
-  return cache.get(ref)! as (args: unknown, context: Types['Context']) => unknown;
-}
+  if (!fieldData) {
+    throw new Error(`Field '${relation}' not found in model '${name}'`);
+  }
 
-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());
+  if (fieldData.kind !== 'object') {
+    throw new Error(`Field ${relation} of model '${name}' is not a relation (${fieldData.kind})`);
   }
-  const cache = findUniqueMap.get(builder)!;
 
-  cache.set(ref, findUnique);
+  return fieldData;
 }
 
-export function getRelation<Types extends SchemaTypes>(
+export function getModel<Types extends SchemaTypes>(
   name: string,
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
-  relation: string,
 ) {
   const { client } = builder.options.prisma;
   // eslint-disable-next-line no-underscore-dangle
@@ -76,27 +65,34 @@ export function getRelation<Types extends SchemaTypes>(
     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}'`);
-  }
+  return modelData;
+}
 
-  if (fieldData.kind !== 'object') {
-    throw new Error(`Field ${relation} of model '${name}' is not a relation (${fieldData.kind})`);
-  }
+export function getCursorFormatter<Types extends SchemaTypes>(
+  name: string,
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  cursor: string,
+) {
+  const modelData = getModel(name, builder);
+  const primaryKey = modelData.primaryKey?.name ?? modelData.primaryKey?.fields.join('_');
 
-  return fieldData;
+  return formatCursor(cursor === primaryKey ? modelData.primaryKey!.fields : cursor);
 }
 
-export function getRelatedDelegate<Types extends SchemaTypes>(
+export function getCursorParser<Types extends SchemaTypes>(
   name: string,
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
-  relation: string,
+  cursor: string,
 ) {
-  const fieldData = getRelation(name, builder, relation);
+  const modelData = getModel(name, builder);
+  const primaryKey = modelData.primaryKey?.name ?? modelData.primaryKey?.fields.join('_');
+
+  const parser =
+    cursor === primaryKey ? parseCompositeCursor(modelData.primaryKey!.fields) : parseRawCursor;
 
-  return fieldData.type;
+  return (rawCursor: string) => ({
+    [cursor]: parser(rawCursor),
+  });
 }
 
 export function getDelegateFromModel(client: Record<string, unknown>, model: string) {