@pothos/plugin-prisma 3.12.1 → 3.13.2

package/src/model-loader.ts

@@ -144,6 +144,35 @@ export class ModelLoader {
     return result;
   }
 
+  static getCursorSelection<Types extends SchemaTypes>(
+    ref: ObjectRef<unknown>,
+    modelName: string,
+    cursor: string,
+    builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  ): Record<string, boolean> {
+    const model = getModel(modelName, builder);
+    const field = model.fields.find((field) => field.name === cursor);
+
+    if (field) {
+      return { [field.name]: true };
+    }
+    const index = [model.primaryKey, ...model.uniqueIndexes]
+      .filter(Boolean)
+      .find((idx) => (idx!.name ?? idx!.fields.join('_')) === cursor);
+
+    if (!index) {
+      throw new Error(`Can't find "${cursor}" field or index for ${ref.name}`);
+    }
+
+    const selection: Record<string, boolean> = {};
+
+    for (const column of index.fields) {
+      selection[column] = true;
+    }
+
+    return selection;
+  }
+
   static getFindUniqueForField<Types extends SchemaTypes>(
     ref: ObjectRef<unknown>,
     modelName: string,
@@ -206,6 +235,13 @@ export class ModelLoader {
           this.modelName,
         );
 
+        if (delegate.findUniqueOrThrow) {
+          return delegate.findUniqueOrThrow({
+            ...selectionToQuery(state),
+            where: { ...(this.findUnique(this.model, context) as {}) },
+          } as never) as Promise<Record<string, unknown>>;
+        }
+
         return delegate.findUnique({
           rejectOnNotFound: true,
           ...selectionToQuery(state),

package/src/prisma-field-builder.ts

@@ -14,12 +14,14 @@ import {
   SchemaTypes,
   TypeParam,
 } from '@pothos/core';
+import { ModelLoader } from './model-loader';
 import { PrismaObjectRef } from './object-ref';
 import {
   PrismaModelTypes,
   RelatedConnectionOptions,
   RelatedFieldOptions,
   RelationCountOptions,
+  SelectionMap,
   ShapeFromConnection,
   VariantFieldOptions,
 } from './types';
@@ -43,6 +45,27 @@ const RootBuilder: {
   ): PothosSchemaTypes.RootFieldBuilder<Types, Shape, Kind>;
 } = RootFieldBuilder as never;
 
+type ContextForAuth<
+  Types extends SchemaTypes,
+  Scopes extends {} = {},
+> = PothosSchemaTypes.ScopeAuthContextForAuth<Types, Scopes> extends {
+  Context: infer T;
+}
+  ? T extends object
+    ? T
+    : object
+  : object;
+
+type FieldAuthScopes<
+  Types extends SchemaTypes,
+  Parent,
+  Args extends {} = {},
+> = PothosSchemaTypes.ScopeAuthFieldAuthScopes<Types, Parent, Args> extends {
+  Scopes: infer T;
+}
+  ? T
+  : never;
+
 export class PrismaObjectFieldBuilder<
   Types extends SchemaTypes,
   Model extends PrismaModelTypes,
@@ -63,6 +86,17 @@ export class PrismaObjectFieldBuilder<
   exposeIDList = this.createExpose(['ID']);
   exposeStringList = this.createExpose(['String']);
 
+  withAuth: 'scopeAuth' extends PluginName
+    ? <Scopes extends FieldAuthScopes<Types, Shape, Record<string, unknown>>>(
+        scopes: Scopes,
+      ) => PothosSchemaTypes.PrismaObjectFieldBuilder<
+        Omit<Types, 'Context'> & { Context: ContextForAuth<Types, Scopes> },
+        Model,
+        NeedsResolve,
+        Shape
+      >
+    : '@pothos/plugin-scope-auth is required to use this method' = (() => {}) as never;
+
   relatedConnection: 'relay' extends PluginName
     ? <
         Field extends Model['ListRelations'],
@@ -133,35 +167,53 @@ export class PrismaObjectFieldBuilder<
         args,
       }),
     });
+    const cursorSelection = ModelLoader.getCursorSelection(
+      ref,
+      relationField.type,
+      cursor,
+      this.builder,
+    );
 
     const relationSelect = (
       args: object,
       context: object,
       nestedQuery: (query: unknown, path: unknown) => unknown,
-    ) => ({
-      select: {
-        [name]: nestedQuery(
-          {
-            ...((typeof query === 'function' ? query(args, context) : query) as {}),
-            ...prismaCursorConnectionQuery({
-              parseCursor,
-              maxSize,
-              defaultSize,
-              args,
-            }),
+    ) => {
+      const nested = nestedQuery(
+        {
+          ...((typeof query === 'function' ? query(args, context) : query) as {}),
+          ...prismaCursorConnectionQuery({
+            parseCursor,
+            maxSize,
+            defaultSize,
+            args,
+          }),
+        },
+        {
+          getType: () => {
+            if (!typeName) {
+              typeName = this.builder.configStore.getTypeConfig(ref).name;
+            }
+            return typeName;
           },
-          {
-            getType: () => {
-              if (!typeName) {
-                typeName = this.builder.configStore.getTypeConfig(ref).name;
+          path: [{ name: 'edges' }, { name: 'node' }],
+        },
+      ) as SelectionMap;
+
+      return {
+        select: {
+          [name]: nested?.select
+            ? {
+                ...nested,
+                select: {
+                  ...cursorSelection,
+                  ...nested.select,
+                },
               }
-              return typeName;
-            },
-            path: [{ name: 'edges' }, { name: 'node' }],
-          },
-        ),
-      },
-    });
+            : nested,
+        },
+      };
+    };
 
     const fieldRef = (
       this as unknown as {
@@ -448,3 +500,39 @@ export class PrismaObjectFieldBuilder<
     };
   }
 }
+
+const prismaFieldBuilderProto = PrismaObjectFieldBuilder.prototype as {} as Omit<
+  PrismaObjectFieldBuilder<SchemaTypes, PrismaModelTypes, false, {}>,
+  'withAuth'
+> & {
+  withAuth: (scopes: {}) => unknown;
+};
+
+prismaFieldBuilderProto.withAuth = function withAuth(scopes) {
+  return addScopes(
+    scopes,
+    new PrismaObjectFieldBuilder(
+      this.typename,
+      this.builder,
+      this.model,
+      this.prismaFieldMap,
+    ) as never,
+  );
+};
+
+function addScopes(
+  scopes: unknown,
+  builder: { createField: (options: Record<string, unknown>) => unknown },
+) {
+  const originalCreateField = builder.createField;
+
+  // eslint-disable-next-line no-param-reassign
+  builder.createField = function createField(options) {
+    return originalCreateField.call(this, {
+      authScopes: scopes,
+      ...options,
+    });
+  };
+
+  return builder as never;
+}

package/src/schema-builder.ts

@@ -97,11 +97,17 @@ schemaBuilderProto.prismaNode = function prismaNode(
     ) => {
       const query = queryFromInfo(context, info, typeName);
       const delegate = getDelegateFromModel(getClient(this, context), type);
-      const record = await delegate.findUnique({
-        ...query,
-        rejectOnNotFound: true,
-        where: rawFindUnique ? rawFindUnique(id, context) : { [fieldName]: idParser!(id) },
-      } as never);
+
+      const record = await (delegate.findUniqueOrThrow
+        ? delegate.findUniqueOrThrow({
+            ...query,
+            where: rawFindUnique ? rawFindUnique(id, context) : { [fieldName]: idParser!(id) },
+          } as never)
+        : delegate.findUnique({
+            ...query,
+            rejectOnNotFound: true,
+            where: rawFindUnique ? rawFindUnique(id, context) : { [fieldName]: idParser!(id) },
+          } as never));
 
       brandWithType(record, typeName as OutputType<SchemaTypes>);
 

package/src/types.ts

@@ -24,6 +24,7 @@ import { PrismaObjectFieldBuilder } from './field-builder';
 import { PrismaObjectRef } from './object-ref';
 
 export interface PrismaDelegate {
+  findUniqueOrThrow?: (...args: any[]) => Promise<unknown>;
   findUnique: (...args: any[]) => Promise<unknown>;
 }
 
@@ -473,7 +474,8 @@ export type PrismaConnectionFieldOptions<
       ParentShape,
       Param,
       Nullable,
-      Args & InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>,
+      (InputFieldMap extends Args ? {} : Args) &
+        InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>,
       Kind,
       ParentShape,
       ResolveReturnShape
@@ -517,10 +519,11 @@ export type RelatedConnectionOptions<
     Model['Shape'],
     ObjectRef<unknown>,
     Nullable,
-    Args,
+    (InputFieldMap extends Args ? {} : Args) &
+      InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>,
     unknown
   >,
-  'resolve' | 'type'
+  'resolve' | 'type' | 'args'
 > &
   Omit<
     PothosSchemaTypes.ConnectionFieldOptions<

package/src/util/cursors.ts

@@ -174,7 +174,7 @@ export function serializeID(id: unknown, dataType: string) {
 }
 
 export function parseCompositeCursor(fields: string[]) {
-  return (cursor: string) => {
+  return (cursor: unknown) => {
     const parsed = parseRawCursor(cursor) as unknown[];
 
     if (!Array.isArray(parsed)) {

package/src/util/datamodel.ts

@@ -72,8 +72,15 @@ export function getCursorFormatter<Types extends SchemaTypes>(
 ) {
   const modelData = getModel(name, builder);
   const primaryKey = modelData.primaryKey?.name ?? modelData.primaryKey?.fields.join('_');
+  if (primaryKey === cursor) {
+    return formatCursor(modelData.primaryKey!.fields);
+  }
+
+  const uniqueIndex = modelData.uniqueIndexes.find(
+    (idx) => (idx.name ?? idx.fields.join('_')) === cursor,
+  );
 
-  return formatCursor(cursor === primaryKey ? modelData.primaryKey!.fields : cursor);
+  return formatCursor(uniqueIndex?.fields ?? cursor);
 }
 
 export function getCursorParser<Types extends SchemaTypes>(
@@ -84,8 +91,19 @@ export function getCursorParser<Types extends SchemaTypes>(
   const modelData = getModel(name, builder);
   const primaryKey = modelData.primaryKey?.name ?? modelData.primaryKey?.fields.join('_');
 
-  const parser =
-    cursor === primaryKey ? parseCompositeCursor(modelData.primaryKey!.fields) : parseRawCursor;
+  let parser = parseRawCursor;
+
+  if (primaryKey === cursor) {
+    parser = parseCompositeCursor(modelData.primaryKey!.fields);
+  } else {
+    const uniqueIndex = modelData.uniqueIndexes.find(
+      (idx) => (idx.name ?? idx.fields.join('_')) === cursor,
+    );
+
+    if (uniqueIndex) {
+      parser = parseCompositeCursor(uniqueIndex.fields);
+    }
+  }
 
   return (rawCursor: string) => ({
     [cursor]: parser(rawCursor),

package/src/util/map-query.ts

@@ -306,10 +306,19 @@ function addFieldSelection(
   }
 }
 
-export function queryFromInfo(context: object, info: GraphQLResolveInfo, typeName?: string): {} {
+export function queryFromInfo(
+  context: object,
+  info: GraphQLResolveInfo,
+  typeName?: string,
+  initialSelection?: SelectionMap,
+): {} {
   const type = typeName ? info.schema.getTypeMap()[typeName] : getNamedType(info.returnType);
   const state = createStateForType(type, info);
 
+  if (initialSelection) {
+    mergeSelection(state, initialSelection);
+  }
+
   addTypeSelectionsForField(type, context, info, state, info.fieldNodes[0], []);
 
   setLoaderMappings(context, info, state.mappings);

package/tsconfig.type.json

@@ -1,10 +1,10 @@
 {
   "compilerOptions": {
-    "skipLibCheck": true,
+    "skipLibCheck": false
   },
   "extends": "../../tsconfig.options.json",
   "include": [
     "src/**/*",
-    "tests/**/*",
+    "tests/**/*"
   ]
-}
+}