msw 2.15.0 → 3.0.0

package/lib/graphql/index.js

@@ -0,0 +1,1244 @@
+import { a as matchRequestUrl, m as devUtils, n as jsonParse, r as toPublicUrl, s as getTimestamp } from "../_chunks/cookie-store.js";
+import { t as RequestHandler } from "../_chunks/request-handler.js";
+import { a as serializeRequest, i as serializeResponse, o as getStatusCodeColor, r as getAllRequestCookies } from "../_chunks/http-handler.js";
+import { t as http } from "../_chunks/http.js";
+import { a as WebSocketHandler, s as kConnect, t as attachSiblingHandlers } from "../_chunks/attach-sibling-handlers.js";
+import { t as colors } from "../_chunks/colors.js";
+import { n as webSocketUpgrade } from "../_chunks/websocket-upgrade.js";
+import { n as kDefaultContentType } from "../_chunks/symbols.js";
+import { invariant } from "outvariant";
+import { createRequestId, resolveWebSocketUrl } from "@mswjs/interceptors";
+import { Emitter, TypedEvent } from "rettime";
+import { OperationTypeNode, parse } from "graphql";
+import { stringToHeaders } from "headers-polyfill";
+//#region src/core/utils/internal/parse-multipart-data.ts
+function parseContentHeaders(headersString) {
+	const headers = stringToHeaders(headersString);
+	const contentType = headers.get("content-type") || "text/plain";
+	const disposition = headers.get("content-disposition");
+	if (!disposition) throw new Error("\"Content-Disposition\" header is required.");
+	const directives = disposition.split(";").reduce((acc, chunk) => {
+		const [name, ...rest] = chunk.trim().split("=");
+		acc[name] = rest.join("=");
+		return acc;
+	}, {});
+	return {
+		name: directives.name?.slice(1, -1),
+		filename: directives.filename?.slice(1, -1),
+		contentType
+	};
+}
+/**
+* Parses a given string as a multipart/form-data.
+* Does not throw an exception on an invalid multipart string.
+*/
+function parseMultipartData(data, headers) {
+	const contentType = headers?.get("content-type");
+	if (!contentType) return;
+	const [, ...directives] = contentType.split(/; */);
+	const boundary = directives.filter((d) => d.startsWith("boundary=")).map((s) => s.replace(/^boundary=/, ""))[0];
+	if (!boundary) return;
+	const boundaryRegExp = new RegExp(`--+${boundary.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`);
+	const fields = data.split(boundaryRegExp).filter((chunk) => chunk.startsWith("\r\n") && chunk.endsWith("\r\n")).map((chunk) => chunk.trimStart().replace(/\r\n$/, ""));
+	if (!fields.length) return;
+	const parsedBody = {};
+	try {
+		for (const field of fields) {
+			const [contentHeaders, ...rest] = field.split("\r\n\r\n");
+			const contentBody = rest.join("\r\n\r\n");
+			const { contentType, filename, name } = parseContentHeaders(contentHeaders);
+			const value = filename === void 0 ? contentBody : new File([contentBody], filename, { type: contentType });
+			const parsedValue = parsedBody[name];
+			if (parsedValue === void 0) parsedBody[name] = value;
+			else if (Array.isArray(parsedValue)) parsedBody[name] = [...parsedValue, value];
+			else parsedBody[name] = [parsedValue, value];
+		}
+		return parsedBody;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/graphql/parse-graphql-request.ts
+function parseDocumentNode(node, operationName) {
+	const operationDefs = node.definitions.filter((definition) => {
+		return definition.kind === "OperationDefinition";
+	});
+	/**
+	* @note A document may bundle multiple operations (e.g. the ones
+	* emitted by GraphQL Code Generator). Honor the requested operation
+	* name, and resolve nothing if the document has no such operation.
+	* Falling back to the first operation would silently resolve one the
+	* client never asked for.
+	*/
+	const operationDef = operationName ? operationDefs.find((definition) => {
+		return definition.name?.value === operationName;
+	}) : operationDefs[0];
+	return {
+		operationType: operationDef?.operation,
+		/**
+		* @note Echo the requested operation name even when the document
+		* has no such operation. It makes the "unhandled operation" warnings
+		* name the operation the client actually asked for.
+		*/
+		operationName: operationDef?.name?.value || operationName || void 0
+	};
+}
+async function parseQuery(query, operationName) {
+	try {
+		return parseDocumentNode(parse(query), operationName);
+	} catch (error) {
+		return error;
+	}
+}
+function extractMultipartVariables(variables, map, files) {
+	const operations = { variables };
+	for (const [key, pathArray] of Object.entries(map)) {
+		if (!(key in files)) throw new Error(`Given files do not have a key '${key}' .`);
+		for (const dotPath of pathArray) {
+			const [lastPath, ...reversedPaths] = dotPath.split(".").reverse();
+			const paths = reversedPaths.reverse();
+			let target = operations;
+			for (const path of paths) {
+				if (!(path in target)) throw new Error(`Property '${path}' is not in operations.`);
+				target = target[path];
+			}
+			target[lastPath] = files[key];
+		}
+	}
+	return operations.variables;
+}
+async function getGraphQLInput(request) {
+	switch (request.method) {
+		case "GET": {
+			const url = new URL(request.url);
+			const query = url.searchParams.get("query");
+			const variables = url.searchParams.get("variables") || "";
+			return {
+				query,
+				variables: jsonParse(variables),
+				operationName: url.searchParams.get("operationName")
+			};
+		}
+		case "POST": {
+			const requestClone = request.clone();
+			if (request.headers.get("content-type")?.includes("multipart/form-data")) {
+				const responseJson = parseMultipartData(await requestClone.text(), request.headers);
+				if (!responseJson) return null;
+				const { operations, map, ...files } = responseJson;
+				const parsedOperations = jsonParse(operations) || {};
+				if (!parsedOperations.query) return null;
+				const parsedMap = jsonParse(map || "") || {};
+				const variables = parsedOperations.variables ? extractMultipartVariables(parsedOperations.variables, parsedMap, files) : {};
+				return {
+					query: parsedOperations.query,
+					variables,
+					operationName: parsedOperations.operationName
+				};
+			}
+			const requestJson = await requestClone.json().catch(() => null);
+			if (requestJson?.query) {
+				const { query, variables, operationName } = requestJson;
+				return {
+					query,
+					variables,
+					operationName
+				};
+			}
+			return null;
+		}
+		default: return null;
+	}
+}
+/**
+* Determines if a given request can be considered a GraphQL request.
+* Does not parse the query and does not guarantee its validity.
+*/
+async function parseGraphQLRequest(request) {
+	const input = await getGraphQLInput(request);
+	if (!input || !input.query) return;
+	const { query, variables, operationName } = input;
+	const parsedResult = await parseQuery(query, operationName);
+	if (parsedResult instanceof Error) {
+		const requestPublicUrl = toPublicUrl(request.url);
+		throw new Error(devUtils.formatMessage("Failed to intercept a GraphQL request to \"%s %s\": cannot parse query. See the error message from the parser below.\n\n%s", request.method, requestPublicUrl, parsedResult.message));
+	}
+	return {
+		query: input.query,
+		operationType: parsedResult.operationType,
+		operationName: parsedResult.operationName,
+		variables
+	};
+}
+//#endregion
+//#region src/core/utils/request/get-all-accepted-mime-types.ts
+/**
+* Returns all accepted mime types, ordered by precedence as defined
+* in [RFC 7231 Section 5.3.2](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2).
+*
+* Precedence rules (highest to lowest):
+* 1. Quality value (`q` parameter, default 1).
+* 2. Specificity: `type/subtype` > `type/*` > `*\/*`.
+* 3. Number of media type parameters (more = more specific).
+*
+* Types with `q=0` are excluded (explicitly not acceptable).
+*/
+function getAllAcceptedMimeTypes(acceptHeader) {
+	if (acceptHeader == null) return [];
+	const accepted = [];
+	for (const part of acceptHeader.split(",")) {
+		const [type, ...params] = part.split(";").map((v) => v.trim());
+		let quality = 1;
+		let parameterCount = 0;
+		for (const param of params) {
+			const [key, value] = param.split("=").map((v) => v.trim());
+			if (key === "q") quality = Number(value);
+			else parameterCount++;
+		}
+		if (quality === 0) continue;
+		const [mediaType, mediaSubtype] = type.split("/");
+		const specificity = mediaType === "*" ? 0 : mediaSubtype === "*" ? 1 : 2;
+		accepted.push({
+			type,
+			quality,
+			specificity,
+			parameterCount
+		});
+	}
+	if (!accepted.length) return [];
+	return accepted.sort((left, right) => {
+		if (right.quality !== left.quality) return right.quality - left.quality;
+		if (right.specificity !== left.specificity) return right.specificity - left.specificity;
+		return right.parameterCount - left.parameterCount;
+	}).map((entry) => entry.type);
+}
+//#endregion
+//#region src/graphql/graphql-handler.ts
+function isDocumentNode(value) {
+	if (value == null) return false;
+	return typeof value === "object" && "kind" in value && "definitions" in value;
+}
+function isDocumentTypeDecoration(value) {
+	return value instanceof String;
+}
+var GraphQLHandler = class GraphQLHandler extends RequestHandler {
+	endpoint;
+	static parsedRequestCache = /* @__PURE__ */ new WeakMap();
+	static #parseOperationName(predicate, operationType) {
+		const getOperationName = (node) => {
+			invariant(node.operationType === operationType, "Failed to create a GraphQL handler: provided a DocumentNode with a mismatched operation type (expected \"%s\" but got \"%s\").", operationType, node.operationType);
+			invariant(node.operationName, "Failed to create a GraphQL handler: provided a DocumentNode without operation name");
+			return node.operationName;
+		};
+		if (isDocumentNode(predicate)) return getOperationName(parseDocumentNode(predicate));
+		if (isDocumentTypeDecoration(predicate)) {
+			const documentNode = parse(predicate.toString());
+			invariant(isDocumentNode(documentNode), "Failed to create a GraphQL handler: given TypedDocumentString (%s) does not produce a valid DocumentNode", predicate);
+			return getOperationName(parseDocumentNode(documentNode));
+		}
+		return predicate;
+	}
+	/**
+	* Creates a GraphQL handler information object from the given
+	* operation predicate. Normalizes `DocumentNode` and typed document
+	* string predicates to plain operation names.
+	*/
+	static parseGraphQLRequestInfo(args) {
+		const operationName = GraphQLHandler.#parseOperationName(args.predicate, args.operationType);
+		const displayOperationName = typeof operationName === "function" ? "[custom predicate]" : operationName;
+		return {
+			header: args.operationType === "all" ? `${args.operationType} (origin: ${args.url.toString()})` : `${args.operationType}${displayOperationName ? ` ${displayOperationName}` : ""} (origin: ${args.url.toString()})`,
+			operationType: args.operationType,
+			operationName
+		};
+	}
+	constructor(operationType, predicate, endpoint, resolver, options) {
+		super({
+			info: GraphQLHandler.parseGraphQLRequestInfo({
+				operationType,
+				predicate,
+				url: endpoint
+			}),
+			resolver,
+			options
+		});
+		this.endpoint = endpoint;
+	}
+	/**
+	* 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.
+	*/
+	async parseGraphQLRequestOrGetFromCache(request) {
+		if (!GraphQLHandler.parsedRequestCache.has(request)) GraphQLHandler.parsedRequestCache.set(request, await parseGraphQLRequest(request).catch((error) => {
+			console.error(error);
+		}));
+		return GraphQLHandler.parsedRequestCache.get(request);
+	}
+	async parse(args) {
+		const match = matchRequestUrl(new URL(args.request.url), this.endpoint);
+		const cookies = getAllRequestCookies(args.request);
+		if (!match.matches) return {
+			match,
+			cookies
+		};
+		const parsedResult = await this.parseGraphQLRequestOrGetFromCache(args.request);
+		if (typeof parsedResult === "undefined") return {
+			match,
+			cookies
+		};
+		return {
+			match,
+			cookies,
+			query: parsedResult.query,
+			operationType: parsedResult.operationType,
+			operationName: parsedResult.operationName,
+			variables: parsedResult.variables
+		};
+	}
+	async predicate(args) {
+		if (args.parsedResult.operationType === void 0) 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 the "operation()" request handler of "graphql.link()" 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;
+		/**
+		* Check if the operation name matches the outgoing GraphQL request.
+		* @note Unlike the HTTP handler, the custom predicate functions are invoked
+		* during predicate, not parsing, because GraphQL request parsing happens first,
+		* and non-GraphQL requests are filtered out automatically.
+		*/
+		const hasMatchingOperationName = await this.matchOperationName({
+			request: args.request,
+			parsedResult: args.parsedResult
+		});
+		return args.parsedResult.match.matches && hasMatchingOperationType && hasMatchingOperationName;
+	}
+	async run(args) {
+		const result = await super.run(args);
+		if (result?.response == null) return result;
+		if (!(kDefaultContentType in result.response)) return result;
+		const acceptedMimeTypes = getAllAcceptedMimeTypes(args.request.headers.get("accept"));
+		if (acceptedMimeTypes.length === 0) return result;
+		const graphqlResponseIndex = acceptedMimeTypes.indexOf("application/graphql-response+json");
+		const jsonIndex = acceptedMimeTypes.indexOf("application/json");
+		/**
+		* Use the "application/graphql-response+json" response content type
+		* only when the client accepts it AND prefers it over "application/json"
+		* (i.e. it appears earlier in the precedence-sorted list, or "application/json"
+		* is not listed at all).
+		* @see https://github.com/graphql/graphql-over-http/blob/4d1df1fb829ec2dd3ecbf3c6aa4025bd356c270d/spec/GraphQLOverHTTP.md#accept
+		*/
+		if (graphqlResponseIndex !== -1 && (jsonIndex === -1 || graphqlResponseIndex <= jsonIndex)) result.response.headers.set("content-type", "application/graphql-response+json");
+		return result;
+	}
+	async matchOperationName(args) {
+		if (typeof this.info.operationName === "function") {
+			const customPredicateResult = await this.info.operationName({
+				request: args.request,
+				...this.extendResolverArgs({
+					request: args.request,
+					parsedResult: args.parsedResult
+				})
+			});
+			/**
+			* @note Keep the { matches } signature in case we decide to support path parameters
+			* in GraphQL handlers. If that happens, the custom predicate would have to be moved
+			* to the parsing phase, the same as we have for the HttpHandler, and the user will
+			* have a possibility to return parsed path parameters from the custom predicate.
+			*/
+			return typeof customPredicateResult === "boolean" ? customPredicateResult : customPredicateResult.matches;
+		}
+		if (this.info.operationName instanceof RegExp) return this.info.operationName.test(args.parsedResult.operationName || "");
+		return args.parsedResult.operationName === this.info.operationName;
+	}
+	extendResolverArgs(args) {
+		return {
+			query: args.parsedResult.query || "",
+			operationType: args.parsedResult.operationType,
+			operationName: args.parsedResult.operationName || "",
+			variables: args.parsedResult.variables || {},
+			cookies: args.parsedResult.cookies
+		};
+	}
+	async log(args) {
+		const loggedRequest = await serializeRequest(args.request);
+		const loggedResponse = await serializeResponse(args.response);
+		const statusColor = getStatusCodeColor(loggedResponse.status);
+		const requestInfo = args.parsedResult.operationName ? `${args.parsedResult.operationType} ${args.parsedResult.operationName}` : `anonymous ${args.parsedResult.operationType}`;
+		console.groupCollapsed(devUtils.formatMessage(`${getTimestamp()} ${requestInfo} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`), `color:${statusColor}`, "color:inherit");
+		console.log("Request:", loggedRequest);
+		console.log("Handler:", this);
+		console.log("Response:", loggedResponse);
+		console.groupEnd();
+	}
+};
+//#endregion
+//#region src/graphql/graphql-subscription-event.ts
+/**
+* Emitted when a GraphQL subscription is established over an
+* intercepted WebSocket connection (i.e. matched by a subscription
+* handler and resolved).
+*
+* @note The event is referenced by the WebSocket frame event map so
+* the life-cycle event emitters derived from it (e.g. `server.events`)
+* are typed correctly. It lives in its own module so the emitting
+* `msw/graphql` module doesn't pull the entire frame graph, and the
+* core stays free of the `graphql` dependency (the event carries
+* plain data only).
+*/
+var GraphQLSubscriptionEvent = class extends TypedEvent {
+	operationName;
+	query;
+	variables;
+	request;
+	constructor(init) {
+		super("graphql:subscription");
+		this.operationName = init.operationName;
+		this.query = init.query;
+		this.variables = init.variables;
+		this.request = init.request;
+	}
+};
+//#endregion
+//#region src/graphql/graphql-subscription.ts
+function createInitMessage(payload) {
+	return JSON.stringify({
+		type: "connection_init",
+		payload
+	});
+}
+function createAcknowledgeMessage() {
+	return JSON.stringify({ type: "connection_ack" });
+}
+function createNextMessage(args) {
+	return JSON.stringify({
+		id: args.id,
+		type: "next",
+		payload: args.payload
+	});
+}
+function createErrorMessage(args) {
+	return JSON.stringify({
+		id: args.id,
+		type: "error",
+		payload: args.payload
+	});
+}
+function createCompleteMessage(args) {
+	return JSON.stringify({
+		id: args.id,
+		type: "complete"
+	});
+}
+function createPongMessage() {
+	return JSON.stringify({ type: "pong" });
+}
+/**
+* Construct a request representing the WebSocket upgrade of the given
+* connection. GraphQL subscriptions have no request of their own, so
+* this describes the connection they are multiplexed over.
+*/
+function createUpgradeRequest(url) {
+	return new Request(url, { headers: {
+		connection: "upgrade",
+		upgrade: "websocket"
+	} });
+}
+function parseGraphQLWebSocketMessage(data) {
+	if (typeof data !== "string") return;
+	const message = jsonParse(data);
+	if (!message || typeof message.type !== "string") return;
+	return message;
+}
+/**
+* Connect to the original server and initialize the `graphql-transport-ws`
+* session for the given connection, at most once.
+*
+* @note The server connection is shared by every subscription of this
+* client. Initializing it more than once makes a compliant GraphQL server
+* close it ("Too many initialisation requests").
+*/
+function ensureUpstreamSession(connection) {
+	if (connection.upstreamSession) return connection.upstreamSession;
+	const { server } = connection;
+	connection.upstreamSession = new Promise((resolve) => {
+		server.addEventListener("message", (event) => {
+			if (parseGraphQLWebSocketMessage(event.data)?.type === "connection_ack") {
+				event.preventDefault();
+				resolve();
+			}
+		});
+		server.addEventListener("open", () => {
+			server.send(createInitMessage(connection.connectionParams));
+		}, { once: true });
+		server.connect();
+	});
+	return connection.upstreamSession;
+}
+/**
+* The `graphql-transport-ws` sessions of the intercepted WebSocket
+* connections, keyed by the client id.
+*
+* @note This registry is module-level, and not per-transport, on purpose.
+* Multiple `graphql.link()` calls to the same endpoint create multiple
+* transports, and all of them must share a single session per connection.
+* Otherwise, each transport binds its own protocol listeners to the same
+* client, which makes it receive duplicate `connection_ack`/`pong` frames
+* and resolves matching subscription handlers more than once.
+*/
+const connections = /* @__PURE__ */ new Map();
+/**
+* The WebSocket protocol implemented by the subscription transport.
+* @see https://github.com/graphql/graphql-over-http/blob/main/rfcs/GraphQLOverWebSocket.md
+*/
+const GRAPHQL_WEBSOCKET_SUBPROTOCOL = "graphql-transport-ws";
+function includesGraphQLProtocol(protocols) {
+	if (protocols == null) return false;
+	return (typeof protocols === "string" ? protocols.split(",") : protocols).some((protocol) => {
+		return protocol.trim() === GRAPHQL_WEBSOCKET_SUBPROTOCOL;
+	});
+}
+/**
+* A WebSocket handler that only matches connections that requested the
+* `graphql-transport-ws` protocol. Connections without it (e.g.
+* arbitrary non-GraphQL WebSockets whose URL matched a permissive
+* endpoint like a wildcard link) are left unhandled so they follow the
+* regular unhandled connection flow (warnings, passthrough).
+*/
+var GraphQLWebSocketHandler = class extends WebSocketHandler {
+	async run(connection, resolutionContext) {
+		if (!includesGraphQLProtocol(connection.info.protocols)) return null;
+		return super.run(connection, resolutionContext);
+	}
+};
+/**
+* A WebSocket handler implementing the `graphql-transport-ws` protocol
+* session for a single GraphQL endpoint. One transport is shared across
+* all subscription handlers created from the same `graphql.link()` call
+* (attached to each of them as a sibling handler).
+*
+* The transport owns the protocol/session concerns: connection
+* acknowledgement, keep-alive, the per-connection registry of active
+* subscriptions, and dispatching parsed `subscribe` operations to the
+* matching subscription handler.
+*/
+var GraphQLSubscriptionTransportHandler = class extends GraphQLWebSocketHandler {
+	/**
+	* Register the given handler as a subscriber to the GraphQL
+	* subscriptions on the given WebSocket connection. Subscribers are
+	* dispatched in registration order, which follows the handlers
+	* resolution order (runtime handlers take precedence).
+	*/
+	subscribe(connection, handler, subscriber) {
+		this.#getOrCreateConnection(connection).subscribers.set(handler, {
+			transport: this,
+			subscriber
+		});
+	}
+	getConnection(clientId) {
+		return connections.get(clientId);
+	}
+	async run(connection, resolutionContext) {
+		const handlerConnection = await super.run(connection, resolutionContext);
+		if (handlerConnection) {
+			const transportConnection = this.#getOrCreateConnection(handlerConnection);
+			if (resolutionContext?.events) transportConnection.events = resolutionContext.events;
+		}
+		return handlerConnection;
+	}
+	/**
+	* End the given subscription without notifying the client. Used when
+	* the subscription has already been terminated over the wire (e.g. the
+	* original server completed it and that frame reached the client).
+	*/
+	endSubscription(args) {
+		const connection = connections.get(args.clientId);
+		if (connection) this.#endSubscription(connection, args.subscriptionId);
+	}
+	/**
+	* Schedule a cleanup to run once the given subscription ends.
+	*
+	* @note If the subscription has already ended by the time this is
+	* called, the cleanup runs immediately. The resolver can no longer
+	* affect that subscription, so there is nothing left to wait for.
+	*/
+	finalize(args) {
+		const cleanups = connections.get(args.clientId)?.subscriptions.get(args.subscriptionId);
+		if (cleanups) {
+			cleanups.push(args.cleanup);
+			return;
+		}
+		this.#exhaustCleanups([args.cleanup]);
+	}
+	async #endAllSubscriptions(connection) {
+		const pendingCleanups = [];
+		for (const subscriptionId of connection.subscriptions.keys()) pendingCleanups.push(this.#endSubscription(connection, subscriptionId));
+		await Promise.all(pendingCleanups);
+	}
+	/**
+	* End the given subscription and run the cleanups scheduled for it.
+	*
+	* This is the single exit point for every way a subscription can end:
+	* completed by the mock, by the client, or by the original server;
+	* terminated with errors; dropped when the client disconnects; or
+	* detached from its resolver when the handlers are reset. Ending an
+	* already-ended subscription is a no-op, so the cleanups are
+	* guaranteed to run at most once.
+	*/
+	#endSubscription(connection, subscriptionId) {
+		const cleanups = connection.subscriptions.get(subscriptionId);
+		if (!cleanups) return Promise.resolve();
+		connection.subscriptions.delete(subscriptionId);
+		return this.#exhaustCleanups(cleanups);
+	}
+	/**
+	* Run the given cleanups as LIFO, consistently with `finalize()` in
+	* the request handlers. Cleanups are detached from the subscription
+	* life-cycle: nothing awaits them, so this must never reject.
+	*/
+	async #exhaustCleanups(cleanups) {
+		const errors = [];
+		for (let index = cleanups.length - 1; index >= 0; index--) try {
+			await cleanups[index]();
+		} catch (error) {
+			if (error instanceof Error) errors.push(error);
+		}
+		if (errors.length > 0) devUtils.error("Failed to execute the cleanup for a GraphQL subscription to \"%s\". Please see the original error below.", this.url.toString(), new AggregateError(errors));
+	}
+	/**
+	* Send a `next` message with the given payload to the subscription.
+	*/
+	publish(args) {
+		const connection = this.#getConnectionForSubscription({
+			clientId: args.clientId,
+			subscriptionId: args.subscriptionId,
+			intent: "publish to"
+		});
+		if (!connection) return;
+		connection.client.send(createNextMessage({
+			id: args.subscriptionId,
+			payload: args.payload
+		}));
+	}
+	/**
+	* Send a terminal `error` message to the subscription and
+	* removes it from the registry of active subscriptions.
+	*/
+	error(args) {
+		const connection = this.#getConnectionForSubscription({
+			clientId: args.clientId,
+			subscriptionId: args.subscriptionId,
+			intent: "error"
+		});
+		if (!connection) return;
+		connection.client.send(createErrorMessage({
+			id: args.subscriptionId,
+			payload: args.errors
+		}));
+		this.#endSubscription(connection, args.subscriptionId);
+	}
+	/**
+	* Send a `complete` message to the subscription and removes it
+	* from the registry of active subscriptions.
+	*/
+	complete(args) {
+		const connection = this.#getConnectionForSubscription({
+			clientId: args.clientId,
+			subscriptionId: args.subscriptionId,
+			intent: "complete"
+		});
+		if (!connection) return;
+		connection.client.send(createCompleteMessage({ id: args.subscriptionId }));
+		this.#endSubscription(connection, args.subscriptionId);
+	}
+	/**
+	* Drop this transport's subscribers and active subscriptions from the
+	* sessions it participates in. The sessions themselves are left intact:
+	* they are shared with the other transports of the same connection and
+	* own the protocol listeners for as long as the client stays connected.
+	*
+	* @note This method is invoked automatically when the handlers
+	* controller resets the handlers (e.g. `server.resetHandlers()`).
+	*/
+	reset() {
+		for (const connection of connections.values()) {
+			let ownsConnection = false;
+			for (const [handler, entry] of connection.subscribers) if (entry.transport === this) {
+				connection.subscribers.delete(handler);
+				ownsConnection = true;
+			}
+			if (ownsConnection) this.#endAllSubscriptions(connection);
+		}
+	}
+	/**
+	* Forget the sessions of this transport, ending their subscriptions.
+	* @note This method is invoked automatically when the network is
+	* disabled (e.g. `server.close()`).
+	*/
+	dispose() {
+		const pendingCleanups = [];
+		for (const [clientId, connection] of connections) {
+			for (const [handler, entry] of connection.subscribers) if (entry.transport === this) connection.subscribers.delete(handler);
+			if (connection.subscribers.size === 0) {
+				pendingCleanups.push(this.#endAllSubscriptions(connection));
+				connections.delete(clientId);
+			}
+		}
+		if (pendingCleanups.length > 0) return Promise.all(pendingCleanups).then(() => {});
+	}
+	/**
+	* @note The transport is the sole owner of logging for GraphQL
+	* subscription connections. It logs parsed `graphql-transport-ws`
+	* frames instead of raw WebSocket messages.
+	*/
+	log(connection) {
+		return attachGraphQLSubscriptionLogger(connection);
+	}
+	[kConnect](connection) {
+		this.#getOrCreateConnection(connection);
+		return true;
+	}
+	#getOrCreateConnection(connection) {
+		const { client } = connection;
+		const existingConnection = connections.get(client.id);
+		if (existingConnection) return existingConnection;
+		const transportConnection = {
+			client: connection.client,
+			server: connection.server,
+			subscribers: /* @__PURE__ */ new Map(),
+			subscriptions: /* @__PURE__ */ new Map()
+		};
+		connections.set(client.id, transportConnection);
+		client.addEventListener("message", (event) => {
+			this.#handleClientMessage(client.id, event.data);
+		});
+		client.addEventListener("close", () => {
+			this.#endAllSubscriptions(transportConnection);
+			connections.delete(client.id);
+		});
+		return transportConnection;
+	}
+	#getConnectionForSubscription(args) {
+		const connection = connections.get(args.clientId);
+		if (!connection || !connection.subscriptions.has(args.subscriptionId)) {
+			devUtils.warn("Failed to %s the GraphQL subscription \"%s\": the subscription is no longer active.", args.intent, args.subscriptionId);
+			return;
+		}
+		return connection;
+	}
+	#handleClientMessage(clientId, data) {
+		const connection = connections.get(clientId);
+		if (!connection) return;
+		const message = parseGraphQLWebSocketMessage(data);
+		if (!message) return;
+		switch (message.type) {
+			case "connection_init":
+				connection.connectionParams = message.payload;
+				connection.client.send(createAcknowledgeMessage());
+				break;
+			case "ping":
+				connection.client.send(createPongMessage());
+				break;
+			case "subscribe":
+				this.#handleSubscribeMessage(connection, message);
+				break;
+			case "complete": this.#endSubscription(connection, message.id);
+		}
+	}
+	#handleSubscribeMessage(connection, message) {
+		let node;
+		try {
+			node = parseDocumentNode(parse(message.payload.query), message.payload.operationName);
+		} catch (error) {
+			devUtils.warn("Failed to intercept a GraphQL subscription to \"%s\": the subscription query is not a valid GraphQL document.\n\n%s", toPublicUrl(connection.client.url), error);
+			return;
+		}
+		if (node.operationType !== OperationTypeNode.SUBSCRIPTION) {
+			devUtils.warn("Intercepted a GraphQL %s \"%s\" over WebSocket: only subscription operations are supported over the WebSocket transport.", node.operationType, node.operationName || "(anonymous)");
+			return;
+		}
+		connection.subscriptions.set(message.id, []);
+		for (const { subscriber } of connection.subscribers.values()) if (subscriber({
+			node,
+			message
+		})) {
+			this.#emitSubscriptionEvent(connection, node, message);
+			return;
+		}
+		devUtils.warn("Intercepted a GraphQL subscription \"%s\" to \"%s\" that has no matching subscription handler. If you wish to mock this subscription, create a subscription handler for it.", node.operationName || "(anonymous)", toPublicUrl(connection.client.url));
+	}
+	/**
+	* Emit the "graphql:subscription" life-cycle event on the network.
+	* The event is emitted once the subscription has been established:
+	* matched by a subscription handler and resolved.
+	*/
+	#emitSubscriptionEvent(connection, node, message) {
+		if (!connection.events || !node.operationName) return;
+		connection.events.emit(new GraphQLSubscriptionEvent({
+			operationName: node.operationName,
+			query: message.payload.query,
+			variables: { ...message.payload.variables },
+			request: createUpgradeRequest(connection.client.url)
+		}));
+	}
+};
+/**
+* A WebSocket handler intercepting GraphQL subscriptions by their
+* operation name. Matching and resolution are delegated to it by the
+* subscription transport (its sibling handler) so the first matching
+* handler wins, respecting runtime handler overrides.
+*/
+var GraphQLSubscriptionHandler = class extends GraphQLWebSocketHandler {
+	info;
+	isUsed;
+	#operationName;
+	#transport;
+	#resolver;
+	#options;
+	constructor(args) {
+		super(args.url);
+		this.info = GraphQLHandler.parseGraphQLRequestInfo({
+			operationType: OperationTypeNode.SUBSCRIPTION,
+			predicate: args.operationName,
+			url: args.url
+		});
+		const { operationName } = this.info;
+		invariant(typeof operationName !== "function" && !isDocumentNode(operationName), "Failed to create a GraphQL subscription handler: custom predicates are not supported for subscriptions");
+		this.#operationName = operationName;
+		this.#transport = args.transport;
+		this.#resolver = args.resolver;
+		this.#options = args.options || {};
+		this.isUsed = false;
+	}
+	reset() {
+		this.isUsed = false;
+	}
+	/**
+	* @note Individual subscription handlers stay silent. The subscription
+	* transport owns the GraphQL-aware logging for the entire connection
+	* (a logger is attached once per matching handler otherwise).
+	*/
+	log() {
+		return function detachLogger() {};
+	}
+	[kConnect](connection) {
+		this.#transport.subscribe(connection, this, (args) => {
+			return this.#handleSubscribe(connection, args);
+		});
+		return true;
+	}
+	#handleSubscribe(connection, args) {
+		if (this.#options.once && this.isUsed) return false;
+		const { operationName } = args.node;
+		if (!operationName || !this.#matchesOperationName(operationName)) return false;
+		this.isUsed = true;
+		const subscription = new GraphQLSubscription({
+			message: args.message,
+			clientId: connection.client.id,
+			transport: this.#transport
+		});
+		this.#resolver({
+			params: connection.params,
+			operationName,
+			subscription,
+			request: createUpgradeRequest(connection.client.url),
+			finalize: (cleanup) => {
+				this.#transport.finalize({
+					clientId: connection.client.id,
+					subscriptionId: subscription.id,
+					cleanup
+				});
+			}
+		});
+		return true;
+	}
+	#matchesOperationName(operationName) {
+		if (this.#operationName instanceof RegExp) return this.#operationName.test(operationName);
+		return this.#operationName === operationName;
+	}
+};
+/**
+* Representation of the intercepted GraphQL subscription.
+*/
+var GraphQLSubscription = class {
+	id;
+	query;
+	variables;
+	extensions;
+	#message;
+	#clientId;
+	#transport;
+	constructor(args) {
+		this.id = args.message.id;
+		this.query = args.message.payload.query;
+		this.variables = args.message.payload.variables || {};
+		this.extensions = args.message.payload.extensions;
+		this.#message = args.message;
+		this.#clientId = args.clientId;
+		this.#transport = args.transport;
+	}
+	/**
+	* Publish an execution result to the subscribed client.
+	*
+	* @example
+	* subscription.publish({
+	*   data: {
+	*     postAdded: {
+	*       id: 'abc-123'
+	*     }
+	*   }
+	* })
+	*/
+	publish(payload) {
+		this.#transport.publish({
+			clientId: this.#clientId,
+			subscriptionId: this.id,
+			payload
+		});
+	}
+	/**
+	* Use the given `Iterable` or `AsyncIterable` as the source
+	* of data for this subscription. Whenever the iterable yields a
+	* value, it gets published to this subscription.
+	*
+	* @example
+	* subscription.from(async function* () {
+	*   yield { text: 'hello world' }
+	* })
+	*/
+	async from(source) {
+		for await (const data of source) this.publish({ data });
+	}
+	/**
+	* Terminate this subscription with the given errors.
+	*
+	* @example
+	* subscription.error([{ message: 'Something went wrong' }])
+	*/
+	error(errors) {
+		this.#transport.error({
+			clientId: this.#clientId,
+			subscriptionId: this.id,
+			errors
+		});
+	}
+	/**
+	* Marks this subscription as complete.
+	*
+	* @example
+	* subscription.complete()
+	*/
+	complete() {
+		this.#transport.complete({
+			clientId: this.#clientId,
+			subscriptionId: this.id
+		});
+	}
+	/**
+	* Perform this GraphQL subscription as-is.
+	* This establishes a connection to the actual server, replays
+	* the intercepted subscription, and forwards the server payloads
+	* to the GraphQL client. You can intercept, modify, or prevent
+	* any of the original server messages.
+	*
+	* @example
+	* const postAddedSubscription = subscription.passthrough()
+	* postAddedSubscription.addEventListener('next', (event) => {
+	*   event.preventDefault()
+	*   event.data.payload.data.postAdded.id = 'mock-id'
+	*   subscription.publish(event.data.payload)
+	* })
+	*/
+	passthrough() {
+		const connection = this.#transport.getConnection(this.#clientId);
+		/**
+		* @note One can only call this method inside the GraphQL subscription
+		* handler. By that point, the WebSocket connection has been established
+		* and intercepted so the connection reference is guaranteed.
+		*/
+		invariant(connection, "Failed to passthrough the GraphQL subscription (\"%s\"): the underlying WebSocket connection is closed", this.query);
+		return new GraphQLPassthroughSubscription({
+			server: connection.server,
+			message: this.#message,
+			upstreamSession: ensureUpstreamSession(connection),
+			onTerminate: () => {
+				this.#transport.endSubscription({
+					clientId: this.#clientId,
+					subscriptionId: this.id
+				});
+			}
+		});
+	}
+};
+/**
+* Representation of a GraphQL subscription to the actual server.
+* You interface with this object from the client's perspective.
+*/
+var GraphQLPassthroughSubscription = class {
+	#server;
+	#message;
+	#emitter;
+	#abortController;
+	#onTerminate;
+	constructor(args) {
+		this.#server = args.server;
+		this.#message = args.message;
+		this.#onTerminate = args.onTerminate;
+		this.#emitter = new Emitter();
+		this.#abortController = new AbortController();
+		args.upstreamSession.then(() => {
+			if (!this.#abortController.signal.aborted) this.#server.send(JSON.stringify(this.#message));
+		});
+		this.#server.addEventListener("message", (event) => {
+			const message = parseGraphQLWebSocketMessage(event.data);
+			if (!message) return;
+			switch (message.type) {
+				case "connection_ack":
+					event.preventDefault();
+					this.#emitter.emit(new TypedEvent("connection_ack"));
+					break;
+				case "next": {
+					if (message.id !== this.#message.id) break;
+					const nextEvent = new TypedEvent("next", { data: message });
+					this.#emitter.emit(nextEvent);
+					if (nextEvent.defaultPrevented) event.preventDefault();
+					break;
+				}
+				case "error": {
+					if (message.id !== this.#message.id) break;
+					const errorEvent = new TypedEvent("error", { data: message });
+					this.#emitter.emit(errorEvent);
+					if (errorEvent.defaultPrevented) {
+						event.preventDefault();
+						break;
+					}
+					this.#onTerminate();
+					break;
+				}
+				case "complete": {
+					if (message.id !== this.#message.id) break;
+					const completeEvent = new TypedEvent("complete", { data: message });
+					this.#emitter.emit(completeEvent);
+					if (completeEvent.defaultPrevented) {
+						event.preventDefault();
+						break;
+					}
+					this.#onTerminate();
+					break;
+				}
+			}
+		}, { signal: this.#abortController.signal });
+	}
+	/**
+	* Add an event listener to the given GraphQL subscription event.
+	*
+	* @example
+	* const onPostAddedSubscription = subscription.passthrough()
+	* onPostAddedSubscription.addEventListener('next', (event) => {
+	*   console.log(event.data)
+	*   // { id, payload, ... }
+	* })
+	*/
+	addEventListener(event, listener) {
+		this.#emitter.on(event, listener, { signal: this.#abortController.signal });
+	}
+	/**
+	* Unsubscribe from this passthrough GraphQL subscription.
+	* This stops this subscription on the original server.
+	*
+	* @note Unsubscribing from the original subscription has no
+	* effect on the intercepted `subscription` object.
+	*
+	* @example
+	* const onPostAddedSubscription = subscription.passthrough()
+	* onPostAddedSubscription.unsubscribe()
+	*/
+	unsubscribe() {
+		this.#abortController.abort();
+		this.#emitter.removeAllListeners();
+		/**
+		* @note Complete this subscription instead of closing the server
+		* connection. That connection is shared by every subscription of
+		* this client, and closing it would terminate the unrelated ones.
+		*/
+		this.#server.send(createCompleteMessage({ id: this.#message.id }));
+	}
+};
+function logGraphQLFrame(args) {
+	const timestamp = getTimestamp({ milliseconds: true });
+	if (typeof args.payload === "undefined") {
+		console.log(devUtils.formatMessage(`${timestamp} %c${args.label}%c`), `color:${args.color}`, "color:inherit");
+		return;
+	}
+	console.groupCollapsed(devUtils.formatMessage(`${timestamp} %c${args.label}%c`), `color:${args.color}`, "color:inherit");
+	console.log(args.payload);
+	console.groupEnd();
+}
+/**
+* Attach a GraphQL-aware logger to the intercepted WebSocket connection.
+* Unlike the raw WebSocket logger, this logger prints parsed
+* `graphql-transport-ws` frames relevant to the subscription.
+*/
+function attachGraphQLSubscriptionLogger(connection) {
+	const { client } = connection;
+	const abortController = new AbortController();
+	logGraphQLFrame({
+		color: colors.system,
+		label: `GraphQL subscription connection ${toPublicUrl(client.url)}`
+	});
+	client.addEventListener("message", (event) => {
+		const message = parseGraphQLWebSocketMessage(event.data);
+		if (!message) return;
+		switch (message.type) {
+			case "subscribe":
+				logGraphQLFrame({
+					color: colors.outgoing,
+					label: `subscribe (id: ${message.id})`,
+					payload: message.payload
+				});
+				break;
+			case "complete": logGraphQLFrame({
+				color: colors.outgoing,
+				label: `complete (id: ${message.id})`
+			});
+		}
+	}, { signal: abortController.signal });
+	const originalClientSend = client.send;
+	client.send = new Proxy(client.send, { apply: (target, thisArg, args) => {
+		const [data] = args;
+		const message = parseGraphQLWebSocketMessage(data);
+		if (message) switch (message.type) {
+			case "next":
+				logGraphQLFrame({
+					color: colors.mocked,
+					label: `next (id: ${message.id})`,
+					payload: message.payload
+				});
+				break;
+			case "error":
+				logGraphQLFrame({
+					color: colors.mocked,
+					label: `error (id: ${message.id})`,
+					payload: message.payload
+				});
+				break;
+			case "complete": logGraphQLFrame({
+				color: colors.mocked,
+				label: `complete (id: ${message.id})`
+			});
+		}
+		return Reflect.apply(target, thisArg, args);
+	} });
+	return function detachLogger() {
+		abortController.abort();
+		client.send = originalClientSend;
+	};
+}
+/**
+* Create a `subscription()` handler factory bound to the given GraphQL
+* endpoint. All subscription handlers created by the factory share a single
+* subscription transport and a single WebSocket upgrade handler, both
+* attached to each handler as siblings.
+*
+* @example
+* const subscription = createGraphQLSubscriptionHandler('https://api.example.com/graphql')
+* subscription('OnPostAdded', ({ subscription }) => {
+*   subscription.publish({ data: { postAdded: { id: 'abc-123' } } })
+* })
+*/
+function createGraphQLSubscriptionHandler(url) {
+	const webSocketUrl = typeof url === "string" ? url.replace(/^http/, "ws") : url;
+	const transport = new GraphQLSubscriptionTransportHandler(webSocketUrl);
+	const upgradeHandler = http.get(({ request }) => {
+		return request.headers.get("upgrade")?.toLowerCase() === "websocket" && includesGraphQLProtocol(request.headers.get("sec-websocket-protocol")) && matchRequestUrl(new URL(resolveWebSocketUrl(request.url)), webSocketUrl).matches;
+	}, webSocketUpgrade);
+	return (operationName, resolver, options) => {
+		const handler = new GraphQLSubscriptionHandler({
+			url: webSocketUrl,
+			operationName,
+			transport,
+			resolver,
+			options
+		});
+		return attachSiblingHandlers(handler, [transport, upgradeHandler]);
+	};
+}
+//#endregion
+//#region src/graphql/graphql.ts
+function createScopedGraphQLHandler(operationType, url) {
+	return (predicate, resolver, options = {}) => {
+		return new GraphQLHandler(operationType, predicate, url, resolver, options);
+	};
+}
+function createGraphQLOperationHandler(url, subscriptionFactory) {
+	/**
+	* @note An explicitly generic function so the subscription sibling
+	* can be created with the same `Query`/`Variables` types as the
+	* operation resolver, without casting its resolver info.
+	*/
+	return (resolver, options) => {
+		const handler = new GraphQLHandler("all", /* @__PURE__ */ new RegExp(".*"), url, resolver, options);
+		if (!subscriptionFactory) return handler;
+		const subscriptionCatchAllHandler = subscriptionFactory(/* @__PURE__ */ new RegExp(".*"), ({ operationName, subscription, request, finalize }) => {
+			/**
+			* @note Subscriptions are resolved imperatively, so the return
+			* value of the resolver is ignored. The request describes the
+			* WebSocket connection this subscription is multiplexed over.
+			*/
+			resolver({
+				operationName,
+				query: subscription.query,
+				variables: subscription.variables,
+				cookies: getAllRequestCookies(request),
+				request,
+				requestId: createRequestId(),
+				finalize
+			});
+		}, options);
+		return attachSiblingHandlers(handler, [subscriptionCatchAllHandler]);
+	};
+}
+/**
+* A namespace to intercept and mock GraphQL operations
+*
+* @example
+* const api = graphql.link('https://api.example.com/graphql')
+* api.query('GetUser', resolver)
+* api.mutation('DeletePost', resolver)
+*
+* @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}
+*/
+const graphql = { 
+/**
+* Intercepts GraphQL operations scoped by the given URL.
+*
+* @example
+* const github = graphql.link('https://api.github.com/graphql')
+* github.query('GetRepo', resolver)
+*
+* @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
+*/
+link(url) {
+	/**
+	* @note Create the subscription handler factory once per link so
+	* the `subscription()` and `operation()` handlers share the same
+	* underlying subscription transport (deduped by reference).
+	*/
+	const subscription = createGraphQLSubscriptionHandler(url);
+	return {
+		operation: createGraphQLOperationHandler(url, subscription),
+		query: createScopedGraphQLHandler("query", url),
+		mutation: createScopedGraphQLHandler("mutation", url),
+		subscription
+	};
+} };
+//#endregion
+export { GraphQLHandler, GraphQLPassthroughSubscription, GraphQLSubscription, GraphQLSubscriptionHandler, createGraphQLSubscriptionHandler, graphql };
+
+//# sourceMappingURL=index.js.map