@pothos/plugin-prisma 3.0.0 → 3.1.2

package/src/field-builder.ts

@@ -3,6 +3,7 @@ import {
   FieldKind,
   FieldRef,
   InputFieldMap,
+  MaybePromise,
   ObjectRef,
   RootFieldBuilder,
   SchemaTypes,
@@ -53,6 +54,7 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
     maxSize,
     defaultSize,
     resolve,
+    totalCount,
     ...options
   }: PrismaConnectionFieldOptions<
     SchemaTypes,
@@ -65,8 +67,8 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
     ResolveReturnShape,
     FieldKind
   >,
-  connectionOptions: {},
-  edgeOptions: {},
+  connectionOptions: {} = {},
+  edgeOptions: {} = {},
 ) {
   const ref = typeof type === 'string' ? getRefFromModel(type, this.builder) : type;
   const typeName = this.builder.configStore.getTypeConfig(ref).name;
@@ -95,6 +97,7 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
             maxSize,
             defaultSize,
             args,
+            totalCount: totalCount && (() => totalCount(parent, args as never, ctx, info)),
           },
           formatCursor,
           (query) => resolve(query as never, parent, args as never, ctx, info),
@@ -102,6 +105,20 @@ fieldBuilderProto.prismaConnection = function prismaConnection<
     },
     {
       ...connectionOptions,
+      fields: totalCount
+        ? (
+            t: PothosSchemaTypes.ObjectFieldBuilder<
+              SchemaTypes,
+              { totalCount?: () => MaybePromise<number> }
+            >,
+          ) => ({
+            totalCount: t.int({
+              nullable: false,
+              resolve: (parent, args, context) => parent.totalCount?.(),
+            }),
+            ...(connectionOptions as { fields?: (t: unknown) => {} }).fields?.(t),
+          })
+        : (connectionOptions as { fields: undefined }).fields,
       extensions: {
         ...(connectionOptions as Record<string, {}> | undefined)?.extensions,
         pothosPrismaIndirectInclude: {

package/src/generator.ts

@@ -1,9 +1,29 @@
+/* eslint-disable no-magic-numbers */
 /* eslint-disable no-nested-ternary */
 import { mkdir, writeFile } from 'fs';
 import { dirname } from 'path';
-import ts, { ListFormat, ScriptKind, ScriptTarget, SyntaxKind } from 'typescript';
+import ts, { ListFormat, ScriptKind, ScriptTarget, SyntaxKind, version } from 'typescript';
 import { generatorHandler } from '@prisma/generator-helper';
 
+const MIN_TS_VERSION = [4, 5, 2];
+
+function checkTSVersion() {
+  const versionParts = version.split(/[.-]/g);
+
+  for (let i = 0; i < 3; i += 1) {
+    const part = Number.parseInt(versionParts[i], 10);
+    if (part < MIN_TS_VERSION[i]) {
+      throw new Error(
+        `@pothos/plugin-prisma requires typescript version >${MIN_TS_VERSION.join('.')}`,
+      );
+    }
+
+    if (part > MIN_TS_VERSION[i]) {
+      return;
+    }
+  }
+}
+
 generatorHandler({
   onManifest: () => ({
     prettyName: 'Pothos integration',
@@ -11,6 +31,7 @@ generatorHandler({
     requiresGenerators: ['prisma-client-js'],
   }),
   onGenerate: async (options) => {
+    checkTSVersion();
     const config = options.generator.config as { clientOutput?: string };
     const prismaLocation =
       config.clientOutput ??

package/src/index.ts

@@ -48,14 +48,14 @@ export class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
     }
 
     const parentConfig = this.buildCache.getTypeConfig(fieldConfig.parentType, 'Object');
-    const loadedCheck = fieldConfig.extensions.pothosPrismaLoaded as
+    const loadedCheck = fieldConfig.extensions?.pothosPrismaLoaded as
       | undefined
       | ((val: unknown) => boolean);
     const loaderCache = parentConfig.extensions?.pothosPrismaLoader as (
       model: unknown,
     ) => ModelLoader;
 
-    const fallback = fieldConfig.extensions.pothosPrismaFallback as
+    const fallback = fieldConfig.extensions?.pothosPrismaFallback as
       | undefined
       | ((query: {}, parent: unknown, args: {}, context: {}, info: {}) => unknown);
 

package/src/prisma-field-builder.ts

@@ -206,6 +206,7 @@ export class PrismaObjectFieldBuilder<
         fields: totalCount
           ? (t: PothosSchemaTypes.ObjectFieldBuilder<SchemaTypes, { totalCount?: number }>) => ({
               totalCount: t.int({
+                nullable: false,
                 extensions: {
                   pothosPrismaParentSelect: { _count: { select: { [name]: true } } },
                 },

package/src/types.ts

@@ -443,6 +443,12 @@ export type PrismaConnectionFieldOptions<
       context: Types['Context'],
       info: GraphQLResolveInfo,
     ) => MaybePromise<Model['Shape'][]>;
+    totalCount?: (
+      parent: ParentShape,
+      args: InputShapeFromFields<Args> & PothosSchemaTypes.DefaultConnectionArguments,
+      context: Types['Context'],
+      info: GraphQLResolveInfo,
+    ) => MaybePromise<number>;
   };
 
 export type RelatedConnectionOptions<

package/src/util/cursors.ts

@@ -84,7 +84,7 @@ export interface PrismaCursorConnectionQueryOptions {
 
 interface ResolvePrismaCursorConnectionOptions extends PrismaCursorConnectionQueryOptions {
   query: {};
-  totalCount?: number;
+  totalCount?: number | (() => MaybePromise<number>);
 }
 
 export function prismaCursorConnectionQuery({
@@ -139,7 +139,7 @@ export function wrapConnectionResult<T extends {}>(
   args: PothosSchemaTypes.DefaultConnectionArguments,
   take: number,
   cursor: (node: T) => string,
-  totalCount?: number,
+  totalCount?: number | (() => MaybePromise<number>),
 ) {
   const gotFullResults = results.length === Math.abs(take);
   const hasNextPage = args.before ? true : gotFullResults;

package/src/util/map-query.ts

@@ -305,11 +305,11 @@ function createStateForType(
 ) {
   const targetType = getIndirectType(type, info);
 
-  const fieldMap = targetType.extensions.pothosPrismaFieldMap as FieldMap;
+  const fieldMap = targetType.extensions?.pothosPrismaFieldMap as FieldMap;
 
   return createState(
     fieldMap,
-    targetType.extensions.pothosPrismaSelect ? 'select' : 'include',
+    targetType.extensions?.pothosPrismaSelect ? 'select' : 'include',
     parent,
   );
 }
@@ -317,9 +317,9 @@ function createStateForType(
 export function getIndirectType(type: GraphQLNamedType, info: GraphQLResolveInfo) {
   let targetType = type;
 
-  while (targetType.extensions.pothosPrismaIndirectInclude) {
+  while (targetType.extensions?.pothosPrismaIndirectInclude) {
     targetType = info.schema.getType(
-      (targetType.extensions.pothosPrismaIndirectInclude as IndirectInclude).getType(),
+      (targetType.extensions?.pothosPrismaIndirectInclude as IndirectInclude).getType(),
     )!;
   }