@pothos/plugin-drizzle 0.18.1 → 0.19.1

package/src/field-builder.ts

@@ -1,13 +1,20 @@
 import type { FieldRef, MaybePromise } from '@pothos/core';
-import { type FieldKind, ObjectRef, RootFieldBuilder, type SchemaTypes } from '@pothos/core';
+import {
+  type FieldKind,
+  isThenable,
+  ObjectRef,
+  RootFieldBuilder,
+  type SchemaTypes,
+} from '@pothos/core';
 import type { TableRelationalConfig } from 'drizzle-orm';
 import type { GraphQLResolveInfo } from 'graphql';
-import { isInterfaceType, isObjectType, Kind } from 'graphql';
+import { getNamedType, isInterfaceType, isObjectType, Kind } from 'graphql';
 import type { DrizzleRef } from './interface-ref.js';
 import type { DrizzleConnectionFieldOptions } from './types.js';
+import type { DrizzlePlan } from './utils/adapter.js';
 import { getSchemaConfig } from './utils/config.js';
 import { resolveDrizzleCursorConnection } from './utils/cursors.js';
-import { queryFromInfo } from './utils/map-query.js';
+import { planFromInfo, queryFromPlan } from './utils/map-query.js';
 import { getRefFromModel } from './utils/refs.js';
 import type { SelectionMap } from './utils/selections.js';
 
@@ -17,34 +24,56 @@ const fieldBuilderProto = RootFieldBuilder.prototype as PothosSchemaTypes.RootFi
   FieldKind
 >;
 
-fieldBuilderProto.drizzleField = function drizzleField({ type, resolve, ...options }) {
+type DrizzleFieldType =
+  | ObjectRef<SchemaTypes, unknown>
+  | [ObjectRef<SchemaTypes, unknown> | string];
+
+/** The `type` of a `drizzleField`, with a table name resolved to its ref, list-ness kept. */
+function refForType(
+  builder: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
+  type: DrizzleFieldType | string,
+) {
   const modelOrRef = Array.isArray(type) ? type[0] : type;
   const typeRef =
     typeof modelOrRef === 'string'
-      ? getRefFromModel(modelOrRef, this.builder)
+      ? getRefFromModel(modelOrRef, builder)
       : (modelOrRef as ObjectRef<SchemaTypes, unknown>);
-  const typeParam = Array.isArray(type)
-    ? ([typeRef] as [ObjectRef<SchemaTypes, unknown>])
-    : typeRef;
+
+  return Array.isArray(type) ? ([typeRef] as [ObjectRef<SchemaTypes, unknown>]) : typeRef;
+}
+
+/**
+ * The resolver of a `drizzleField`: the plan for the field, then the user's resolver with a query
+ * builder over it. A promise while a selection beneath the field is async, so the resolver runs
+ * once the plan has settled and the builder it is handed never returns one. Built once per field,
+ * so a synchronous plan allocates nothing but the builder itself.
+ */
+function planResolver(
+  builder: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
+  resolve: (...args: unknown[]) => unknown,
+) {
+  const run = (
+    plan: DrizzlePlan | undefined,
+    parent: unknown,
+    args: unknown,
+    context: {},
+    info: GraphQLResolveInfo,
+  ) => resolve((select?: SelectionMap) => queryFromPlan(plan, select), parent, args, context, info);
+
+  return (parent: unknown, args: unknown, context: {}, info: GraphQLResolveInfo) => {
+    const plan = planFromInfo({ config: getSchemaConfig(builder), context, info });
+
+    return isThenable(plan)
+      ? plan.then((settled) => run(settled as DrizzlePlan | undefined, parent, args, context, info))
+      : run(plan, parent, args, context, info);
+  };
+}
+
+fieldBuilderProto.drizzleField = function drizzleField({ type, resolve, ...options }) {
   return this.field({
     ...(options as {}),
-    type: typeParam,
-    resolve: (parent: unknown, args: unknown, context: {}, info: GraphQLResolveInfo) => {
-      return resolve(
-        (select) =>
-          queryFromInfo({
-            config: getSchemaConfig(this.builder),
-            context,
-            select,
-            info,
-            // withUsageCheck: !!this.builder.options.drizzle?.onUnusedQuery,
-          }) as never,
-        parent,
-        args as never,
-        context,
-        info,
-      ) as never;
-    },
+    type: refForType(this.builder, type as DrizzleFieldType),
+    resolve: planResolver(this.builder, resolve as never),
   }) as never;
 };
 
@@ -54,38 +83,14 @@ fieldBuilderProto.drizzleFieldWithInput = function drizzleFieldWithInput(
     type,
     resolve,
     ...options
-  }: { type: ObjectRef<SchemaTypes, unknown> | [string]; resolve: (...args: unknown[]) => unknown },
+  }: { type: DrizzleFieldType; resolve: (...args: unknown[]) => unknown },
 ) {
-  const modelOrRef = Array.isArray(type) ? type[0] : type;
-  const typeRef =
-    typeof modelOrRef === 'string'
-      ? getRefFromModel(modelOrRef, this.builder)
-      : (modelOrRef as ObjectRef<SchemaTypes, unknown>);
-  const typeParam = Array.isArray(type)
-    ? ([typeRef] as [ObjectRef<SchemaTypes, unknown>])
-    : typeRef;
-
   return (
     this as typeof fieldBuilderProto & { fieldWithInput: typeof fieldBuilderProto.field }
   ).fieldWithInput({
     ...(options as {}),
-    type: typeParam,
-    resolve: (parent: unknown, args: unknown, context: {}, info: GraphQLResolveInfo) => {
-      return resolve(
-        (select: SelectionMap) =>
-          queryFromInfo({
-            config: getSchemaConfig(this.builder),
-            context,
-            select,
-            info,
-            // withUsageCheck: !!this.builder.options.drizzle?.onUnusedQuery,
-          }),
-        parent,
-        args as never,
-        context,
-        info,
-      ) as never;
-    },
+    type: refForType(this.builder, type),
+    resolve: planResolver(this.builder, resolve),
   }) as never;
 } as never;
 
@@ -121,6 +126,38 @@ fieldBuilderProto.drizzleConnection = function drizzleConnection<
   const ref = typeof type === 'string' ? getRefFromModel(type, this.builder) : type;
   const typeName = this.builder.configStore.getTypeConfig(ref).name;
   const tableName = typeof type === 'string' ? type : (ref as DrizzleRef<SchemaTypes>).tableName;
+
+  // Built once per field: resolving with a synchronous plan allocates nothing beyond the
+  // callback `resolveDrizzleCursorConnection` was already handed.
+  const resolveConnection = (
+    plan: DrizzlePlan | undefined,
+    parent: unknown,
+    args: PothosSchemaTypes.DefaultConnectionArguments,
+    context: {},
+    info: GraphQLResolveInfo,
+    totalCountOnly: boolean,
+  ) =>
+    resolveDrizzleCursorConnection(
+      tableName,
+      plan,
+      getSchemaConfig(this.builder),
+      {
+        ctx: context,
+        maxSize,
+        defaultSize,
+        args,
+        totalCount: totalCount && (() => totalCount(parent, args as never, context, info)),
+      },
+      (q) => {
+        if (totalCountOnly) {
+          return [];
+        }
+
+        return resolve(q as never, parent, args as never, context, info) as never;
+      },
+      parent,
+    );
+
   const fieldRef = (
     this as typeof fieldBuilderProto & {
       connection: (...args: unknown[]) => FieldRef<SchemaTypes, unknown>;
@@ -135,7 +172,7 @@ fieldBuilderProto.drizzleConnection = function drizzleConnection<
         context: {},
         info: GraphQLResolveInfo,
       ) => {
-        const returnType = info.returnType;
+        const returnType = getNamedType(info.returnType);
         const fields =
           isObjectType(returnType) || isInterfaceType(returnType) ? returnType.getFields() : {};
 
@@ -150,32 +187,28 @@ fieldBuilderProto.drizzleConnection = function drizzleConnection<
           ),
         );
 
-        return resolveDrizzleCursorConnection(
-          tableName,
+        // Planned before the resolver runs, so the builder it is handed is synchronous even when
+        // a selection beneath the connection is async.
+        const plan = planFromInfo({
+          config: getSchemaConfig(this.builder),
+          context,
           info,
+          paths: [['nodes'], ['edges', 'node']],
           typeName,
-          getSchemaConfig(this.builder),
-          {
-            ctx: context,
-            maxSize,
-            defaultSize,
-            args,
-            totalCount: totalCount && (() => totalCount(parent, args as never, context, info)),
-          },
-          (q) => {
-            if (totalCountOnly) {
-              return [];
-            }
-
-            // return checkIfQueryIsUsed(
-            //   this.builder,
-            //   query,
-            //   info,
-            return resolve(q as never, parent, args as never, context, info) as never;
-            // );
-          },
-          parent,
-        );
+        });
+
+        return isThenable(plan)
+          ? plan.then((settled) =>
+              resolveConnection(
+                settled as DrizzlePlan | undefined,
+                parent,
+                args,
+                context,
+                info,
+                totalCountOnly,
+              ),
+            )
+          : resolveConnection(plan, parent, args, context, info, totalCountOnly);
       },
     },
     connectionOptions instanceof ObjectRef

package/src/global-types.ts

@@ -184,38 +184,6 @@ declare global {
         type: Type,
         fields: (t: DrizzleObjectFieldBuilder<Types, TableConfig, Shape>) => FieldMap,
       ) => void;
-
-      // drizzleGraphQLOrderBy: 'addGraphQL' extends PluginName
-      //   ? <Table extends keyof Types['DrizzleRelations']>(
-      //       table: Table,
-      //       type: GraphQLInputObjectType,
-      //       ...args: NormalizeArgs<[options: AddGraphQLInputTypeOptions<Types, {}>]>
-      //     ) => InputObjectRef<Types, SQL | SQL[]>
-      //   : '@pothos/plugin-add-graphql is required to use this method';
-
-      // drizzleGraphQLFilters: 'addGraphQL' extends PluginName
-      //   ? <Table extends keyof Types['DrizzleRelations']>(
-      //       table: Table,
-      //       type: GraphQLInputObjectType,
-      //       ...args: NormalizeArgs<[options: AddGraphQLInputTypeOptions<Types, {}>]>
-      //     ) => InputObjectRef<Types, SQL>
-      //   : '@pothos/plugin-add-graphql is required to use this method';
-
-      // drizzleGraphQLInsert: 'addGraphQL' extends PluginName
-      //   ? <Table extends keyof Types['DrizzleRelations']>(
-      //       table: Table,
-      //       type: GraphQLInputObjectType,
-      //       ...args: NormalizeArgs<[options: AddGraphQLInputTypeOptions<Types, {}>]>
-      //     ) => InputObjectRef<Types, Record<string, unknown>>
-      //   : '@pothos/plugin-add-graphql is required to use this method';
-
-      // drizzleGraphQLUpdate: 'addGraphQL' extends PluginName
-      //   ? <Table extends keyof Types['DrizzleRelations']>(
-      //       table: Table,
-      //       type: GraphQLInputObjectType,
-      //       ...args: NormalizeArgs<[options: AddGraphQLInputTypeOptions<Types, {}>]>
-      //     ) => InputObjectRef<Types, Record<string, unknown>>
-      //   : '@pothos/plugin-add-graphql is required to use this method';
     }
 
     export interface PothosKindToGraphQLType {

package/src/index.ts

@@ -3,14 +3,17 @@ import './field-builder.js';
 import './schema-builder.js';
 import SchemaBuilder, {
   BasePlugin,
+  completeValue,
   type PothosOutputFieldConfig,
   PothosSchemaError,
   type PothosTypeConfig,
   type SchemaTypes,
 } from '@pothos/core';
-import type { GraphQLFieldResolver } from 'graphql';
+import { getLoaderMapping, setFieldMapping } from '@pothos/selection-mapper';
+import type { TableRelationalConfig } from 'drizzle-orm';
+import type { GraphQLFieldResolver, GraphQLResolveInfo } from 'graphql';
 import type { ModelLoader } from './model-loader.js';
-import { getLoaderMapping, setLoaderMappings } from './utils/loader-map.js';
+import type { PathInfo } from './types.js';
 
 export { drizzleConnectionHelpers } from './connection-helpers.js';
 export { DrizzleObjectFieldBuilder } from './drizzle-field-builder.js';
@@ -23,29 +26,31 @@ const pluginName = 'drizzle';
 export default pluginName;
 
 export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
-  // private mappingCache = new Map<
-  //   string,
-  //   InputTypeFieldsMapping<Types, DrizzleGraphQLInputExtensions>
-  // >();
   override onTypeConfig(typeConfig: PothosTypeConfig): PothosTypeConfig {
     if (typeConfig.kind !== 'Object' && typeConfig.kind !== 'Interface') {
       return typeConfig;
     }
 
     let model = typeConfig.extensions?.pothosDrizzleModel as string | undefined;
+    let table = typeConfig.extensions?.pothosDrizzleTable as TableRelationalConfig | undefined;
 
     for (const iface of typeConfig.interfaces) {
-      const interfaceModel = this.buildCache.getTypeConfig(iface, 'Interface').extensions
-        ?.pothosDrizzleModel as string | undefined;
+      const interfaceConfig = this.buildCache.getTypeConfig(iface, 'Interface');
+      const interfaceModel = interfaceConfig.extensions?.pothosDrizzleModel as string | undefined;
 
       if (interfaceModel) {
         if (model && model !== interfaceModel) {
           throw new PothosSchemaError(
-            `DrizzleObjects must be based on the same prisma model as any DrizzleInterfaces they extend. ${typeConfig.name} uses ${model} and ${iface.name} uses ${interfaceModel}`,
+            `DrizzleObjects must be based on the same drizzle table as any DrizzleInterfaces they extend. ${typeConfig.name} uses ${model} and ${iface.name} uses ${interfaceModel}`,
           );
         }
 
         model = interfaceModel;
+        // A plain object type implementing a drizzle interface is walked with the interface's
+        // table, so fragments on it plan the relations it inherits.
+        table ??= interfaceConfig.extensions?.pothosDrizzleTable as
+          | TableRelationalConfig
+          | undefined;
       }
     }
 
@@ -54,6 +59,7 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
       extensions: {
         ...typeConfig.extensions,
         pothosDrizzleModel: model,
+        pothosDrizzleTable: table,
       },
     };
   }
@@ -61,49 +67,6 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
   override onOutputFieldConfig(
     fieldConfig: PothosOutputFieldConfig<Types>,
   ): PothosOutputFieldConfig<Types> | null {
-    // const argMappings = mapInputFields<Types, DrizzleGraphQLInputExtensions>(
-    //   fieldConfig.args,
-    //   this.buildCache,
-    //   (inputField) => {
-    //     if (inputField.type.kind === 'InputObject') {
-    //       const config = this.buildCache.getTypeConfig(inputField.type.ref);
-
-    //       return (config.extensions?.drizzleGraphQL as DrizzleGraphQLInputExtensions) ?? null;
-    //     }
-
-    //     return null;
-    //   },
-    //   this.mappingCache,
-    // );
-
-    // const argMapper = argMappings
-    //   ? createInputValueMapper(argMappings, (input, mappings) => {
-    //       if (!mappings.value) {
-    //         return input;
-    //       }
-
-    //       const { table, tableConfig, inputType } = mappings.value;
-
-    //       switch (inputType) {
-    //         case 'orderBy':
-    //           return extractOrderBy(tableConfig, input as never);
-    //         case 'filters':
-    //           return extractFilters(tableConfig, table, input as never);
-    //         case 'insert':
-    //           return remapFromGraphQLSingleInput(input as never, tableConfig);
-    //         case 'update':
-    //           return remapFromGraphQLSingleInput(input as never, tableConfig);
-
-    //         default:
-    //           throw new Error(`Unknown drizzle input type: ${inputType}`);
-    //       }
-    //     })
-    //   : null;
-
-    // const argMappers: typeof fieldConfig.argMappers = argMapper
-    //   ? [...(fieldConfig.argMappers ?? []), (args) => argMapper(args, undefined)]
-    //   : fieldConfig.argMappers;
-
     if (
       fieldConfig.kind === 'DrizzleObject' &&
       fieldConfig.pothosOptions.select &&
@@ -112,7 +75,6 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
       const { select } = fieldConfig.pothosOptions;
       return {
         ...fieldConfig,
-        // argMappers,
         extensions: {
           ...fieldConfig.extensions,
           pothosDrizzleSelect:
@@ -122,21 +84,18 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
                   ctx: Types['Context'],
                   nestedQuery: (query: unknown, path?: string[]) => never,
                   _resolveSelection: unknown,
-                  pathInfo: import('./types').PathInfo,
+                  pathInfo: PathInfo,
                 ) => {
-                  // Attach PathInfo properties to nestedQuery for t.field select callbacks
-                  const nestedQueryWithPath = Object.assign(nestedQuery, {
-                    path: pathInfo.path,
-                    segments: pathInfo.segments,
-                  });
-                  return {
-                    columns: {},
-                    ...(select as (args: unknown, ctx: unknown, nestedQuery: unknown) => {})(
+                  // A field's select also reads its metadata from the nested selection function.
+                  const nestedQueryWithPath = Object.assign(nestedQuery, pathInfo);
+                  return completeValue(
+                    (select as (args: unknown, ctx: unknown, nestedQuery: unknown) => {} | null)(
                       args,
                       ctx,
                       nestedQueryWithPath,
                     ),
-                  };
+                    wrapSelect,
+                  );
                 }
               : {
                   columns: {},
@@ -148,7 +107,6 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
 
     return {
       ...fieldConfig,
-      // argMappers,
     };
   }
 
@@ -161,6 +119,12 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
     }
 
     const parentConfig = this.buildCache.getTypeConfig(fieldConfig.parentType);
+    // A field can declare how to tell whether its data is already on the parent row. When the
+    // row was not loaded from the planned query (a resolver returned a row it fetched itself),
+    // the mapping alone is not proof, and the field falls back to the model loader.
+    const loadedCheck = fieldConfig.extensions?.pothosDrizzleLoaded as
+      | ((value: unknown, info: GraphQLResolveInfo, context: object) => boolean)
+      | undefined;
 
     const parentTypes = new Set([fieldConfig.parentType]);
 
@@ -182,19 +146,24 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
     }
 
     return (parent, args, context, info) => {
-      let mapping = getLoaderMapping(context, info.path, info.parentType.name);
+      // Asked of the row: a mapping recorded for this row wins over the plan's, which answers
+      // for the rows the planned query loaded.
+      let mapping = getLoaderMapping(context, info.path, info.parentType.name, parent);
 
       if (!mapping) {
         for (const parentType of parentTypes) {
-          mapping = getLoaderMapping(context, info.path, parentType);
+          mapping = getLoaderMapping(context, info.path, parentType, parent);
           if (mapping) {
             break;
           }
         }
       }
 
-      if (mapping) {
-        setLoaderMappings(context, info, mapping);
+      if ((!loadedCheck || loadedCheck(parent, info, context)) && mapping) {
+        // Recorded under the field's own parent type as well, so its resolver finds the pathInfo
+        // it was planned with, whichever same-model type the plan was made for. Against the row
+        // it resolves with: a sibling row of the same list may have been loaded by another plan.
+        setFieldMapping(context, info, mapping, parent);
 
         return resolver(parent, args, context, info);
       }
@@ -206,4 +175,9 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
   }
 }
 
+/** A falsy selection means the field selects nothing from the parent row. */
+function wrapSelect(selected: {} | null) {
+  return selected ? { columns: {}, ...selected } : null;
+}
+
 SchemaBuilder.registerPlugin(pluginName, PothosDrizzlePlugin, {});