import { FetchResponse } from '@mswjs/interceptors'; import { Iterable, AsyncIterable } from './utils/internal/isIterable.js'; import { MaybePromise, NoInfer } from './typeUtils.js'; import { OperationTypeNode, DocumentNode, GraphQLError } from 'graphql'; import { Match, Path } from './utils/matching/matchRequestUrl.js'; interface HandlersExecutionResult { handler: RequestHandler; parsedResult?: any; response?: Response; } interface ResponseResolutionContext { baseUrl?: string; } /** * Executes the list of request handlers against the given request. * Returns the execution result object containing any matching request * handler and any mocked response it returned. */ declare const executeHandlers: >({ request, requestId, handlers, resolutionContext, }: { request: Request; requestId: string; handlers: Handlers; resolutionContext?: ResponseResolutionContext; }) => Promise; interface ParsedGraphQLQuery { operationType: OperationTypeNode; operationName?: string; } type ParsedGraphQLRequest = (ParsedGraphQLQuery & { query: string; variables?: VariablesType; }) | undefined; declare function parseDocumentNode(node: DocumentNode): ParsedGraphQLQuery; type GraphQLParsedOperationsMap = Record; type GraphQLMultipartRequestBody = { operations: string; map?: string; } & { [fileName: string]: File; }; /** * Determines if a given request can be considered a GraphQL request. * Does not parse the query and does not guarantee its validity. */ declare function parseGraphQLRequest(request: Request): Promise; type ExpectedOperationTypeNode = OperationTypeNode | 'all'; type GraphQLHandlerNameSelector = DocumentNode | RegExp | string; type GraphQLQuery = Record | null; type GraphQLVariables = Record; interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo { operationType: ExpectedOperationTypeNode; operationName: GraphQLHandlerNameSelector; } type GraphQLRequestParsedResult = { match: Match; cookies: Record; } & (ParsedGraphQLRequest /** * An empty version of the ParsedGraphQLRequest * which simplifies the return type of the resolver * when the request is to a non-matching endpoint */ | { operationType?: undefined; operationName?: undefined; query?: undefined; variables?: undefined; }); type GraphQLResolverExtras = { query: string; operationName: string; variables: Variables; cookies: Record; }; type GraphQLRequestBody = GraphQLJsonRequestBody | GraphQLMultipartRequestBody | Record | undefined; interface GraphQLJsonRequestBody { query: string; variables?: Variables; } type GraphQLResponseBody = { data?: BodyType | null; errors?: readonly Partial[] | null; extensions?: Record; } | null | undefined; declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode; declare class GraphQLHandler extends RequestHandler> { private endpoint; static parsedRequestCache: WeakMap>; constructor(operationType: ExpectedOperationTypeNode, operationName: GraphQLHandlerNameSelector, endpoint: Path, resolver: ResponseResolver, any, any>, options?: RequestHandlerOptions); /** * Parses the request body, once per request, cached across all * GraphQL handlers. This is done to avoid multiple parsing of the * request body, which each requires a clone of the request. */ parseGraphQLRequestOrGetFromCache(request: Request): Promise>; parse(args: { request: Request; }): Promise; predicate(args: { request: Request; parsedResult: GraphQLRequestParsedResult; }): boolean; protected extendResolverArgs(args: { request: Request; parsedResult: GraphQLRequestParsedResult; }): { query: string; operationName: string; variables: GraphQLVariables; cookies: Record; }; log(args: { request: Request; response: Response; parsedResult: GraphQLRequestParsedResult; }): Promise; } type DefaultRequestMultipartBody = Record>; type DefaultBodyType = Record | DefaultRequestMultipartBody | string | number | boolean | null | undefined; type JsonBodyType = Record | string | number | boolean | null | undefined; interface RequestHandlerDefaultInfo { header: string; } interface RequestHandlerInternalInfo { callFrame?: string; } type ResponseResolverReturnType = ([ResponseBodyType] extends [undefined] ? Response : ResponseBodyType extends GraphQLRequestBody ? HttpResponse | DefaultUnsafeFetchResponse : HttpResponse) | undefined | void; type MaybeAsyncResponseResolverReturnType = MaybePromise>; type AsyncResponseResolverReturnType = MaybePromise | Iterable, MaybeAsyncResponseResolverReturnType, MaybeAsyncResponseResolverReturnType> | AsyncIterable, MaybeAsyncResponseResolverReturnType, MaybeAsyncResponseResolverReturnType>>; type ResponseResolverInfo, RequestBodyType extends DefaultBodyType = DefaultBodyType> = { request: StrictRequest; requestId: string; } & ResolverExtraInfo; type ResponseResolver = Record, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined> = (info: ResponseResolverInfo) => AsyncResponseResolverReturnType; interface RequestHandlerArgs { info: HandlerInfo; resolver: ResponseResolver; options?: HandlerOptions; } interface RequestHandlerOptions { once?: boolean; } interface RequestHandlerExecutionResult | undefined> { handler: RequestHandler; parsedResult?: ParsedResult; request: Request; requestId: string; response?: Response; } declare abstract class RequestHandler | undefined = any, ResolverExtras extends Record = any, HandlerOptions extends RequestHandlerOptions = RequestHandlerOptions> { static cache: WeakMap, StrictRequest>; private readonly __kind; info: HandlerInfo & RequestHandlerInternalInfo; /** * Indicates whether this request handler has been used * (its resolver has successfully executed). */ isUsed: boolean; protected resolver: ResponseResolver; private resolverIterator?; private resolverIteratorResult?; private options?; constructor(args: RequestHandlerArgs); /** * Determine if the intercepted request should be mocked. */ abstract predicate(args: { request: Request; parsedResult: ParsedResult; resolutionContext?: ResponseResolutionContext; }): boolean; /** * Print out the successfully handled request. */ abstract log(args: { request: Request; response: Response; parsedResult: ParsedResult; }): void; /** * Parse the intercepted request to extract additional information from it. * Parsed result is then exposed to other methods of this request handler. */ parse(_args: { request: Request; resolutionContext?: ResponseResolutionContext; }): Promise; /** * Test if this handler matches the given request. * * This method is not used internally but is exposed * as a convenience method for consumers writing custom * handlers. */ test(args: { request: Request; resolutionContext?: ResponseResolutionContext; }): Promise; protected extendResolverArgs(_args: { request: Request; parsedResult: ParsedResult; }): ResolverExtras; private cloneRequestOrGetFromCache; /** * Execute this request handler and produce a mocked response * using the given resolver function. */ run(args: { request: StrictRequest; requestId: string; resolutionContext?: ResponseResolutionContext; }): Promise | null>; private wrapResolver; private createExecutionResult; } interface HttpResponseInit extends ResponseInit { type?: ResponseType; } declare const bodyType: unique symbol; type DefaultUnsafeFetchResponse = Response & { [bodyType]?: never; }; interface StrictRequest extends Request { json(): Promise; } /** * Opaque `Response` type that supports strict body type. * * @deprecated Please use {@link HttpResponse} instead. */ type StrictResponse = HttpResponse; /** * A drop-in replacement for the standard `Response` class * to allow additional features, like mocking the response `Set-Cookie` header. * * @example * new HttpResponse('Hello world', { status: 201 }) * HttpResponse.json({ name: 'John' }) * HttpResponse.formData(form) * * @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference} */ declare class HttpResponse extends FetchResponse { readonly [bodyType]: BodyType; constructor(body?: NoInfer | null, init?: HttpResponseInit); static error(): HttpResponse; /** * Create a `Response` with a `Content-Type: "text/plain"` body. * @example * HttpResponse.text('hello world') * HttpResponse.text('Error', { status: 500 }) */ static text(body?: NoInfer | null, init?: HttpResponseInit): HttpResponse; /** * Create a `Response` with a `Content-Type: "application/json"` body. * @example * HttpResponse.json({ firstName: 'John' }) * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 }) */ static json(body?: NoInfer | null | undefined, init?: HttpResponseInit): HttpResponse; /** * Create a `Response` with a `Content-Type: "application/xml"` body. * @example * HttpResponse.xml(``) * HttpResponse.xml(`
`, { status: 201 }) */ static xml(body?: BodyType | null, init?: HttpResponseInit): HttpResponse; /** * Create a `Response` with a `Content-Type: "text/html"` body. * @example * HttpResponse.html(`

Jane Doe

`) * HttpResponse.html(`
Main text
`, { status: 201 }) */ static html(body?: BodyType | null, init?: HttpResponseInit): HttpResponse; /** * Create a `Response` with an `ArrayBuffer` body. * @example * const buffer = new ArrayBuffer(3) * const view = new Uint8Array(buffer) * view.set([1, 2, 3]) * * HttpResponse.arrayBuffer(buffer) */ static arrayBuffer(body?: ArrayBuffer | SharedArrayBuffer, init?: HttpResponseInit): HttpResponse; /** * Create a `Response` with a `FormData` body. * @example * const data = new FormData() * data.set('name', 'Alice') * * HttpResponse.formData(data) */ static formData(body?: FormData, init?: HttpResponseInit): HttpResponse; } export { type AsyncResponseResolverReturnType as A, isDocumentNode as B, type RequestHandlerInternalInfo as C, type DefaultBodyType as D, type ExpectedOperationTypeNode as E, type ResponseResolverInfo as F, GraphQLHandler as G, type HttpResponseInit as H, type RequestHandlerArgs as I, type JsonBodyType as J, type RequestHandlerExecutionResult as K, type MaybeAsyncResponseResolverReturnType as M, type ParsedGraphQLRequest as P, RequestHandler as R, type StrictRequest as S, type ResponseResolver as a, type ResponseResolverReturnType as b, type RequestHandlerOptions as c, type DefaultRequestMultipartBody as d, type GraphQLQuery as e, type GraphQLVariables as f, type GraphQLRequestBody as g, type GraphQLJsonRequestBody as h, bodyType as i, type DefaultUnsafeFetchResponse as j, type StrictResponse as k, HttpResponse as l, type ResponseResolutionContext as m, type GraphQLHandlerNameSelector as n, type GraphQLResolverExtras as o, type GraphQLResponseBody as p, type RequestHandlerDefaultInfo as q, type HandlersExecutionResult as r, executeHandlers as s, type ParsedGraphQLQuery as t, parseDocumentNode as u, type GraphQLParsedOperationsMap as v, type GraphQLMultipartRequestBody as w, parseGraphQLRequest as x, type GraphQLHandlerInfo as y, type GraphQLRequestParsedResult as z };