refactor(drizzle): use me.user pattern for path-based filtering example

Update the path-based filtering example to use Query.viewer pattern in docs
and me.user in tests, which is clearer than the previous pendingReviewAuthor
naming.

- Removed userAdmin query field (using existing me.user pattern)
- Updated docs to show Query.viewer vs Query.user example
- Updated changeset with cleaner example
- Updated snapshot after schema change

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: hayes

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

@@ -10,12 +10,12 @@ PathInfo includes:
 
 Example usage:
 ```typescript
-postsForModeration: t.relation('posts', {
+posts: t.relation('posts', {
   query: (args, ctx, pathInfo) => {
-    // Check if we're a direct child of pendingReviewAuthor
-    const isReviewContext = pathInfo?.path?.at(-2) === 'Query.pendingReviewAuthor';
+    // Check if accessed via viewer (own profile) vs user (public)
+    const isViewerContext = pathInfo?.path?.at(-2) === 'Query.viewer';
     return {
-      where: { published: isReviewContext ? 0 : 1 },
+      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,71 +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)
-
-### Path-based filtering
-
-The query callback also receives a `pathInfo` parameter that provides information about the GraphQL
-query path. This enables filtering based on how a field is accessed in the query:
-
-```ts
-builder.drizzleObject('users', {
-  name: 'User',
-  fields: (t) => ({
-    // This field returns different results based on the query path
-    posts: t.relation('posts', {
-      query: (args, ctx, pathInfo) => {
-        // pathInfo.path = ['Query.pendingReviewAuthor', 'User.posts']
-        // Check if we're accessed via the pendingReviewAuthor query
-        const isReviewContext = pathInfo?.path?.at(-2) === 'Query.pendingReviewAuthor';
-
-        return {
-          where: {
-            // Show drafts in review context, published posts otherwise
-            published: isReviewContext ? false : true,
-          },
-          orderBy: { updatedAt: 'desc' },
-        };
-      },
-    }),
-  }),
-});
-```
-
-The `pathInfo` object contains:
-
-- `path`: Array of `"ParentType.fieldName"` strings representing the query path (e.g.,
-  `['Query.user', 'User.posts']`)
-- `segments`: Detailed info for each path segment with `field`, `alias`, `parentType`, and `isList`
-  properties
-
-This is useful when you want the same relation field to behave differently depending on the context
-in which it's queried. The `t.relatedConnection` method also supports `pathInfo` in its query
-callback.
-
-### Path info on nestedSelection
-
-When using `t.field` with a `select` callback function, path information is also available on the
-`nestedSelection` function:
-
-```ts
-builder.drizzleObject('users', {
-  name: 'User',
-  fields: (t) => ({
-    customField: t.field({
-      type: SomeType,
-      select: (args, ctx, nestedSelection) => {
-        // Access path info from the nestedSelection function
-        console.log(nestedSelection.path);     // ['Query.user', 'User.customField']
-        console.log(nestedSelection.segments); // [{ field, alias, parentType, isList }, ...]
-
-        return nestedSelection({ columns: { id: true } });
-      },
-      resolve: (parent) => parent,
-    }),
-  }),
-});
+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/tests/__snapshots__/index.test.ts.snap

@@ -143,7 +143,6 @@ type Query {
   me: Viewer
   node(id: ID!): Node
   nodes(ids: [ID!]!): [Node]!
-  pendingReviewAuthor(id: ID!): User
   post(id: ID!): Post
   postWithErrors(id: ID!): QueryPostWithErrorsResult
   posts(after: String, before: String, category: String, first: Int, invert: Boolean, last: Int, sortByCategory: Boolean): QueryPostsConnection

packages/plugin-drizzle/tests/example/schema.graphql

@@ -101,7 +101,6 @@ type Query {
   me: Viewer
   node(id: ID!): Node
   nodes(ids: [ID!]!): [Node]!
-  pendingReviewAuthor(id: ID!): User
   post(id: ID!): Post
   postWithErrors(id: ID!): QueryPostWithErrorsResult
   posts(after: String, before: String, category: String, first: Int, invert: Boolean, last: Int, sortByCategory: Boolean): QueryPostsConnection

packages/plugin-drizzle/tests/example/schema/user.ts

@@ -276,12 +276,14 @@ export const User = builder.drizzleNode('users', {
         limit: t.arg.int(),
       },
       query: (args, _ctx, pathInfo) => {
-        const isReviewContext = pathInfo?.path?.at(-2) === 'Query.pendingReviewAuthor';
+        // Check if accessed via me.user (own profile) vs user (public)
+        const isViewerContext = pathInfo?.path?.at(-2) === 'Viewer.user';
 
         return {
           limit: args.limit ?? 10,
           where: {
-            published: isReviewContext ? 0 : 1,
+            // Viewer sees their own drafts, public sees only published
+            published: isViewerContext ? 0 : 1,
           },
           orderBy: { updatedAt: 'desc' },
         };
@@ -408,25 +410,6 @@ builder.queryField('admin', (t) =>
   }),
 );
 
-// Example from GitHub issue #1596: query field for moderation context
-// When postsForModeration is accessed via this query, it shows draft posts
-// When accessed via the regular `user` query, it shows published posts
-builder.queryField('pendingReviewAuthor', (t) =>
-  t.drizzleField({
-    type: User,
-    nullable: true,
-    args: {
-      id: t.arg.globalID({ required: true }),
-    },
-    resolve: (query, _root, args) =>
-      db.query.users.findFirst(
-        query({
-          where: { id: Number(args.id.id) },
-        }),
-      ),
-  }),
-);
-
 builder.drizzleInterfaceField(Viewer, 'selfList', (t) =>
   t.relation('manySelf', {
     type: Viewer,

packages/plugin-drizzle/tests/query-path.test.ts

@@ -224,34 +224,36 @@ describe('path-based conditional filtering (GitHub #1596)', () => {
     // Via 'user' query, postsForModeration shows published posts
     expect(regularData.user.postsForModeration.length).toBeGreaterThan(0);
 
-    // Query via 'pendingReviewAuthor' - should return DRAFT (unpublished) posts only
-    const reviewResult = await execute({
+    // Query via 'me.user' (viewer context) - should return DRAFT (unpublished) posts only
+    const viewerResult = await execute({
       schema,
       document: gql`
         {
-          pendingReviewAuthor(id: "VXNlcjox") {
-            firstName
-            postsForModeration(limit: 5) {
-              id
-              title
+          me {
+            user {
+              firstName
+              postsForModeration(limit: 5) {
+                id
+                title
+              }
             }
           }
         }
       `,
       contextValue: context,
     });
 
-    expect(reviewResult.errors).toBeUndefined();
-    const reviewData = reviewResult.data as {
-      pendingReviewAuthor: { firstName: string; postsForModeration: { id: string; title: string }[] };
+    expect(viewerResult.errors).toBeUndefined();
+    const viewerData = viewerResult.data as {
+      me: { user: { firstName: string; postsForModeration: { id: string; title: string }[] } };
     };
 
-    // Via 'pendingReviewAuthor' query, postsForModeration shows draft posts
+    // Via 'me.user', postsForModeration shows draft posts (viewer's own content)
     // The same field returns different data based on the query path!
-    expect(reviewData.pendingReviewAuthor.firstName).toBe('Mason');
+    expect(viewerData.me.user.firstName).toBe('Mason');
 
     // The key insight: same field (postsForModeration) returns different results
-    // based on whether it's accessed via 'user' or 'pendingReviewAuthor'
+    // based on whether it's accessed via 'user' or 'me.user'
     // This is exactly the use case from GitHub issue #1596
   });
 });

website/content/docs/plugins/drizzle.mdx

@@ -241,6 +241,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,
@@ -264,71 +265,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)
-
-### Path-based filtering
-
-The query callback also receives a `pathInfo` parameter that provides information about the GraphQL
-query path. This enables filtering based on how a field is accessed in the query:
-
-```ts
-builder.drizzleObject('users', {
-  name: 'User',
-  fields: (t) => ({
-    // This field returns different results based on the query path
-    posts: t.relation('posts', {
-      query: (args, ctx, pathInfo) => {
-        // pathInfo.path = ['Query.pendingReviewAuthor', 'User.posts']
-        // Check if we're accessed via the pendingReviewAuthor query
-        const isReviewContext = pathInfo?.path?.at(-2) === 'Query.pendingReviewAuthor';
-
-        return {
-          where: {
-            // Show drafts in review context, published posts otherwise
-            published: isReviewContext ? false : true,
-          },
-          orderBy: { updatedAt: 'desc' },
-        };
-      },
-    }),
-  }),
-});
-```
-
-The `pathInfo` object contains:
-
-- `path`: Array of `"ParentType.fieldName"` strings representing the query path (e.g.,
-  `['Query.user', 'User.posts']`)
-- `segments`: Detailed info for each path segment with `field`, `alias`, `parentType`, and `isList`
-  properties
-
-This is useful when you want the same relation field to behave differently depending on the context
-in which it's queried. The `t.relatedConnection` method also supports `pathInfo` in its query
-callback.
-
-### Path info on nestedSelection
-
-When using `t.field` with a `select` callback function, path information is also available on the
-`nestedSelection` function:
-
-```ts
-builder.drizzleObject('users', {
-  name: 'User',
-  fields: (t) => ({
-    customField: t.field({
-      type: SomeType,
-      select: (args, ctx, nestedSelection) => {
-        // Access path info from the nestedSelection function
-        console.log(nestedSelection.path);     // ['Query.user', 'User.customField']
-        console.log(nestedSelection.segments); // [{ field, alias, parentType, isList }, ...]
-
-        return nestedSelection({ columns: { id: true } });
-      },
-      resolve: (parent) => parent,
-    }),
-  }),
-});
+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