@fluojs/graphql 1.0.4 → 2.0.0

package/dist/service.js

@@ -4,27 +4,35 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
 function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
-import { Controller, Get, Post } from '@fluojs/http';
+import { createRequire } from 'node:module';
 import { Inject } from '@fluojs/core';
+import { Controller, Get, Post } from '@fluojs/http';
 import { APPLICATION_LOGGER, COMPILED_MODULES, HTTP_APPLICATION_ADAPTER, RUNTIME_CONTAINER } from '@fluojs/runtime/internal';
 import { discoverResolverDescriptors } from './discovery.js';
 import { createGraphqlValidationPlugin, resolveGraphqlRequestLimits } from './guardrails.js';
+import { installGraphqlInstanceOfPatch } from './instance-of-patch.js';
 import { GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN } from './internal-tokens.js';
 import { createCodeFirstSchema, resolveSchema } from './schema/schema.js';
 import { isGraphqlPath, toFetchRequest, writeFetchResponse } from './transport/transport.js';
 import { GRAPHQL_OPERATION_CONTAINER } from './types.js';
 const GRAPHQL_CONTEXT_OVERRIDE = Symbol('fluo.graphql.context.override');
+const runtimeRequire = createRequire(import.meta.url);
 const DEFAULT_GRAPHQL_WEBSOCKET_LIMITS = {
   maxConnections: 100,
   maxOperationsPerConnection: 25,
   maxPayloadBytes: 64 * 1024
 };
-function hasNodeUpgradeServer(value) {
-  if (typeof value !== 'object' || value === null) {
-    return false;
+function collectCleanupError(errors, error) {
+  if (error instanceof AggregateError) {
+    for (const nested of error.errors) {
+      collectCleanupError(errors, nested);
+    }
+    return;
+  }
+  if (errors.includes(error)) {
+    return;
   }
-  const server = value;
-  return typeof server.on === 'function' && typeof server.off === 'function';
+  errors.push(error);
 }
 function buildFrameworkRequestFromFetchRequest(request) {
   const requestUrl = new URL(request.url);
@@ -40,45 +48,10 @@ function buildFrameworkRequestFromFetchRequest(request) {
     url: requestUrl.pathname + requestUrl.search
   };
 }
-function buildFrameworkRequestFromIncomingMessage(request) {
-  const requestUrl = new URL(request.url ?? '/graphql', 'http://localhost');
-  return {
-    cookies: {},
-    headers: request.headers,
-    method: request.method ?? 'GET',
-    params: {},
-    path: requestUrl.pathname,
-    query: Object.fromEntries(requestUrl.searchParams.entries()),
-    raw: request,
-    url: requestUrl.pathname + requestUrl.search
-  };
-}
-function isConnectionParamsRecord(value) {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function closeWebSocketServer(server) {
-  return new Promise((resolve, reject) => {
-    server.close(error => {
-      if (error?.message === 'The server is not running') {
-        resolve();
-        return;
-      }
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
-}
-let graphqlInstanceOfPatchRefCount = 0;
-let restoreGraphqlInstanceOfPatch;
-const allowedCrossRealmGraphqlObjects = new WeakSet();
-
+let _GraphqlEndpointContr;
 /**
  * Declares the HTTP endpoints that receive GraphQL GET and POST requests.
  */
-let _GraphqlEndpointContr;
 class GraphqlEndpointController {
   static {
     ({
@@ -100,22 +73,7 @@ class GraphqlEndpointController {
   }
 }
 export { _GraphqlEndpointContr as GraphqlEndpointController };
-function getCrossRealmGraphqlTag(value, constructor) {
-  const className = constructor.prototype?.[Symbol.toStringTag];
-  if (typeof className !== 'string' || !className.startsWith('GraphQL')) {
-    return undefined;
-  }
-  if (typeof value !== 'object' || value === null) {
-    return undefined;
-  }
-  if (Symbol.toStringTag in value) {
-    const valueClassName = value[Symbol.toStringTag];
-    return valueClassName === className ? className : undefined;
-  }
-  const valueClassName = value.constructor?.name;
-  return valueClassName === className ? className : undefined;
-}
-function markAllowedCrossRealmGraphqlObjects(value, visited = new WeakSet()) {
+function markAllowedCrossRealmGraphqlObjects(value, allowedObjects, visited = new WeakSet()) {
   if (typeof value !== 'object' || value === null) {
     return;
   }
@@ -124,73 +82,26 @@ function markAllowedCrossRealmGraphqlObjects(value, visited = new WeakSet()) {
   }
   visited.add(value);
   const tag = value[Symbol.toStringTag];
-  if (typeof tag === 'string' && tag.startsWith('GraphQL')) {
-    allowedCrossRealmGraphqlObjects.add(value);
+  const constructorName = value.constructor?.name;
+  if (typeof tag === 'string' && tag.startsWith('GraphQL') || typeof constructorName === 'string' && constructorName.startsWith('GraphQL')) {
+    allowedObjects.add(value);
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      markAllowedCrossRealmGraphqlObjects(item, visited);
+      markAllowedCrossRealmGraphqlObjects(item, allowedObjects, visited);
     }
     return;
   }
   for (const nestedValue of Object.values(value)) {
-    markAllowedCrossRealmGraphqlObjects(nestedValue, visited);
+    markAllowedCrossRealmGraphqlObjects(nestedValue, allowedObjects, visited);
   }
 }
-function isAllowedCrossRealmGraphqlObject(value, constructor) {
-  if (typeof value !== 'object' || value === null) {
-    return false;
-  }
-  return allowedCrossRealmGraphqlObjects.has(value) && getCrossRealmGraphqlTag(value, constructor) !== undefined;
-}
-function installGraphqlInstanceOfPatch(instanceOfModule) {
-  if (restoreGraphqlInstanceOfPatch) {
-    graphqlInstanceOfPatchRefCount += 1;
-    return releaseGraphqlInstanceOfPatch;
-  }
-  const patchedFrom = instanceOfModule.instanceOf;
-  const patchedInstanceOf = (value, constructor) => {
-    try {
-      if (patchedFrom(value, constructor)) {
-        return true;
-      }
-    } catch (error) {
-      if (isAllowedCrossRealmGraphqlObject(value, constructor)) {
-        return true;
-      }
-      throw error;
-    }
-    return isAllowedCrossRealmGraphqlObject(value, constructor);
-  };
-  instanceOfModule.instanceOf = patchedInstanceOf;
-  graphqlInstanceOfPatchRefCount = 1;
-  restoreGraphqlInstanceOfPatch = () => {
-    if (instanceOfModule.instanceOf !== patchedInstanceOf) {
-      return;
-    }
-    instanceOfModule.instanceOf = patchedFrom;
-  };
-  return releaseGraphqlInstanceOfPatch;
-}
-function releaseGraphqlInstanceOfPatch() {
-  if (graphqlInstanceOfPatchRefCount === 0) {
-    return;
-  }
-  graphqlInstanceOfPatchRefCount -= 1;
-  if (graphqlInstanceOfPatchRefCount > 0) {
-    return;
-  }
-  restoreGraphqlInstanceOfPatch?.();
-  restoreGraphqlInstanceOfPatch = undefined;
-}
 async function loadGraphqlDeps() {
-  const {
-    createRequire
-  } = await import('node:module');
-  const runtimeRequire = createRequire(import.meta.url);
-  const graphqlMod = runtimeRequire('graphql');
-  const yogaMod = runtimeRequire('graphql-yoga');
-  const instanceOfModule = runtimeRequire('graphql/jsutils/instanceOf.js');
+  const graphqlSpecifier = 'graphql';
+  const yogaSpecifier = 'graphql-yoga';
+  const instanceOfSpecifier = 'graphql/jsutils/instanceOf.js';
+  const [graphqlMod, yogaMod] = await Promise.all([import(/* @vite-ignore */graphqlSpecifier), import(/* @vite-ignore */yogaSpecifier)]);
+  const instanceOfModule = runtimeRequire(instanceOfSpecifier);
   return {
     GraphQLError: graphqlMod.GraphQLError,
     GraphQLBoolean: graphqlMod.GraphQLBoolean,
@@ -198,11 +109,13 @@ async function loadGraphqlDeps() {
     GraphQLID: graphqlMod.GraphQLID,
     GraphQLInt: graphqlMod.GraphQLInt,
     GraphQLList: graphqlMod.GraphQLList,
+    GraphQLNonNull: graphqlMod.GraphQLNonNull,
     GraphQLObjectType: graphqlMod.GraphQLObjectType,
     GraphQLSchema: graphqlMod.GraphQLSchema,
     GraphQLString: graphqlMod.GraphQLString,
     GraphQLUnionType: graphqlMod.GraphQLUnionType,
     buildSchema: graphqlMod.buildSchema,
+    createGraphQLError: yogaMod.createGraphQLError,
     createYoga: yogaMod.createYoga,
     execute: graphqlMod.execute,
     instanceOfModule,
@@ -218,62 +131,60 @@ class GraphqlLifecycleService {
   static {
     [_GraphqlLifecycleServ, _initClass2] = _applyDecs(this, [Inject(RUNTIME_CONTAINER, COMPILED_MODULES, APPLICATION_LOGGER, HTTP_APPLICATION_ADAPTER, GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN)], []).c;
   }
+  allowedCrossRealmGraphqlObjects;
   graphQLErrorConstructor;
-  middlewareRegistered = false;
-  operationContainers = new WeakMap();
+  operationContainers = new Map();
   requestContexts = new WeakMap();
+  failedWebsocketOperationContainers = new Map();
+  websocketContainerDisposals = new Map();
+  websocketContainersAttemptedInCurrentCleanup;
   websocketOperationContainers = new Map();
-  websocketDisposable;
-  websocketServer;
-  websocketUpgradeListener;
-  websocketUpgradeServer;
+  websocketTransport;
   executeGraphqlOperation;
   releaseGraphqlInstanceOfPatch;
   subscribeGraphqlOperation;
   yoga;
-  middleware = {
-    handle: async (context, next) => {
-      if (!isGraphqlPath(context.request.path)) {
-        await next();
-        return;
+  async handle(context, next) {
+    if (!isGraphqlPath(context.request.path)) {
+      await next();
+      return;
+    }
+    const yoga = this.yoga;
+    if (!yoga) {
+      this.logger.error('GraphQL middleware was invoked before GraphQL Yoga initialization.', undefined, 'GraphqlLifecycleService');
+      context.response.setStatus(500);
+      await context.response.send({
+        errors: [{
+          message: 'GraphQL server not initialized.'
+        }]
+      });
+      return;
+    }
+    try {
+      const fetchRequest = toFetchRequest(context.request);
+      this.requestContexts.set(fetchRequest, {
+        principal: context.requestContext.principal,
+        request: context.request
+      });
+      try {
+        const fetchResponse = await yoga.fetch(fetchRequest);
+        await writeFetchResponse(fetchResponse, context.response);
+      } finally {
+        this.requestContexts.delete(fetchRequest);
+        await this.disposeOperationContainer(fetchRequest);
       }
-      const yoga = this.yoga;
-      if (!yoga) {
-        this.logger.error('GraphQL middleware was invoked before GraphQL Yoga initialization.', undefined, 'GraphqlLifecycleService');
+    } catch (error) {
+      this.logger.error('Failed to process GraphQL request.', error, 'GraphqlLifecycleService');
+      if (!context.response.committed) {
         context.response.setStatus(500);
         await context.response.send({
           errors: [{
-            message: 'GraphQL server not initialized.'
+            message: 'Internal server error.'
           }]
         });
-        return;
-      }
-      try {
-        const fetchRequest = toFetchRequest(context.request);
-        this.requestContexts.set(fetchRequest, {
-          principal: context.requestContext.principal,
-          request: context.request
-        });
-        try {
-          const fetchResponse = await yoga.fetch(fetchRequest);
-          await writeFetchResponse(fetchResponse, context.response);
-        } finally {
-          this.requestContexts.delete(fetchRequest);
-          await this.disposeOperationContainer(fetchRequest);
-        }
-      } catch (error) {
-        this.logger.error('Failed to process GraphQL request.', error, 'GraphqlLifecycleService');
-        if (!context.response.committed) {
-          context.response.setStatus(500);
-          await context.response.send({
-            errors: [{
-              message: 'Internal server error.'
-            }]
-          });
-        }
       }
     }
-  };
+  }
   constructor(runtimeContainer, compiledModules, logger, adapter, options) {
     this.runtimeContainer = runtimeContainer;
     this.compiledModules = compiledModules;
@@ -282,7 +193,7 @@ class GraphqlLifecycleService {
     this.options = options;
   }
   async onApplicationBootstrap() {
-    if (this.middlewareRegistered) {
+    if (this.yoga) {
       return;
     }
     try {
@@ -306,8 +217,6 @@ class GraphqlLifecycleService {
         schema
       });
       await this.registerWebSocketTransport();
-      this.registerMiddleware();
-      this.middlewareRegistered = true;
     } catch (error) {
       try {
         await this.resetGraphqlRuntimeState();
@@ -321,13 +230,28 @@ class GraphqlLifecycleService {
     await this.resetGraphqlRuntimeState();
   }
   async resetGraphqlRuntimeState() {
-    await this.unregisterWebSocketTransport();
-    this.unregisterMiddleware();
-    this.middlewareRegistered = false;
+    const cleanupErrors = [];
+    this.websocketContainersAttemptedInCurrentCleanup = new Set();
+    try {
+      await this.unregisterWebSocketTransport();
+    } catch (error) {
+      collectCleanupError(cleanupErrors, error);
+    } finally {
+      this.websocketContainersAttemptedInCurrentCleanup = undefined;
+    }
+    try {
+      await this.disposeAllOperationContainers();
+    } catch (error) {
+      collectCleanupError(cleanupErrors, error);
+    }
+    if (cleanupErrors.length > 0) {
+      throw new AggregateError(cleanupErrors, 'Failed to clean up GraphQL runtime resources.');
+    }
     this.executeGraphqlOperation = undefined;
     this.graphQLErrorConstructor = undefined;
     this.releaseGraphqlInstanceOfPatch?.();
     this.releaseGraphqlInstanceOfPatch = undefined;
+    this.allowedCrossRealmGraphqlObjects = undefined;
     this.subscribeGraphqlOperation = undefined;
     this.yoga = undefined;
   }
@@ -349,43 +273,18 @@ class GraphqlLifecycleService {
     };
   }
   resolveSchema(deps) {
-    this.releaseGraphqlInstanceOfPatch ??= installGraphqlInstanceOfPatch(deps.instanceOfModule);
-    return resolveSchema(deps, this.options.schema, () => this.createCodeFirstSchema(deps), markAllowedCrossRealmGraphqlObjects);
+    const allowedObjects = this.allowedCrossRealmGraphqlObjects ?? new WeakSet();
+    this.allowedCrossRealmGraphqlObjects = allowedObjects;
+    this.releaseGraphqlInstanceOfPatch ??= installGraphqlInstanceOfPatch(deps.instanceOfModule, allowedObjects);
+    const markAllowedObject = value => markAllowedCrossRealmGraphqlObjects(value, allowedObjects);
+    return resolveSchema(deps, this.options.schema, () => this.createCodeFirstSchema(deps, markAllowedObject), markAllowedObject);
   }
-  createCodeFirstSchema(deps) {
-    return createCodeFirstSchema(deps, this.runtimeContainer, this.discoverResolverDescriptors(), markAllowedCrossRealmGraphqlObjects);
+  createCodeFirstSchema(deps, markAllowedObject) {
+    return createCodeFirstSchema(deps, this.runtimeContainer, this.discoverResolverDescriptors(), markAllowedObject);
   }
   discoverResolverDescriptors() {
     return discoverResolverDescriptors(this.compiledModules, this.options);
   }
-  registerMiddleware() {
-    for (const compiledModule of this.compiledModules) {
-      if (!compiledModule.providerTokens.has(_GraphqlLifecycleServ)) {
-        continue;
-      }
-      const middleware = compiledModule.definition.middleware ?? [];
-      if (!middleware.includes(this.middleware)) {
-        compiledModule.definition.middleware = [...middleware, this.middleware];
-        continue;
-      }
-      compiledModule.definition.middleware = [...middleware];
-    }
-  }
-  unregisterMiddleware() {
-    for (const compiledModule of this.compiledModules) {
-      if (!compiledModule.providerTokens.has(_GraphqlLifecycleServ)) {
-        continue;
-      }
-      const middleware = compiledModule.definition.middleware ?? [];
-      const remaining = [];
-      for (const entry of middleware) {
-        if (entry !== this.middleware) {
-          remaining.push(entry);
-        }
-      }
-      compiledModule.definition.middleware = remaining;
-    }
-  }
   buildGraphqlContext(request, requestContextOverride, operationContainerOverride) {
     const storedContext = this.requestContexts.get(request);
     const requestContext = {
@@ -406,126 +305,81 @@ class GraphqlLifecycleService {
     };
   }
   async registerWebSocketTransport() {
-    if (!this.isWebSocketTransportEnabled() || this.yoga === undefined || this.websocketUpgradeListener !== undefined) {
+    if (!this.isWebSocketTransportEnabled() || this.yoga === undefined || this.websocketTransport !== undefined) {
       return;
     }
-    const [{
-      handleProtocols
-    }, {
-      useServer
-    }, {
-      WebSocketServer
-    }] = await Promise.all([import('graphql-ws'), import('graphql-ws/lib/use/ws'), import('ws')]);
-    const upgradeServer = this.resolveUpgradeServer();
-    const websocketLimits = this.resolveWebSocketLimits();
-    const websocketServer = new WebSocketServer({
-      handleProtocols: protocols => handleProtocols(protocols),
-      maxPayload: websocketLimits?.maxPayloadBytes ?? 0,
-      noServer: true
-    });
-    const upgradeListener = (request, socket, head) => {
-      const targetPath = new URL(request.url ?? '/', 'http://localhost').pathname;
-      if (!isGraphqlPath(targetPath)) {
-        return;
-      }
-      if (websocketLimits && websocketServer.clients.size >= websocketLimits.maxConnections) {
-        this.rejectWebSocketUpgrade(socket, 503, 'GraphQL websocket connection count exceeds the configured limit.');
-        return;
-      }
-      websocketServer.handleUpgrade(request, socket, head, websocket => {
-        websocketServer.emit('connection', websocket, request);
-      });
-    };
-    const websocketDisposable = useServer({
-      connectionInitWaitTimeout: this.options.subscriptions?.websocket?.connectionInitWaitTimeoutMs,
+    const {
+      createNodeGraphqlWebSocketTransport
+    } = await import('./node/graphql-websocket-transport.js');
+    this.websocketTransport = await createNodeGraphqlWebSocketTransport({
+      adapter: this.adapter,
+      connectionInitWaitTimeoutMs: this.options.subscriptions?.websocket?.connectionInitWaitTimeoutMs,
       execute: args => {
         if (!this.executeGraphqlOperation) {
           throw new Error('GraphQL execute function not initialized.');
         }
         return this.executeGraphqlOperation(args);
       },
-      onComplete: async (context, message) => {
-        await this.disposeWebSocketOperationContainer(context.extra.socket, message.id);
+      keepAliveMs: this.options.subscriptions?.websocket?.keepAliveMs,
+      limits: this.resolveWebSocketLimits(),
+      onComplete: async (socketKey, operationId) => {
+        await this.disposeWebSocketOperationContainer(socketKey, operationId);
       },
-      onDisconnect: async context => {
-        await this.disposeAllWebSocketOperationContainers(context.extra.socket);
-      },
-      onSubscribe: async (context, message) => this.handleWebSocketSubscribe(context, message.id, message.payload),
+      onDisconnect: socketKey => this.disposeAllWebSocketOperationContainers(socketKey),
+      onSubscribe: request => this.handleWebSocketSubscribe(request),
       subscribe: args => {
         if (!this.subscribeGraphqlOperation) {
           throw new Error('GraphQL subscribe function not initialized.');
         }
         return this.subscribeGraphqlOperation(args);
       }
-    }, websocketServer, this.options.subscriptions?.websocket?.keepAliveMs);
-    upgradeServer.on('upgrade', upgradeListener);
-    this.websocketDisposable = websocketDisposable;
-    this.websocketServer = websocketServer;
-    this.websocketUpgradeListener = upgradeListener;
-    this.websocketUpgradeServer = upgradeServer;
+    });
   }
   async unregisterWebSocketTransport() {
-    if (this.websocketUpgradeListener && this.websocketUpgradeServer) {
-      this.websocketUpgradeServer.off('upgrade', this.websocketUpgradeListener);
-    }
-    this.websocketUpgradeListener = undefined;
-    this.websocketUpgradeServer = undefined;
-    if (this.websocketServer) {
-      for (const client of this.websocketServer.clients) {
-        client.terminate();
-      }
-    }
-    if (this.websocketDisposable) {
+    const cleanupErrors = [];
+    if (this.websocketTransport) {
       try {
-        await this.websocketDisposable.dispose();
+        await this.websocketTransport.dispose();
       } catch (error) {
         this.logger.error('Failed to dispose GraphQL websocket transport.', error, 'GraphqlLifecycleService');
+        collectCleanupError(cleanupErrors, error);
+      }
+      if (cleanupErrors.length === 0) {
+        this.websocketTransport = undefined;
       }
     }
-    this.websocketDisposable = undefined;
-    if (this.websocketServer) {
+    const socketKeys = new Set([...this.websocketOperationContainers.keys(), ...this.failedWebsocketOperationContainers.keys()]);
+    for (const socketKey of socketKeys) {
       try {
-        await closeWebSocketServer(this.websocketServer);
+        await this.disposeAllWebSocketOperationContainers(socketKey);
       } catch (error) {
-        this.logger.error('Failed to close GraphQL websocket server.', error, 'GraphqlLifecycleService');
+        collectCleanupError(cleanupErrors, error);
       }
     }
-    this.websocketServer = undefined;
-    for (const socketKey of this.websocketOperationContainers.keys()) {
-      await this.disposeAllWebSocketOperationContainers(socketKey);
+    if (cleanupErrors.length > 0) {
+      throw new AggregateError(cleanupErrors, 'Failed to dispose GraphQL websocket resources.');
     }
   }
   isWebSocketTransportEnabled() {
     return this.options.subscriptions?.websocket?.enabled === true;
   }
-  resolveUpgradeServer() {
-    if (typeof this.adapter.getServer !== 'function') {
-      throw new Error('GraphQL websocket subscriptions require an HTTP adapter with getServer(). Use the Node HTTP adapter or provide a compatible adapter implementation.');
-    }
-    const server = this.adapter.getServer();
-    if (!hasNodeUpgradeServer(server)) {
-      throw new Error('GraphQL websocket subscriptions require adapter.getServer() to return a Node HTTP/S server that supports upgrade listeners.');
-    }
-    return server;
-  }
-  async handleWebSocketSubscribe(context, operationId, payload) {
+  async handleWebSocketSubscribe(request) {
     const yoga = this.yoga;
     if (!yoga) {
       throw new Error('GraphQL server not initialized.');
     }
-    const websocketLimitError = this.createWebSocketOperationLimitError(context.extra.socket, operationId);
+    const websocketLimitError = this.createWebSocketOperationLimitError(request.socket, request.operationId);
     if (websocketLimitError) {
       return [websocketLimitError];
     }
-    const frameworkRequest = buildFrameworkRequestFromIncomingMessage(context.extra.request);
-    const fetchRequest = toFetchRequest(frameworkRequest);
-    const operationContainer = this.getOrCreateWebSocketOperationContainer(context.extra.socket, operationId);
-    const graphqlContext = this.buildGraphqlContext(fetchRequest, {
-      connectionParams: isConnectionParamsRecord(context.connectionParams) ? context.connectionParams : undefined,
-      request: frameworkRequest,
-      socket: context.extra.socket
-    }, operationContainer);
+    const fetchRequest = toFetchRequest(request.request);
+    const operationContainer = this.getOrCreateWebSocketOperationContainer(request.socket, request.operationId);
     try {
+      const graphqlContext = this.buildGraphqlContext(fetchRequest, {
+        connectionParams: request.connectionParams,
+        request: request.request,
+        socket: request.socket
+      }, operationContainer);
       const {
         contextFactory,
         parse,
@@ -535,21 +389,21 @@ class GraphqlLifecycleService {
         request: fetchRequest,
         [GRAPHQL_CONTEXT_OVERRIDE]: graphqlContext
       });
-      const document = parse(payload.query);
+      const document = parse(request.payload.query);
       const validationErrors = validate(schema, document);
       if (validationErrors.length > 0) {
-        await this.disposeWebSocketOperationContainer(context.extra.socket, operationId);
+        await this.disposeWebSocketOperationContainer(request.socket, request.operationId);
         return validationErrors;
       }
       return {
         contextValue: await contextFactory(),
         document,
-        operationName: payload.operationName ?? undefined,
+        operationName: request.payload.operationName ?? undefined,
         schema,
-        variableValues: payload.variables
+        variableValues: request.payload.variables
       };
     } catch (error) {
-      await this.disposeWebSocketOperationContainer(context.extra.socket, operationId);
+      await this.disposeWebSocketOperationContainer(request.socket, request.operationId);
       throw error;
     }
   }
@@ -568,15 +422,6 @@ class GraphqlLifecycleService {
     }
     return new GraphQLError(`GraphQL websocket active operation count exceeds the configured limit of ${String(limits.maxOperationsPerConnection)}.`);
   }
-  rejectWebSocketUpgrade(socket, statusCode, message) {
-    if (!socket.writable) {
-      socket.destroy();
-      return;
-    }
-    const body = `${message}\n`;
-    socket.write([`HTTP/1.1 ${String(statusCode)} ${statusCode === 503 ? 'Service Unavailable' : 'Bad Request'}`, 'Connection: close', 'Content-Type: text/plain; charset=utf-8', `Content-Length: ${String(new TextEncoder().encode(body).byteLength)}`, '', body].join('\r\n'));
-    socket.destroy();
-  }
   getOrCreateWebSocketOperationContainer(socketKey, operationId) {
     const existingSocketContainers = this.websocketOperationContainers.get(socketKey);
     if (existingSocketContainers?.has(operationId)) {
@@ -598,25 +443,55 @@ class GraphqlLifecycleService {
     if (socketContainers && socketContainers.size === 0) {
       this.websocketOperationContainers.delete(socketKey);
     }
-    try {
-      await operationContainer.dispose();
-    } catch (error) {
-      this.logger.error('Failed to dispose GraphQL websocket operation container.', error, 'GraphqlLifecycleService');
+    return await this.disposeWebSocketContainerOnce(socketKey, operationContainer);
+  }
+  async disposeWebSocketContainerOnce(socketKey, operationContainer) {
+    const inFlight = this.websocketContainerDisposals.get(operationContainer);
+    if (inFlight) {
+      return await inFlight;
     }
+    const attempted = this.websocketContainersAttemptedInCurrentCleanup;
+    if (attempted?.has(operationContainer)) {
+      return undefined;
+    }
+    attempted?.add(operationContainer);
+    const disposal = operationContainer.dispose().then(() => {
+      this.failedWebsocketOperationContainers.get(socketKey)?.delete(operationContainer);
+      return undefined;
+    }, error => {
+      const failedContainers = this.failedWebsocketOperationContainers.get(socketKey) ?? new Set();
+      failedContainers.add(operationContainer);
+      this.failedWebsocketOperationContainers.set(socketKey, failedContainers);
+      this.logger.error('Failed to dispose GraphQL websocket operation container.', error, 'GraphqlLifecycleService');
+      return error;
+    }).finally(() => {
+      this.websocketContainerDisposals.delete(operationContainer);
+    });
+    this.websocketContainerDisposals.set(operationContainer, disposal);
+    return await disposal;
   }
   async disposeAllWebSocketOperationContainers(socketKey) {
-    const socketContainers = this.websocketOperationContainers.get(socketKey);
-    if (!socketContainers) {
-      return;
+    const cleanupErrors = [];
+    const failedContainers = this.failedWebsocketOperationContainers.get(socketKey);
+    for (const operationContainer of [...(failedContainers ?? [])]) {
+      const cleanupError = await this.disposeWebSocketContainerOnce(socketKey, operationContainer);
+      if (cleanupError !== undefined) {
+        collectCleanupError(cleanupErrors, cleanupError);
+      }
     }
-    this.websocketOperationContainers.delete(socketKey);
-    for (const operationContainer of socketContainers.values()) {
-      try {
-        await operationContainer.dispose();
-      } catch (error) {
-        this.logger.error('Failed to dispose GraphQL websocket operation container.', error, 'GraphqlLifecycleService');
+    if (failedContainers?.size === 0) {
+      this.failedWebsocketOperationContainers.delete(socketKey);
+    }
+    const socketContainers = this.websocketOperationContainers.get(socketKey);
+    for (const operationId of [...(socketContainers?.keys() ?? [])]) {
+      const cleanupError = await this.disposeWebSocketOperationContainer(socketKey, operationId);
+      if (cleanupError !== undefined) {
+        collectCleanupError(cleanupErrors, cleanupError);
       }
     }
+    if (cleanupErrors.length > 0) {
+      throw new AggregateError(cleanupErrors, 'Failed to dispose GraphQL websocket operation containers.');
+    }
   }
   getOrCreateOperationContainer(request) {
     const existing = this.operationContainers.get(request);
@@ -632,11 +507,24 @@ class GraphqlLifecycleService {
     if (!operationContainer) {
       return;
     }
-    this.operationContainers.delete(request);
     try {
       await operationContainer.dispose();
     } catch (error) {
       this.logger.error('Failed to dispose GraphQL operation container.', error, 'GraphqlLifecycleService');
+      return error;
+    }
+    this.operationContainers.delete(request);
+  }
+  async disposeAllOperationContainers() {
+    const cleanupErrors = [];
+    for (const request of [...this.operationContainers.keys()]) {
+      const cleanupError = await this.disposeOperationContainer(request);
+      if (cleanupError !== undefined) {
+        collectCleanupError(cleanupErrors, cleanupError);
+      }
+    }
+    if (cleanupErrors.length > 0) {
+      throw new AggregateError(cleanupErrors, 'Failed to dispose GraphQL operation containers.');
     }
   }
   static {