@fluojs/graphql 1.0.0-beta.1

package/dist/service.js

@@ -0,0 +1,602 @@
+let _initProto, _initClass, _initClass2;
+function _applyDecs(e, t, n, r, o, i) { var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length; function g(t, n, r) { return function (o, i) { n && (i = o, o = e); for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); return r ? i : o; }; } function b(e, t, n, r) { if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); return e; } function applyDec(e, t, n, r, o, i, u, s, f, l, p) { function d(e) { if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); } var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o; function I(t, n, r) { return function (o, i) { return n && (i = o, o = e), r && r(o), P[t].call(o, i); }; } if (!w) { var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value"; if (f ? (l || D ? P = { get: _setFunctionName(function () { return v(this); }, r, "get"), set: function (e) { t[4](this, e); } } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); y[+s][r] = o < 3 ? 1 : o; } } for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: r, metadata: a, addInitializer: function (e, t) { if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); b(t, "An initializer", "be", !0), i.push(t); }.bind(null, A) }; if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function (e) { return r in e; } }, j || (c.get = f ? E ? function (e) { return d(e), P.value; } : I("get", 0, d) : function (e) { return e[r]; }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { e[r] = t; }), N = T.call(z, D ? { get: P.get, set: P.set } : P[F], H), A.v = 1, D) { if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); } return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; } function w(e) { return m(e, d, { configurable: !0, enumerable: !0, value: a }); } return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function (e) { e && f.push(g(e)); }, p = function (t, r) { for (var i = 0; i < n.length; i++) { var a = n[i], c = a[1], l = 7 & c; if ((8 & c) == t && !l == r) { var p = a[2], d = !!a[3], m = 16 & c; applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { return _checkInRHS(t) === e; } : o); } } }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { e: c, get c() { var n = []; return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; } }; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+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 { AsyncLocalStorage } from 'node:async_hooks';
+import { createRequire } from 'node:module';
+import { Controller, Get, Post } from '@fluojs/http';
+import { Inject } from '@fluojs/core';
+import { APPLICATION_LOGGER, COMPILED_MODULES, HTTP_APPLICATION_ADAPTER, RUNTIME_CONTAINER } from '@fluojs/runtime/internal';
+import { handleProtocols } from 'graphql-ws';
+import { useServer } from 'graphql-ws/lib/use/ws';
+import { WebSocketServer } from 'ws';
+import { discoverResolverDescriptors } from './discovery.js';
+import { createGraphqlValidationPlugin, resolveGraphqlRequestLimits } from './guardrails.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 DEFAULT_GRAPHQL_WEBSOCKET_LIMITS = {
+  maxConnections: 100,
+  maxOperationsPerConnection: 25,
+  maxPayloadBytes: 64 * 1024
+};
+function hasNodeUpgradeServer(value) {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  const server = value;
+  return typeof server.on === 'function' && typeof server.off === 'function';
+}
+function buildFrameworkRequestFromFetchRequest(request) {
+  const requestUrl = new URL(request.url);
+  return {
+    cookies: {},
+    headers: Object.fromEntries(request.headers.entries()),
+    method: request.method,
+    params: {},
+    path: requestUrl.pathname,
+    query: Object.fromEntries(requestUrl.searchParams.entries()),
+    raw: request,
+    signal: request.signal,
+    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();
+    });
+  });
+}
+const graphqlRequestContextStorage = new AsyncLocalStorage();
+const runtimeRequire = createRequire(import.meta.url);
+let graphqlInstanceOfPatched = false;
+const allowedCrossRealmGraphqlObjects = new WeakSet();
+
+/**
+ * Declares the HTTP endpoints that receive GraphQL GET and POST requests.
+ */
+let _GraphqlEndpointContr;
+class GraphqlEndpointController {
+  static {
+    ({
+      e: [_initProto],
+      c: [_GraphqlEndpointContr, _initClass]
+    } = _applyDecs(this, [Controller('/graphql')], [[Get('/'), 2, "handleGet"], [Post('/'), 2, "handlePost"]]));
+  }
+  constructor() {
+    _initProto(this);
+  }
+  handleGet() {
+    return undefined;
+  }
+  handlePost() {
+    return undefined;
+  }
+  static {
+    _initClass();
+  }
+}
+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()) {
+  if (typeof value !== 'object' || value === null) {
+    return;
+  }
+  if (visited.has(value)) {
+    return;
+  }
+  visited.add(value);
+  const tag = value[Symbol.toStringTag];
+  if (typeof tag === 'string' && tag.startsWith('GraphQL')) {
+    allowedCrossRealmGraphqlObjects.add(value);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      markAllowedCrossRealmGraphqlObjects(item, visited);
+    }
+    return;
+  }
+  for (const nestedValue of Object.values(value)) {
+    markAllowedCrossRealmGraphqlObjects(nestedValue, visited);
+  }
+}
+function isAllowedCrossRealmGraphqlObject(value, constructor) {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  return allowedCrossRealmGraphqlObjects.has(value) && getCrossRealmGraphqlTag(value, constructor) !== undefined;
+}
+function patchGraphqlInstanceOf() {
+  if (graphqlInstanceOfPatched) {
+    return;
+  }
+  const instanceOfModule = runtimeRequire('graphql/jsutils/instanceOf.js');
+  const originalInstanceOf = instanceOfModule.instanceOf;
+  instanceOfModule.instanceOf = (value, constructor) => {
+    try {
+      if (originalInstanceOf(value, constructor)) {
+        return true;
+      }
+    } catch (error) {
+      if (isAllowedCrossRealmGraphqlObject(value, constructor)) {
+        return true;
+      }
+      throw error;
+    }
+    return isAllowedCrossRealmGraphqlObject(value, constructor);
+  };
+  graphqlInstanceOfPatched = true;
+}
+async function loadGraphqlDeps() {
+  const graphqlMod = runtimeRequire('graphql');
+  const yogaMod = runtimeRequire('graphql-yoga');
+  return {
+    GraphQLError: graphqlMod.GraphQLError,
+    GraphQLBoolean: graphqlMod.GraphQLBoolean,
+    GraphQLFloat: graphqlMod.GraphQLFloat,
+    GraphQLID: graphqlMod.GraphQLID,
+    GraphQLInt: graphqlMod.GraphQLInt,
+    GraphQLList: graphqlMod.GraphQLList,
+    GraphQLObjectType: graphqlMod.GraphQLObjectType,
+    GraphQLSchema: graphqlMod.GraphQLSchema,
+    GraphQLString: graphqlMod.GraphQLString,
+    GraphQLUnionType: graphqlMod.GraphQLUnionType,
+    buildSchema: graphqlMod.buildSchema,
+    createYoga: yogaMod.createYoga,
+    execute: graphqlMod.execute,
+    subscribe: graphqlMod.subscribe
+  };
+}
+
+/**
+ * Boots the GraphQL runtime, middleware, and subscription transports for the active adapter.
+ */
+let _GraphqlLifecycleServ;
+class GraphqlLifecycleService {
+  static {
+    [_GraphqlLifecycleServ, _initClass2] = _applyDecs(this, [Inject(RUNTIME_CONTAINER, COMPILED_MODULES, APPLICATION_LOGGER, HTTP_APPLICATION_ADAPTER, GRAPHQL_INTERNAL_MODULE_OPTIONS_TOKEN)], []).c;
+  }
+  graphQLErrorConstructor;
+  middlewareRegistered = false;
+  operationContainers = new WeakMap();
+  websocketOperationContainers = new Map();
+  websocketDisposable;
+  websocketServer;
+  websocketUpgradeListener;
+  websocketUpgradeServer;
+  executeGraphqlOperation;
+  subscribeGraphqlOperation;
+  yoga;
+  middleware = {
+    handle: async (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);
+        try {
+          const fetchResponse = await graphqlRequestContextStorage.run({
+            principal: context.requestContext.principal,
+            request: context.request
+          }, () => yoga.fetch(fetchRequest));
+          await writeFetchResponse(fetchResponse, context.response);
+        } finally {
+          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;
+    this.logger = logger;
+    this.adapter = adapter;
+    this.options = options;
+  }
+  async onApplicationBootstrap() {
+    if (this.middlewareRegistered) {
+      return;
+    }
+    const deps = await loadGraphqlDeps();
+    const schema = this.resolveSchema(deps);
+    this.executeGraphqlOperation = deps.execute;
+    this.graphQLErrorConstructor = deps.GraphQLError;
+    this.subscribeGraphqlOperation = deps.subscribe;
+    const requestLimits = resolveGraphqlRequestLimits(this.options.limits);
+    const validationPlugin = createGraphqlValidationPlugin({
+      introspection: this.resolveIntrospectionEnabled(),
+      limits: requestLimits
+    });
+    this.yoga = deps.createYoga({
+      context: contextValue => contextValue[GRAPHQL_CONTEXT_OVERRIDE] ?? this.buildGraphqlContext(contextValue.request),
+      graphqlEndpoint: '/graphql',
+      graphiql: this.resolveGraphiqlEnabled(),
+      ...(validationPlugin || this.options.plugins && this.options.plugins.length > 0 ? {
+        plugins: [...(validationPlugin ? [validationPlugin] : []), ...(this.options.plugins ?? [])]
+      } : {}),
+      schema
+    });
+    this.registerWebSocketTransport();
+    this.registerMiddleware();
+    this.middlewareRegistered = true;
+  }
+  async onApplicationShutdown() {
+    await this.unregisterWebSocketTransport();
+    this.unregisterMiddleware();
+    this.middlewareRegistered = false;
+    this.executeGraphqlOperation = undefined;
+    this.graphQLErrorConstructor = undefined;
+    this.subscribeGraphqlOperation = undefined;
+    this.yoga = undefined;
+  }
+  resolveGraphiqlEnabled() {
+    return this.options.graphiql ?? false;
+  }
+  resolveIntrospectionEnabled() {
+    return this.options.introspection ?? this.resolveGraphiqlEnabled();
+  }
+  resolveWebSocketLimits() {
+    const limits = this.options.subscriptions?.websocket?.limits;
+    if (limits === false) {
+      return undefined;
+    }
+    return {
+      maxConnections: limits?.maxConnections ?? DEFAULT_GRAPHQL_WEBSOCKET_LIMITS.maxConnections,
+      maxOperationsPerConnection: limits?.maxOperationsPerConnection ?? DEFAULT_GRAPHQL_WEBSOCKET_LIMITS.maxOperationsPerConnection,
+      maxPayloadBytes: limits?.maxPayloadBytes ?? DEFAULT_GRAPHQL_WEBSOCKET_LIMITS.maxPayloadBytes
+    };
+  }
+  resolveSchema(deps) {
+    patchGraphqlInstanceOf();
+    return resolveSchema(deps, this.options.schema, () => this.createCodeFirstSchema(deps), markAllowedCrossRealmGraphqlObjects);
+  }
+  createCodeFirstSchema(deps) {
+    return createCodeFirstSchema(deps, this.runtimeContainer, this.discoverResolverDescriptors(), markAllowedCrossRealmGraphqlObjects);
+  }
+  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 = graphqlRequestContextStorage.getStore();
+    const requestContext = {
+      connectionParams: requestContextOverride?.connectionParams,
+      principal: requestContextOverride?.principal ?? storedContext?.principal,
+      request: requestContextOverride?.request ?? storedContext?.request ?? buildFrameworkRequestFromFetchRequest(request),
+      socket: requestContextOverride?.socket
+    };
+    const customContext = this.options.context?.(requestContext) ?? {};
+    const operationContainer = operationContainerOverride ?? this.getOrCreateOperationContainer(request);
+    return {
+      ...customContext,
+      connectionParams: requestContext.connectionParams,
+      principal: requestContext.principal,
+      request: requestContext.request,
+      socket: requestContext.socket,
+      [GRAPHQL_OPERATION_CONTAINER]: operationContainer
+    };
+  }
+  registerWebSocketTransport() {
+    if (!this.isWebSocketTransportEnabled() || this.yoga === undefined || this.websocketUpgradeListener !== undefined) {
+      return;
+    }
+    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,
+      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);
+      },
+      onDisconnect: async context => {
+        await this.disposeAllWebSocketOperationContainers(context.extra.socket);
+      },
+      onSubscribe: async (context, message) => this.handleWebSocketSubscribe(context, message.id, message.payload),
+      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) {
+      try {
+        await this.websocketDisposable.dispose();
+      } catch (error) {
+        this.logger.error('Failed to dispose GraphQL websocket transport.', error, 'GraphqlLifecycleService');
+      }
+    }
+    this.websocketDisposable = undefined;
+    if (this.websocketServer) {
+      try {
+        await closeWebSocketServer(this.websocketServer);
+      } catch (error) {
+        this.logger.error('Failed to close GraphQL websocket server.', error, 'GraphqlLifecycleService');
+      }
+    }
+    this.websocketServer = undefined;
+    for (const socketKey of this.websocketOperationContainers.keys()) {
+      await this.disposeAllWebSocketOperationContainers(socketKey);
+    }
+  }
+  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) {
+    const yoga = this.yoga;
+    if (!yoga) {
+      throw new Error('GraphQL server not initialized.');
+    }
+    const websocketLimitError = this.createWebSocketOperationLimitError(context.extra.socket, 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);
+    try {
+      const {
+        contextFactory,
+        parse,
+        schema,
+        validate
+      } = yoga.getEnveloped({
+        request: fetchRequest,
+        [GRAPHQL_CONTEXT_OVERRIDE]: graphqlContext
+      });
+      const document = parse(payload.query);
+      const validationErrors = validate(schema, document);
+      if (validationErrors.length > 0) {
+        await this.disposeWebSocketOperationContainer(context.extra.socket, operationId);
+        return validationErrors;
+      }
+      return {
+        contextValue: await contextFactory(),
+        document,
+        operationName: payload.operationName ?? undefined,
+        schema,
+        variableValues: payload.variables
+      };
+    } catch (error) {
+      await this.disposeWebSocketOperationContainer(context.extra.socket, operationId);
+      throw error;
+    }
+  }
+  createWebSocketOperationLimitError(socketKey, operationId) {
+    const limits = this.resolveWebSocketLimits();
+    if (!limits) {
+      return undefined;
+    }
+    const socketContainers = this.websocketOperationContainers.get(socketKey);
+    if (socketContainers?.has(operationId) || (socketContainers?.size ?? 0) < limits.maxOperationsPerConnection) {
+      return undefined;
+    }
+    const GraphQLError = this.graphQLErrorConstructor;
+    if (!GraphQLError) {
+      throw new Error('GraphQL error constructor not initialized.');
+    }
+    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(Buffer.byteLength(body))}`, '', body].join('\r\n'));
+    socket.destroy();
+  }
+  getOrCreateWebSocketOperationContainer(socketKey, operationId) {
+    const existingSocketContainers = this.websocketOperationContainers.get(socketKey);
+    if (existingSocketContainers?.has(operationId)) {
+      return existingSocketContainers.get(operationId);
+    }
+    const created = this.runtimeContainer.createRequestScope();
+    const socketContainers = existingSocketContainers ?? new Map();
+    socketContainers.set(operationId, created);
+    this.websocketOperationContainers.set(socketKey, socketContainers);
+    return created;
+  }
+  async disposeWebSocketOperationContainer(socketKey, operationId) {
+    const socketContainers = this.websocketOperationContainers.get(socketKey);
+    const operationContainer = socketContainers?.get(operationId);
+    if (!operationContainer) {
+      return;
+    }
+    socketContainers?.delete(operationId);
+    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');
+    }
+  }
+  async disposeAllWebSocketOperationContainers(socketKey) {
+    const socketContainers = this.websocketOperationContainers.get(socketKey);
+    if (!socketContainers) {
+      return;
+    }
+    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');
+      }
+    }
+  }
+  getOrCreateOperationContainer(request) {
+    const existing = this.operationContainers.get(request);
+    if (existing) {
+      return existing;
+    }
+    const created = this.runtimeContainer.createRequestScope();
+    this.operationContainers.set(request, created);
+    return created;
+  }
+  async disposeOperationContainer(request) {
+    const operationContainer = this.operationContainers.get(request);
+    if (!operationContainer) {
+      return;
+    }
+    this.operationContainers.delete(request);
+    try {
+      await operationContainer.dispose();
+    } catch (error) {
+      this.logger.error('Failed to dispose GraphQL operation container.', error, 'GraphqlLifecycleService');
+    }
+  }
+  static {
+    _initClass2();
+  }
+}
+export { _GraphqlLifecycleServ as GraphqlLifecycleService };

package/dist/transport/transport.d.ts

@@ -0,0 +1,5 @@
+import type { FrameworkRequest, FrameworkResponse } from '@fluojs/http';
+export declare function isGraphqlPath(path: string): boolean;
+export declare function toFetchRequest(request: FrameworkRequest): Request;
+export declare function writeFetchResponse(fetchResponse: Response, frameworkResponse: FrameworkResponse): Promise<void>;
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/transport/transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAA2B,MAAM,cAAc,CAAC;AAEjG,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAsED,wBAAgB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAUjE;AAsBD,wBAAsB,kBAAkB,CAAC,aAAa,EAAE,QAAQ,EAAE,iBAAiB,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqDrH"}