feat: custom request predicate function

src/core/graphql.ts

@@ -11,6 +11,7 @@ import {
   GraphQLResolverExtras,
   GraphQLResponseBody,
   GraphQLQuery,
+  GraphQLCustomPredicate,
 } from './handlers/GraphQLHandler'
 import type { Path } from './utils/matching/matchRequestUrl'
 
@@ -30,7 +31,8 @@ export type GraphQLRequestHandler = <
   operationName:
     | GraphQLHandlerNameSelector
     | DocumentNode
-    | TypedDocumentNode<Query, Variables>,
+    | TypedDocumentNode<Query, Variables>
+    | GraphQLCustomPredicate<GraphQLVariables>,
   resolver: GraphQLResponseResolver<
     [Query] extends [never] ? GraphQLQuery : Query,
     Variables
@@ -52,6 +54,12 @@ function createScopedGraphQLHandler(
   url: Path,
 ): GraphQLRequestHandler {
   return (operationName, resolver, options = {}) => {
+    if (typeof operationName === 'function') {
+      return new GraphQLHandler(operationType, '', url, resolver, {
+        ...options,
+        predicate: operationName,
+      })
+    }
     return new GraphQLHandler(
       operationType,
       operationName,

src/core/handlers/GraphQLHandler.test.ts

@@ -557,13 +557,13 @@ describe('predicate', () => {
     })
 
     expect(
-      handler.predicate({
+      await handler.predicate({
         request,
         parsedResult: await handler.parse({ request }),
       }),
     ).toBe(true)
     expect(
-      handler.predicate({
+      await handler.predicate({
         request: alienRequest,
         parsedResult: await handler.parse({ request: alienRequest }),
       }),
@@ -591,13 +591,13 @@ describe('predicate', () => {
     })
 
     expect(
-      handler.predicate({
+      await handler.predicate({
         request,
         parsedResult: await handler.parse({ request }),
       }),
     ).toBe(true)
     expect(
-      handler.predicate({
+      await handler.predicate({
         request: alienRequest,
         parsedResult: await handler.parse({ request: alienRequest }),
       }),
@@ -618,7 +618,7 @@ describe('predicate', () => {
     })
 
     expect(
-      handler.predicate({
+      await handler.predicate({
         request,
         parsedResult: await handler.parse({ request }),
       }),
@@ -643,13 +643,13 @@ describe('predicate', () => {
     })
 
     expect(
-      handler.predicate({
+      await handler.predicate({
         request,
         parsedResult: await handler.parse({ request }),
       }),
     ).toBe(true)
     expect(
-      handler.predicate({
+      await handler.predicate({
         request: alienRequest,
         parsedResult: await handler.parse({ request: alienRequest }),
       }),
@@ -836,3 +836,123 @@ describe('request', () => {
     )
   })
 })
+
+describe('custom predicate', () => {
+  test('receives cookies parameter', async () => {
+    let receivedCookies: Record<string, string> | undefined
+    const handler = new GraphQLHandler(
+      OperationTypeNode.QUERY,
+      '',
+      '*',
+      resolver,
+      {
+        predicate: ({ cookies }) => {
+          receivedCookies = cookies
+          return true
+        },
+      },
+    )
+    const request = createPostGraphQLRequest(
+      {
+        query: GET_USER,
+        variables: { userId: 'abc-123' },
+      },
+      'https://example.com',
+    )
+    request.headers.set('Cookie', 'token=secret')
+    const requestId = createRequestId()
+    await handler.run({ request, requestId })
+    expect(receivedCookies).toEqual({ token: 'secret' })
+  })
+
+  test('receives query parameter', async () => {
+    let receivedQuery = ''
+    const handler = new GraphQLHandler(
+      OperationTypeNode.QUERY,
+      '',
+      '*',
+      resolver,
+      {
+        predicate: ({ query }) => {
+          receivedQuery = query
+          return true
+        },
+      },
+    )
+    const request = createPostGraphQLRequest({
+      query: GET_USER,
+      variables: { userId: 'abc-123' },
+    })
+    const requestId = createRequestId()
+    await handler.run({ request, requestId })
+    expect(receivedQuery).toBe(GET_USER)
+  })
+
+  test('receives operationName parameter', async () => {
+    let receivedOperationName = ''
+    const handler = new GraphQLHandler(
+      OperationTypeNode.QUERY,
+      '',
+      '*',
+      resolver,
+      {
+        predicate: ({ operationName }) => {
+          receivedOperationName = operationName
+          return true
+        },
+      },
+    )
+    const request = createPostGraphQLRequest({
+      query: GET_USER,
+      variables: { userId: 'abc-123' },
+    })
+    const requestId = createRequestId()
+    await handler.run({ request, requestId })
+    expect(receivedOperationName).toBe('GetUser')
+  })
+
+  test('does not match if custom predicate returns true', async () => {
+    const handler = new GraphQLHandler(
+      OperationTypeNode.QUERY,
+      '',
+      '*',
+      resolver,
+      {
+        predicate: async ({ variables }) => {
+          return variables?.userId === 'abc-123'
+        },
+      },
+    )
+    const request = createPostGraphQLRequest({
+      query: GET_USER,
+      variables: { userId: 'abc-123' },
+    })
+    const requestId = createRequestId()
+    const result = await handler.run({ request, requestId })
+    expect(result?.response).toBeDefined()
+    expect(await result?.response?.json()).toEqual({
+      data: { user: { id: 'abc-123' } },
+    })
+  })
+
+  test('does not match if custom predicate returns false', async () => {
+    const handler = new GraphQLHandler(
+      OperationTypeNode.QUERY,
+      '',
+      '*',
+      resolver,
+      {
+        predicate: async ({ variables }) => {
+          return variables?.userId === 'not-match'
+        },
+      },
+    )
+    const request = createPostGraphQLRequest({
+      query: GET_USER,
+      variables: { userId: 'abc-123' },
+    })
+    const requestId = createRequestId()
+    const result = await handler.run({ request, requestId })
+    expect(result).toBeNull()
+  })
+})

src/core/handlers/GraphQLHandler.ts

@@ -76,6 +76,14 @@ export type GraphQLResponseBody<BodyType extends DefaultBodyType> =
   | null
   | undefined
 
+export type GraphQLCustomPredicate<GraphQLVariables> = (args: {
+  request: Request
+  query: string
+  operationName: string
+  variables: GraphQLVariables
+  cookies: Record<string, string>
+}) => boolean | Promise<boolean>
+
 export function isDocumentNode(
   value: DocumentNode | any,
 ): value is DocumentNode {
@@ -92,6 +100,7 @@ export class GraphQLHandler extends RequestHandler<
   GraphQLResolverExtras<any>
 > {
   private endpoint: Path
+  private customPredicate?: GraphQLCustomPredicate<GraphQLVariables>
 
   static parsedRequestCache = new WeakMap<
     Request,
@@ -103,7 +112,9 @@ export class GraphQLHandler extends RequestHandler<
     operationName: GraphQLHandlerNameSelector,
     endpoint: Path,
     resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>,
-    options?: RequestHandlerOptions,
+    options?: RequestHandlerOptions & {
+      predicate?: GraphQLCustomPredicate<GraphQLVariables>
+    },
   ) {
     let resolvedOperationName = operationName
 
@@ -140,6 +151,7 @@ export class GraphQLHandler extends RequestHandler<
       options,
     })
 
+    this.customPredicate = options?.predicate
     this.endpoint = endpoint
   }
 
@@ -195,33 +207,42 @@ export class GraphQLHandler extends RequestHandler<
     }
   }
 
-  predicate(args: {
+  async predicate(args: {
     request: Request
     parsedResult: GraphQLRequestParsedResult
-  }) {
+  }): Promise<boolean> {
+    if (this.customPredicate) {
+      // Clone the request to avoid locking its body stream.
+      // The body can only be read once, so cloning allows both
+      // the predicate and resolver to access it independently.
+      const clonedRequest = args.request.clone()
+
+      return await this.customPredicate({
+        request: clonedRequest,
+        ...this.extendResolverArgs({
+          request: clonedRequest,
+          parsedResult: args.parsedResult,
+        }),
+      })
+    }
     if (args.parsedResult.operationType === undefined) {
       return false
     }
-
     if (!args.parsedResult.operationName && this.info.operationType !== 'all') {
       const publicUrl = toPublicUrl(args.request.url)
-
       devUtils.warn(`\
 Failed to intercept a GraphQL request at "${args.request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
 
 Consider naming this operation or using "graphql.operation()" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/#graphqloperationresolver`)
       return false
     }
-
     const hasMatchingOperationType =
       this.info.operationType === 'all' ||
       args.parsedResult.operationType === this.info.operationType
-
     const hasMatchingOperationName =
       this.info.operationName instanceof RegExp
         ? this.info.operationName.test(args.parsedResult.operationName || '')
         : args.parsedResult.operationName === this.info.operationName
-
     return (
       args.parsedResult.match.matches &&
       hasMatchingOperationType &&