@pothos/plugin-prisma 3.36.0 → 3.38.0

package/package.json

@@ -1,17 +1,27 @@
 {
   "name": "@pothos/plugin-prisma",
-  "version": "3.36.0",
+  "version": "3.38.0",
   "description": "A Pothos plugin for more efficient integration with prisma",
   "main": "./lib/index.js",
   "types": "./dts/index.d.ts",
   "module": "./esm/index.js",
   "exports": {
-    "import": {
-      "default": "./esm/index.js"
+    ".": {
+      "import": {
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./dts/index.d.ts",
+        "default": "./lib/index.js"
+      }
     },
-    "require": {
-      "types": "./dts/index.d.ts",
-      "default": "./lib/index.js"
+    "./generated": {
+      "import": {
+        "default": "./esm/generated.ts"
+      },
+      "require": {
+        "default": "./generated.ts"
+      }
     }
   },
   "repository": {
@@ -40,7 +50,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@prisma/generator-helper": "^4.5.0"
+    "@prisma/generator-helper": "^4.7.1"
   },
   "prisma": {
     "seed": "node prisma/seed.mjs"
@@ -52,14 +62,14 @@
     "typescript": ">=4.7.2"
   },
   "devDependencies": {
-    "@prisma/client": "^4.5.0",
+    "@prisma/client": "^4.7.1",
     "graphql": "16.6.0",
     "graphql-tag": "^2.12.6",
-    "prisma": "^4.5.0",
-    "@pothos/core": "3.23.0",
+    "prisma": "^4.7.1",
+    "@pothos/core": "3.23.1",
     "@pothos/plugin-complexity": "3.11.7",
     "@pothos/plugin-errors": "3.9.0",
-    "@pothos/plugin-relay": "3.29.0",
+    "@pothos/plugin-relay": "3.30.0",
     "@pothos/plugin-simple-objects": "3.6.7",
     "@pothos/test-utils": "1.4.7"
   },

package/src/connection-helpers.ts

@@ -1,6 +1,7 @@
-import { SchemaTypes } from '@pothos/core';
+import { ObjectRef, SchemaTypes } from '@pothos/core';
+import { ModelLoader } from './model-loader';
 import { PrismaObjectRef } from './object-ref';
-import type { PrismaModelTypes } from './types';
+import type { PrismaModelTypes, ShapeFromSelection } from './types';
 import {
   getCursorFormatter,
   getCursorParser,
@@ -8,41 +9,72 @@ import {
   wrapConnectionResult,
 } from './util/cursors';
 import { getRefFromModel } from './util/datamodel';
+import { getDMMF } from './util/get-client';
+import { getRelationMap } from './util/relation-map';
+import { createState, mergeSelection, selectionToQuery } from './util/selections';
 
 export const prismaModelKey = Symbol.for('Pothos.prismaModelKey');
 
 export function prismaConnectionHelpers<
   Types extends SchemaTypes,
   RefOrType extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'],
+  Select extends Model['Select'] & {},
   Model extends PrismaModelTypes = RefOrType extends PrismaObjectRef<infer T>
     ? T & PrismaModelTypes
     : Types['PrismaTypes'][RefOrType & keyof Types['PrismaTypes']] & PrismaModelTypes,
   Shape = RefOrType extends PrismaObjectRef<PrismaModelTypes, infer T> ? T : Model['Shape'],
+  EdgeShape = Model['Include'] extends Select
+    ? Shape
+    : ShapeFromSelection<Model, { select: Select }>,
+  NodeShape = EdgeShape,
 >(
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
   refOrType: RefOrType,
   options: {
     cursor: string & keyof Model['WhereUnique'];
+    select?: (nestedSelection: <T extends {} | true>(selection?: T) => T) => Select;
     defaultSize?:
       | number
       | ((args: PothosSchemaTypes.DefaultConnectionArguments, ctx: {}) => number);
     maxSize?: number | ((args: PothosSchemaTypes.DefaultConnectionArguments, ctx: {}) => number);
+    resolveNode?: (edge: EdgeShape) => NodeShape;
   },
 ) {
   const modelName =
     typeof refOrType === 'string' ? refOrType : (refOrType as PrismaObjectRef<Model>).modelName;
+  const ref =
+    typeof refOrType === 'string'
+      ? getRefFromModel(modelName, builder)
+      : (refOrType as ObjectRef<unknown>);
   const formatCursor = getCursorFormatter(modelName, builder, options.cursor);
   const parseCursor = getCursorParser(modelName, builder, options.cursor);
+  const cursorSelection = ModelLoader.getCursorSelection(ref, modelName, options.cursor, builder);
+  const fieldMap = getRelationMap(getDMMF(builder)).get(modelName)!;
 
   function resolve(
-    list: (Shape & {})[],
+    list: (EdgeShape & {})[],
     args: PothosSchemaTypes.DefaultConnectionArguments,
     ctx: Types['Context'],
   ) {
-    return wrapConnectionResult(list, args, getQuery(args, ctx).take, formatCursor);
+    return wrapConnectionResult(
+      list,
+      args,
+      getQueryArgs(args, ctx).take,
+      formatCursor,
+      null,
+      (options?.resolveNode as never) ?? ((edge: unknown) => edge),
+    ) as unknown as {
+      edges: (Omit<EdgeShape, 'cursor' | 'node'> & { node: NodeShape; cursor: string })[];
+      pageInfo: {
+        startCursor: string | null;
+        endCursor: string | null;
+        hasPreviousPage: boolean;
+        hasNextPage: boolean;
+      };
+    };
   }
 
-  function getQuery(args: PothosSchemaTypes.DefaultConnectionArguments, ctx: Types['Context']) {
+  function getQueryArgs(args: PothosSchemaTypes.DefaultConnectionArguments, ctx: Types['Context']) {
     return prismaCursorConnectionQuery({
       args,
       ctx,
@@ -55,11 +87,36 @@ export function prismaConnectionHelpers<
     });
   }
 
+  function getQuery(
+    args: PothosSchemaTypes.DefaultConnectionArguments,
+    ctx: Types['Context'],
+    nestedSelection: <T extends true | {}>(selection?: T, path?: string[]) => T,
+  ) {
+    const nestedSelect: Record<string, unknown> | true = options.select
+      ? { select: options.select((sel) => nestedSelection(sel, ['edges', 'node'])) }
+      : nestedSelection(true, ['edges', 'node']);
+
+    const selectState = createState(fieldMap, 'select');
+
+    mergeSelection(selectState, { select: cursorSelection });
+
+    if (typeof nestedSelect === 'object' && nestedSelect) {
+      mergeSelection(selectState, nestedSelect);
+    }
+
+    return {
+      ...getQueryArgs(args, ctx),
+      ...selectionToQuery(selectState),
+    } as unknown as ReturnType<typeof getQueryArgs> &
+      (Model['Select'] extends Select ? {} : { select: Select });
+  }
+
   return {
     ref: (typeof refOrType === 'string'
       ? getRefFromModel(refOrType, builder)
       : refOrType) as PrismaObjectRef<Model>,
     resolve,
+    select: options.select ?? {},
     getQuery,
   };
 }

package/src/generator.ts

@@ -5,7 +5,7 @@
 import { mkdir, writeFile } from 'fs';
 import { dirname, resolve as resolvePath } from 'path';
 import ts, { ListFormat, ScriptKind, ScriptTarget, SyntaxKind, version } from 'typescript';
-import { generatorHandler } from '@prisma/generator-helper';
+import { DMMF, generatorHandler } from '@prisma/generator-helper';
 
 const MIN_TS_VERSION = [4, 5, 2];
 
@@ -42,210 +42,232 @@ generatorHandler({
       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 outputLocation = options.generator.output?.value ?? defaultOutput;
+    const prismaTypes = buildTypes(options.dmmf);
 
-    function getOrderByTypeName(type: string) {
-      const possibleTypes = [
-        `${type}OrderByWithRelationInput`,
-        `${type}OrderByWithRelationAndSearchRelevanceInput`,
-      ];
+    await generateOutput(options.dmmf, prismaTypes, prismaLocation, outputLocation);
 
-      const orderBy = options.dmmf.schema.inputObjectTypes.prisma?.find((inputType) =>
-        possibleTypes.includes(inputType.name),
+    if (outputLocation === defaultOutput) {
+      await generateOutput(
+        options.dmmf,
+        prismaTypes,
+        prismaLocation.replace('../', '../../'),
+        outputLocation.replace('/generated.ts', '/esm/generated.ts'),
       );
+    }
+  },
+});
 
-      if (!orderBy) {
-        return possibleTypes[0];
-      }
+async function generateOutput(
+  dmmf: DMMF.Document,
+  prismaTypes: ts.InterfaceDeclaration,
+  prismaLocation: string,
+  outputLocation: string,
+) {
+  const importStatement = ts.factory.createImportDeclaration(
+    [],
+    [],
+    ts.factory.createImportClause(
+      true,
+      undefined,
+      ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('Prisma')),
+        ...dmmf.datamodel.models.map((model) =>
+          ts.factory.createImportSpecifier(
+            false,
+            undefined,
+            ts.factory.createIdentifier(model.name),
+          ),
+        ),
+      ]),
+    ),
+    ts.factory.createStringLiteral(prismaLocation),
+  );
 
-      return orderBy.name;
-    }
+  const printer = ts.createPrinter({});
 
-    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);
+  const sourcefile = ts.createSourceFile(
+    outputLocation,
+    '',
+    ScriptTarget.ESNext,
+    false,
+    ScriptKind.TS,
+  );
 
-      return ts.factory.createPropertySignature(
-        [],
-        model.name,
-        undefined,
+  const nodes = ts.factory.createNodeArray([importStatement, prismaTypes]);
 
-        ts.factory.createTypeLiteralNode([
-          ts.factory.createPropertySignature(
-            [],
-            'Name',
-            undefined,
-            ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(model.name)),
-          ),
-          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(
-            [],
-            'Select',
-            undefined,
-            ts.factory.createTypeReferenceNode(`Prisma.${model.name}Select`),
-          ),
-          ts.factory.createPropertySignature(
-            [],
-            'OrderBy',
-            undefined,
-            ts.factory.createTypeReferenceNode(`Prisma.${getOrderByTypeName(model.name)}`),
-          ),
-          ts.factory.createPropertySignature(
-            [],
-            'WhereUnique',
-            undefined,
-            ts.factory.createTypeReferenceNode(`Prisma.${model.name}WhereUniqueInput`),
-          ),
-          ts.factory.createPropertySignature(
-            [],
-            'Where',
-            undefined,
-            ts.factory.createTypeReferenceNode(`Prisma.${model.name}WhereInput`),
-          ),
-          ts.factory.createPropertySignature(
-            [],
-            'RelationName',
-            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 = field.type;
-
-                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 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();
+      }
     });
+  });
 
-    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,
+  return new Promise<void>((resolve, reject) => {
+    writeFile(sourcefile.fileName, `/* eslint-disable */\n${result}`, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+function buildTypes(dmmf: DMMF.Document) {
+  function getOrderByTypeName(type: string) {
+    const possibleTypes = [
+      `${type}OrderByWithRelationInput`,
+      `${type}OrderByWithRelationAndSearchRelevanceInput`,
+    ];
+
+    const orderBy = dmmf.schema.inputObjectTypes.prisma?.find((inputType) =>
+      possibleTypes.includes(inputType.name),
     );
 
-    const nodes = ts.factory.createNodeArray([importStatement, prismaTypes]);
+    if (!orderBy) {
+      return possibleTypes[0];
+    }
 
-    const result = printer.printList(ListFormat.SourceFileStatements, nodes, sourcefile);
+    return orderBy.name;
+  }
 
-    await new Promise<void>((resolve, reject) => {
-      mkdir(dirname(sourcefile.fileName), { recursive: true }, (err) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
-    });
+  const modelTypes = dmmf.datamodel.models.map((model) => {
+    const relations = model.fields.filter((field) => !!field.relationName);
+    const listRelations = model.fields.filter((field) => !!field.relationName && field.isList);
 
-    return new Promise<void>((resolve, reject) => {
-      writeFile(sourcefile.fileName, `/* eslint-disable */\n${result}`, (err) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve();
-        }
-      });
-    });
-  },
-});
+    return ts.factory.createPropertySignature(
+      [],
+      model.name,
+      undefined,
+
+      ts.factory.createTypeLiteralNode([
+        ts.factory.createPropertySignature(
+          [],
+          'Name',
+          undefined,
+          ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(model.name)),
+        ),
+        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(
+          [],
+          'Select',
+          undefined,
+          ts.factory.createTypeReferenceNode(`Prisma.${model.name}Select`),
+        ),
+        ts.factory.createPropertySignature(
+          [],
+          'OrderBy',
+          undefined,
+          ts.factory.createTypeReferenceNode(`Prisma.${getOrderByTypeName(model.name)}`),
+        ),
+        ts.factory.createPropertySignature(
+          [],
+          'WhereUnique',
+          undefined,
+          ts.factory.createTypeReferenceNode(`Prisma.${model.name}WhereUniqueInput`),
+        ),
+        ts.factory.createPropertySignature(
+          [],
+          'Where',
+          undefined,
+          ts.factory.createTypeReferenceNode(`Prisma.${model.name}WhereInput`),
+        ),
+        ts.factory.createPropertySignature(
+          [],
+          'RelationName',
+          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 = field.type;
+
+              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)),
+                    ),
+                  ),
+                ]),
+              );
+            }),
+          ),
+        ),
+      ]),
+    );
+  });
+
+  return ts.factory.createInterfaceDeclaration(
+    [],
+    [
+      ts.factory.createModifier(SyntaxKind.ExportKeyword),
+      ts.factory.createModifier(SyntaxKind.DefaultKeyword),
+    ],
+    'PrismaTypes',
+    [],
+    [],
+    modelTypes,
+  );
+}

package/src/util/cursors.ts

@@ -261,7 +261,8 @@ export function wrapConnectionResult<T extends {}>(
   args: PothosSchemaTypes.DefaultConnectionArguments,
   take: number,
   cursor: (node: T) => string,
-  totalCount?: number | (() => MaybePromise<number>),
+  totalCount?: null | number | (() => MaybePromise<number>),
+  resolveNode?: (node: unknown) => unknown,
 ) {
   const gotFullResults = results.length === Math.abs(take);
   const hasNextPage = args.before ? true : gotFullResults;
@@ -273,6 +274,12 @@ export function wrapConnectionResult<T extends {}>(
   const edges = nodes.map((value, index) =>
     value == null
       ? null
+      : resolveNode
+      ? {
+          ...value,
+          cursor: cursor(value),
+          node: resolveNode(value),
+        }
       : {
           cursor: cursor(value),
           node: value,