Merge pull request #1597 from hayes/feat/drizzle-path-info

feat(plugin-drizzle): add pathInfo to query callbacks for path-based …

Author: hayes

.changeset/path-info-query-callbacks.md

@@ -0,0 +1,22 @@
+---
+"@pothos/plugin-drizzle": minor
+---
+
+Add pathInfo parameter to t.relation() and t.relatedConnection() query callbacks for path-based filtering.
+
+PathInfo includes:
+- `path`: Array of "ParentType.fieldName" strings (e.g., `['Query.user', 'User.posts']`)
+- `segments`: Detailed info for each path segment including field, alias, parentType, and isList
+
+Example usage:
+```typescript
+posts: t.relation('posts', {
+  query: (args, ctx, pathInfo) => {
+    // Check if accessed via viewer (own profile) vs user (public)
+    const isViewerContext = pathInfo?.path?.at(-2) === 'Query.viewer';
+    return {
+      where: { published: isViewerContext ? false : true },
+    };
+  },
+})
+```

packages/plugin-drizzle/README.md

@@ -228,6 +228,7 @@ builder.drizzleObject('users', {
         limit: t.arg.int(),
         offset: t.arg.int(),
       },
+      // query callback receives (args, ctx, pathInfo)
       query: (args) => ({
         limit: args.limit ?? 10,
         offset: args.offset ?? 0,
@@ -251,8 +252,9 @@ builder.drizzleObject('users', {
 ```
 
 The query API enables you to define args and convert them into parameters that will be passed into
-the relational query builder. You can read more about the relation query builder api
-[here](https://orm.drizzle.team/docs/rqb#querying)
+the relational query builder. The `query` callback receives `(args, ctx, pathInfo)` where `pathInfo`
+contains the GraphQL query path information (`path` and `segments`). You can read more about the
+relation query builder api [here](https://orm.drizzle.team/docs/rqb#querying)
 
 ## Drizzle Fields
 

packages/plugin-drizzle/src/drizzle-field-builder.ts

@@ -41,6 +41,7 @@ import type { DrizzleRef } from './interface-ref';
 import type {
   DrizzleConnectionShape,
   ListRelation,
+  PathInfo,
   RelatedConnectionOptions,
   RelatedCountOptions,
   RelatedFieldOptions,
@@ -219,9 +220,23 @@ export class DrizzleObjectFieldBuilder<
       )!;
     };
 
-    const getQuery = (args: PothosSchemaTypes.DefaultConnectionArguments, ctx: {}) => {
-      const { limit, orderBy, where, ...fieldQuery } =
-        (typeof query === 'function' ? query(args, ctx) : query) ?? {};
+    const getQuery = (
+      args: PothosSchemaTypes.DefaultConnectionArguments,
+      ctx: {},
+      pathInfo?: import('./types').PathInfo,
+    ) => {
+      const { limit, orderBy, where, ...fieldQuery } = ((typeof query === 'function'
+        ? (query as (args: {}, ctx: {}, pathInfo?: import('./types').PathInfo) => {})(
+            args,
+            ctx,
+            pathInfo,
+          )
+        : query) ?? {}) as {
+        limit?: number;
+        orderBy?: unknown;
+        where?: SQL;
+        columns?: Record<string, boolean>;
+      };
 
       const { cursorColumns, columns, ...connectionQuery } = drizzleCursorConnectionQuery({
         ctx,
@@ -255,6 +270,7 @@ export class DrizzleObjectFieldBuilder<
       context: object,
       nestedQuery: (query: unknown, path?: unknown) => { select?: object },
       getSelection: (path: string[]) => FieldNode | null,
+      pathInfo: import('./types').PathInfo,
     ) => {
       typeName ??= this.builder.configStore.getTypeConfig(ref).name;
 
@@ -279,7 +295,7 @@ export class DrizzleObjectFieldBuilder<
         };
       }
 
-      const nested = nestedQuery(getQuery(args, context).select, {
+      const nested = nestedQuery(getQuery(args, context, pathInfo).select, {
         getType: () => typeName!,
         paths: [[{ name: 'nodes' }], [{ name: 'edges' }, { name: 'node' }]],
       }) as SelectionMap;
@@ -500,14 +516,24 @@ export class DrizzleObjectFieldBuilder<
 
     const { query = {}, extensions, ...rest } = options;
 
-    const relationSelect = (args: object, context: object, nestedQuery: (query: unknown) => {}) => {
+    const relationSelect = (
+      args: object,
+      context: object,
+      nestedQuery: (query: unknown) => {},
+      _resolveSelection: unknown,
+      pathInfo: PathInfo,
+    ) => {
       const relQuery = {
         columns: {},
         with: {
           [name]: {
             ...nestedQuery(query),
             ...((typeof query === 'function'
-              ? (query as (args: {}, context: {}) => {})(args, context)
+              ? (query as (args: {}, context: {}, pathInfo: PathInfo) => {})(
+                  args,
+                  context,
+                  pathInfo,
+                )
               : query) as {}),
           },
         },

packages/plugin-drizzle/src/index.ts

@@ -121,14 +121,23 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
                   args: {},
                   ctx: Types['Context'],
                   nestedQuery: (query: unknown, path?: string[]) => never,
-                ) => ({
-                  columns: {},
-                  ...(select as (args: unknown, ctx: unknown, nestedQuery: unknown) => {})(
-                    args,
-                    ctx,
-                    nestedQuery,
-                  ),
-                })
+                  _resolveSelection: unknown,
+                  pathInfo: import('./types').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) => {})(
+                      args,
+                      ctx,
+                      nestedQueryWithPath,
+                    ),
+                  };
+                }
               : {
                   columns: {},
                   ...select,

packages/plugin-drizzle/src/types.ts

@@ -44,6 +44,18 @@ import type { DrizzleRef } from './interface-ref';
 import type { IndirectInclude } from './utils/map-query';
 import type { SelectionMap } from './utils/selections';
 
+export interface FieldPathInfo {
+  field: string;
+  alias: string;
+  parentType: string;
+  isList: boolean;
+}
+
+export interface PathInfo {
+  path: string[];
+  segments: FieldPathInfo[];
+}
+
 export type DrizzleClient<TCountSource = Table | SQL | SQLWrapper> = {
   readonly _: {
     readonly schema: unknown;
@@ -323,10 +335,11 @@ export type DrizzleObjectFieldOptions<
         | ((
             args: InputShapeFromFields<Args>,
             ctx: Types['Context'],
-            nestedSelection: <Selection extends boolean | {}>(
+            nestedSelection: (<Selection extends boolean | {}>(
               selection?: Selection,
               path?: string[],
-            ) => Selection,
+            ) => Selection) &
+              PathInfo,
           ) => DBQueryConfig<'one', Types['DrizzleRelations'], ExtractTable<Types, ParentShape>>)
       );
   };
@@ -345,6 +358,7 @@ export type DrizzleFieldSelection =
         type?: string,
       ) => DBQueryConfig<'one'> | boolean,
       resolveSelection: (path: string[]) => FieldNode | null,
+      pathInfo: PathInfo,
     ) => SelectionMap);
 
 export type ExtractTable<Types extends SchemaTypes, Shape> = Shape extends {
@@ -480,7 +494,13 @@ export type QueryForField<
         'columns' | 'extra' | 'with'
       >
 ) extends infer QueryConfig
-  ? QueryConfig | ((args: InputShapeFromFields<Args>, context: Types['Context']) => QueryConfig)
+  ?
+      | QueryConfig
+      | ((
+          args: InputShapeFromFields<Args>,
+          context: Types['Context'],
+          pathInfo: PathInfo,
+        ) => QueryConfig)
   : never;
 
 export type QueryForDrizzleField<
@@ -503,7 +523,7 @@ export type QueryForRelatedConnection<
 > & {
   orderBy?: ConnectionOrderBy<Table> | ((table: Table) => ConnectionOrderBy<Table>);
 } extends infer QueryConfig
-  ? QueryConfig | ((args: Args, context: Types['Context']) => QueryConfig)
+  ? QueryConfig | ((args: Args, context: Types['Context'], pathInfo: PathInfo) => QueryConfig)
   : never;
 
 export type QueryForDrizzleConnection<