@pothos/plugin-prisma 0.15.0

package/src/field-builder.ts

@@ -0,0 +1,115 @@
+import { GraphQLResolveInfo } from 'graphql';
+import {
+  FieldKind,
+  FieldRef,
+  InputFieldMap,
+  ObjectRef,
+  RootFieldBuilder,
+  SchemaTypes,
+  TypeParam,
+} from '@pothos/core';
+import { resolvePrismaCursorConnection } from './cursors';
+import { getRefFromModel } from './refs';
+import { PrismaConnectionFieldOptions, PrismaModelTypes } from './types';
+import { queryFromInfo } from './util';
+
+export * from './prisma-field-builder';
+
+const fieldBuilderProto = RootFieldBuilder.prototype as PothosSchemaTypes.RootFieldBuilder<
+  SchemaTypes,
+  unknown,
+  FieldKind
+>;
+
+fieldBuilderProto.prismaField = function prismaField({ type, resolve, ...options }) {
+  const model: string = Array.isArray(type) ? type[0] : type;
+  const typeRef = getRefFromModel(model, this.builder);
+  const typeParam: TypeParam<SchemaTypes> = Array.isArray(type) ? [typeRef] : typeRef;
+
+  return this.field({
+    ...options,
+    type: typeParam,
+    resolve: (parent: unknown, args: unknown, ctx: {}, info: GraphQLResolveInfo) => {
+      const query = queryFromInfo(ctx, info);
+
+      return resolve(query, parent, args as never, ctx, info) as never;
+    },
+  }) as never;
+};
+
+fieldBuilderProto.prismaConnection = function prismaConnection<
+  Type extends keyof SchemaTypes['PrismaTypes'],
+  Nullable extends boolean,
+  ResolveReturnShape,
+  Args extends InputFieldMap,
+  Model extends PrismaModelTypes,
+>(
+  this: typeof fieldBuilderProto,
+  {
+    type,
+    cursor,
+    maxSize,
+    defaultSize,
+    resolve,
+    ...options
+  }: PrismaConnectionFieldOptions<
+    SchemaTypes,
+    unknown,
+    Type,
+    Model,
+    ObjectRef<{}>,
+    Nullable,
+    Args,
+    ResolveReturnShape,
+    FieldKind
+  >,
+  connectionOptions: {},
+  edgeOptions: {},
+) {
+  const ref = getRefFromModel(type, this.builder);
+  let typeName: string | undefined;
+
+  const fieldRef = (
+    this as typeof fieldBuilderProto & { connection: (...args: unknown[]) => FieldRef<unknown> }
+  ).connection(
+    {
+      ...options,
+      type: ref,
+      resolve: (
+        parent: unknown,
+        args: PothosSchemaTypes.DefaultConnectionArguments,
+        ctx: {},
+        info: GraphQLResolveInfo,
+      ) =>
+        resolvePrismaCursorConnection(
+          {
+            query: queryFromInfo(ctx, info),
+            column: cursor,
+            maxSize,
+            defaultSize,
+            args,
+          },
+          (query) => resolve(query as never, parent, args as never, ctx, info),
+        ),
+    },
+    {
+      ...connectionOptions,
+      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;

package/src/generator.ts

@@ -0,0 +1,184 @@
+/* eslint-disable no-nested-ternary */
+import { mkdir, writeFile } from 'fs';
+import { dirname } from 'path';
+import ts, { ListFormat, ScriptKind, ScriptTarget, SyntaxKind } from 'typescript';
+import { generatorHandler } from '@prisma/generator-helper';
+
+generatorHandler({
+  onManifest: () => ({
+    prettyName: 'Pothos integration',
+    defaultOutput: 'node_modules/@pothos/plugin-prisma/generated.ts',
+    requiresGenerators: ['prisma-client-js'],
+  }),
+  onGenerate: async (options) => {
+    const config = options.generator.config as { clientOutput?: string };
+    const prismaLocation =
+      config.clientOutput ??
+      options.otherGenerators.find((gen) => gen.provider.value === 'prisma-client-js')!.output!
+        .value;
+
+    const importStatement = ts.factory.createImportDeclaration(
+      [],
+      [],
+      ts.factory.createImportClause(
+        true,
+        undefined,
+        ts.factory.createNamedImports([
+          ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('Prisma')),
+          ...options.dmmf.datamodel.models.map((model) =>
+            ts.factory.createImportSpecifier(
+              false,
+              undefined,
+              ts.factory.createIdentifier(model.name),
+            ),
+          ),
+        ]),
+      ),
+      ts.factory.createStringLiteral(prismaLocation),
+    );
+
+    const modelTypes = options.dmmf.datamodel.models.map((model) => {
+      const relations = model.fields.filter((field) => !!field.relationName);
+      const listRelations = model.fields.filter((field) => !!field.relationName && field.isList);
+
+      return ts.factory.createPropertySignature(
+        [],
+        model.name,
+        undefined,
+        ts.factory.createTypeLiteralNode([
+          ts.factory.createPropertySignature(
+            [],
+            'Shape',
+            undefined,
+            ts.factory.createTypeReferenceNode(model.name),
+          ),
+          ts.factory.createPropertySignature(
+            [],
+            'Include',
+            undefined,
+            relations.length > 0
+              ? ts.factory.createTypeReferenceNode(`Prisma.${model.name}Include`)
+              : ts.factory.createTypeReferenceNode('never'),
+          ),
+          ts.factory.createPropertySignature(
+            [],
+            'Where',
+            undefined,
+            ts.factory.createTypeReferenceNode(`Prisma.${model.name}WhereUniqueInput`),
+          ),
+          ts.factory.createPropertySignature(
+            [],
+            'Fields',
+            undefined,
+            relations.length > 0
+              ? ts.factory.createUnionTypeNode(
+                  relations.map((field) =>
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(field.name)),
+                  ),
+                )
+              : ts.factory.createTypeReferenceNode('never'),
+          ),
+          ts.factory.createPropertySignature(
+            [],
+            'ListRelations',
+            undefined,
+            listRelations.length > 0
+              ? ts.factory.createUnionTypeNode(
+                  listRelations.map((field) =>
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(field.name)),
+                  ),
+                )
+              : ts.factory.createTypeReferenceNode('never'),
+          ),
+          ts.factory.createPropertySignature(
+            [],
+            'Relations',
+            undefined,
+            ts.factory.createTypeLiteralNode(
+              relations.map((field) => {
+                const typeName = typeof field.type === 'string' ? field.type : field.type.name;
+
+                return ts.factory.createPropertySignature(
+                  [],
+                  field.name,
+                  undefined,
+                  ts.factory.createTypeLiteralNode([
+                    ts.factory.createPropertySignature(
+                      [],
+                      'Shape',
+                      undefined,
+                      field.isList
+                        ? ts.factory.createArrayTypeNode(
+                            ts.factory.createTypeReferenceNode(typeName),
+                          )
+                        : field.isRequired
+                        ? ts.factory.createTypeReferenceNode(typeName)
+                        : ts.factory.createUnionTypeNode([
+                            ts.factory.createTypeReferenceNode(typeName),
+                            ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+                          ]),
+                    ),
+                    ts.factory.createPropertySignature(
+                      [],
+                      'Types',
+                      undefined,
+                      ts.factory.createIndexedAccessTypeNode(
+                        ts.factory.createTypeReferenceNode('PrismaTypes'),
+                        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(typeName)),
+                      ),
+                    ),
+                  ]),
+                );
+              }),
+            ),
+          ),
+        ]),
+      );
+    });
+
+    const prismaTypes = ts.factory.createInterfaceDeclaration(
+      [],
+      [
+        ts.factory.createModifier(SyntaxKind.ExportKeyword),
+        ts.factory.createModifier(SyntaxKind.DefaultKeyword),
+      ],
+      'PrismaTypes',
+      [],
+      [],
+      modelTypes,
+    );
+    const printer = ts.createPrinter({});
+
+    const sourcefile = ts.createSourceFile(
+      options.generator.output!.value,
+      '',
+      ScriptTarget.ESNext,
+      false,
+      ScriptKind.TS,
+    );
+
+    const nodes = ts.factory.createNodeArray([importStatement, prismaTypes]);
+
+    const result = printer.printList(ListFormat.SourceFileStatements, nodes, sourcefile);
+
+    await new Promise<void>((resolve, reject) => {
+      mkdir(dirname(sourcefile.fileName), { recursive: true }, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+
+    return new Promise<void>((resolve, reject) => {
+      writeFile(sourcefile.fileName, result, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  },
+});

package/src/global-types.ts

@@ -0,0 +1,180 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+import {
+  FieldKind,
+  FieldNullability,
+  FieldRef,
+  InputFieldMap,
+  InterfaceParam,
+  NormalizeArgs,
+  ObjectRef,
+  OutputType,
+  PluginName,
+  SchemaTypes,
+  ShapeFromTypeParam,
+} from '@pothos/core';
+import PrismaNodeRef from './node-ref';
+import {
+  PrismaConnectionFieldOptions,
+  PrismaFieldOptions,
+  PrismaModelTypes,
+  PrismaNodeOptions,
+  PrismaObjectTypeOptions,
+  ShapeWithInclude,
+} from './types';
+import { PrismaPlugin } from '.';
+
+declare global {
+  export namespace PothosSchemaTypes {
+    export interface Plugins<Types extends SchemaTypes> {
+      prisma: PrismaPlugin<Types>;
+    }
+
+    export interface SchemaBuilderOptions<Types extends SchemaTypes> {
+      prisma: {
+        client: {
+          $connect: () => Promise<void>;
+        };
+      };
+    }
+
+    export interface UserSchemaTypes {
+      PrismaTypes: {};
+    }
+
+    export interface ExtendDefaultTypes<PartialTypes extends Partial<UserSchemaTypes>> {
+      PrismaTypes: undefined extends PartialTypes['PrismaTypes']
+        ? {}
+        : PartialTypes['PrismaTypes'] & {};
+    }
+
+    export interface SchemaBuilder<Types extends SchemaTypes> {
+      prismaObject: <
+        Name extends keyof Types['PrismaTypes'],
+        Interfaces extends InterfaceParam<Types>[],
+        FindUnique,
+        Model extends PrismaModelTypes & Types['PrismaTypes'][Name],
+        Include extends Model['Include'] = {},
+        Shape extends object = ShapeWithInclude<Model, Include>,
+      >(
+        name: Name,
+        options: PrismaObjectTypeOptions<Types, Model, Interfaces, FindUnique, Include, Shape>,
+      ) => ObjectRef<Shape>;
+
+      prismaNode: 'relay' extends PluginName
+        ? <
+            Name extends keyof Types['PrismaTypes'],
+            Interfaces extends InterfaceParam<Types>[],
+            Model extends PrismaModelTypes & Types['PrismaTypes'][Name],
+            Include extends Model['Include'] = {},
+            Shape extends object = ShapeWithInclude<Model, Include>,
+          >(
+            name: Name,
+            options: PrismaNodeOptions<Types, Model, Interfaces, Include, Shape>,
+          ) => PrismaNodeRef<Shape>
+        : '@pothos/plugin-relay is required to use this method';
+    }
+
+    export interface RootFieldBuilder<
+      Types extends SchemaTypes,
+      ParentShape,
+      Kind extends FieldKind = FieldKind,
+    > {
+      prismaField: <
+        Args extends InputFieldMap,
+        TypeParam extends keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']],
+        Nullable extends FieldNullability<Type>,
+        ResolveReturnShape,
+        Type extends TypeParam extends [keyof Types['PrismaTypes']]
+          ? [ObjectRef<Model['Shape']>]
+          : ObjectRef<Model['Shape']>,
+        Model extends PrismaModelTypes = PrismaModelTypes &
+          (TypeParam extends [keyof Types['PrismaTypes']]
+            ? Types['PrismaTypes'][TypeParam[0]]
+            : TypeParam extends keyof Types['PrismaTypes']
+            ? Types['PrismaTypes'][TypeParam]
+            : never),
+      >(
+        options: PrismaFieldOptions<
+          Types,
+          ParentShape,
+          TypeParam,
+          Model,
+          Type,
+          Args,
+          Nullable,
+          ResolveReturnShape,
+          Kind
+        >,
+      ) => FieldRef<ShapeFromTypeParam<Types, Type, Nullable>>;
+
+      prismaConnection: 'relay' extends PluginName
+        ? <
+            Type extends keyof Types['PrismaTypes'],
+            Nullable extends boolean,
+            ResolveReturnShape,
+            Args extends InputFieldMap = {},
+            Model extends PrismaModelTypes = PrismaModelTypes & Types['PrismaTypes'][Type],
+          >(
+            ...args: NormalizeArgs<
+              [
+                options: PrismaConnectionFieldOptions<
+                  Types,
+                  ParentShape,
+                  Type,
+                  Model,
+                  ObjectRef<Model['Shape']>,
+                  Nullable,
+                  Args,
+                  ResolveReturnShape,
+                  Kind
+                >,
+                connectionOptions?: ConnectionObjectOptions<
+                  Types,
+                  ObjectRef<Model['Shape']>,
+                  ResolveReturnShape
+                >,
+                edgeOptions?: ConnectionEdgeObjectOptions<
+                  Types,
+                  ObjectRef<Model['Shape']>,
+                  ResolveReturnShape
+                >,
+              ]
+            >
+          ) => FieldRef<ConnectionShapeHelper<Types, Model['Shape'], Nullable>['shape']>
+        : '@pothos/plugin-relay is required to use this method';
+    }
+
+    export interface ConnectionFieldOptions<
+      Types extends SchemaTypes,
+      ParentShape,
+      Type extends OutputType<Types>,
+      Nullable extends boolean,
+      Args extends InputFieldMap,
+      ResolveReturnShape,
+    > {}
+
+    export interface ConnectionObjectOptions<
+      Types extends SchemaTypes,
+      Type extends OutputType<Types>,
+      Resolved,
+    > {}
+
+    export interface ConnectionEdgeObjectOptions<
+      Types extends SchemaTypes,
+      Type extends OutputType<Types>,
+      Resolved,
+    > {}
+
+    export interface DefaultConnectionArguments {
+      first?: number | null | undefined;
+      last?: number | null | undefined;
+      before?: string | null | undefined;
+      after?: string | null | undefined;
+    }
+
+    export interface ConnectionShapeHelper<Types extends SchemaTypes, T, Nullable> {
+      shape: unknown;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+import './global-types';
+import './field-builder';
+import './schema-builder';
+import SchemaBuilder, { BasePlugin, BuildCache, SchemaTypes } from '@pothos/core';
+
+export * from './types';
+
+const pluginName = 'prisma' as const;
+
+export default pluginName;
+
+export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
+  constructor(cache: BuildCache<Types>) {
+    super(cache, pluginName);
+  }
+}
+
+SchemaBuilder.registerPlugin(pluginName, PrismaPlugin);

package/src/loader-map.ts

@@ -0,0 +1,48 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { createContextCache } from '@pothos/core';
+import { LoaderMappings } from './types';
+
+const cache = createContextCache((ctx) => new Map<string, LoaderMappings>());
+
+export function cacheKey(path: GraphQLResolveInfo['path'], subPath: string[]) {
+  let key = '';
+  let current: GraphQLResolveInfo['path'] | undefined = path;
+
+  while (current) {
+    if (typeof current.key === 'string') {
+      key = key ? `${current.key}.${key}` : current.key;
+    }
+    current = current.prev;
+  }
+
+  for (const entry of subPath) {
+    key = `${key}.${entry}`;
+  }
+
+  return key;
+}
+
+export function setLoaderMappings(
+  ctx: object,
+  path: GraphQLResolveInfo['path'],
+  value: LoaderMappings,
+) {
+  Object.keys(value).forEach((field) => {
+    const map = cache(ctx);
+
+    for (const mapping of value[field]) {
+      const selectionName = mapping.alias ?? mapping.field;
+      const subPath = [...mapping.indirectPath, selectionName];
+      const key = cacheKey(path, subPath);
+
+      map.set(key, mapping.mappings);
+    }
+  });
+}
+
+export function getLoaderMapping(ctx: object, path: GraphQLResolveInfo['path']) {
+  const map = cache(ctx);
+  const key = cacheKey(path, []);
+
+  return map.get(key) ?? null;
+}

package/src/model-loader.ts

@@ -0,0 +1,135 @@
+/* eslint-disable prefer-destructuring */
+/* eslint-disable no-underscore-dangle */
+import { createContextCache, SchemaTypes } from '@pothos/core';
+import { getDelegateFromModel, getFindUniqueForRef, getRefFromModel } from './refs';
+import { PrismaDelegate } from './types';
+import { mergeIncludes } from './util';
+
+const loaderCache = new WeakMap<object, (model: object) => ModelLoader>();
+
+export class ModelLoader {
+  model: object;
+  delegate: PrismaDelegate;
+  findUnique: (args: unknown, ctx: {}) => unknown;
+
+  staged = new Set<{
+    promise: Promise<Record<string, unknown>>;
+    include: Record<string, unknown>;
+  }>();
+
+  constructor(
+    model: object,
+    delegate: PrismaDelegate,
+    findUnique: (args: unknown, ctx: {}) => unknown,
+  ) {
+    this.model = model;
+    this.delegate = delegate;
+    this.findUnique = findUnique;
+  }
+
+  static forModel<Types extends SchemaTypes>(
+    modelName: string,
+    builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  ) {
+    const delegate = getDelegateFromModel(builder.options.prisma.client, modelName);
+
+    if (!loaderCache.has(delegate)) {
+      const ref = getRefFromModel(modelName, builder);
+
+      const findUnique = getFindUniqueForRef(ref, builder);
+      loaderCache.set(
+        delegate,
+        createContextCache((model) => new ModelLoader(model, delegate, findUnique!)),
+      );
+    }
+
+    return loaderCache.get(delegate)!;
+  }
+
+  async loadCount(relation: string, context: {}): Promise<number> {
+    let promise;
+    const entry = [...this.staged][0];
+
+    if (entry) {
+      if (!entry.include._count) {
+        entry.include._count = { select: {} };
+      }
+
+      (entry.include._count as { select: Record<string, boolean> }).select[relation] = true;
+      promise = entry.promise;
+    } else {
+      promise = this.initLoad(relation, null, context, true);
+    }
+
+    const result = await promise;
+
+    return (result._count as Record<string, number>)[relation];
+  }
+
+  async loadRelation(relation: string, include: unknown, context: {}) {
+    let promise;
+    for (const entry of this.staged) {
+      if (entry.include[relation] === undefined) {
+        promise = entry.promise;
+        entry.include[relation] = include;
+
+        break;
+      }
+
+      const merged = mergeIncludes(
+        entry.include[relation] as Record<string, unknown>,
+        include as Record<string, unknown>,
+      );
+
+      if (merged) {
+        entry.include[relation] = merged;
+        break;
+      }
+    }
+
+    if (!promise) {
+      promise = this.initLoad(relation, include, context);
+    }
+
+    const result = await promise;
+
+    return result[relation];
+  }
+
+  async initLoad(relation: string, includeArg: unknown, context: {}, count = false) {
+    const include: Record<string, unknown> = count
+      ? {
+          _count: {
+            select: {
+              [relation]: true,
+            },
+          },
+        }
+      : {
+          [relation]: includeArg,
+        };
+
+    const promise = new Promise<Record<string, unknown>>((resolve, reject) => {
+      setTimeout(() => {
+        this.staged.delete(entry);
+
+        resolve(
+          this.delegate.findUnique({
+            rejectOnNotFound: true,
+            where: { ...(this.findUnique(this.model, context) as {}) },
+            include,
+          } as never) as Promise<Record<string, unknown>>,
+        );
+      }, 0);
+    });
+
+    const entry = {
+      promise,
+      include,
+    };
+
+    this.staged.add(entry);
+
+    return promise;
+  }
+}

package/src/node-ref.ts

@@ -0,0 +1,29 @@
+import { abstractReturnShapeKey, brandWithType, ObjectRef, typeBrandKey } from '@pothos/core';
+import { WithBrand } from './types';
+
+export default class PrismaNodeRef<T> extends ObjectRef<T, T> {
+  [abstractReturnShapeKey]: WithBrand<T>;
+
+  addBrand<V extends T | T[]>(
+    value: V,
+  ): V extends T[] ? { [K in keyof V]: WithBrand<V[K]> } : WithBrand<V> {
+    if (Array.isArray(value)) {
+      value.forEach((val) => void brandWithType(val, this.name as never));
+
+      return value as never;
+    }
+
+    brandWithType(value, this.name as never);
+
+    return value as never;
+  }
+
+  hasBrand(value: unknown) {
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      typeBrandKey in value &&
+      (value as { [typeBrandKey]?: unknown })[typeBrandKey] === this.name
+    );
+  }
+}