nitro-graphql 1.6.1 → 1.7.0-beta.1

package/dist/routes/graphql-yoga-ws.mjs

@@ -0,0 +1,298 @@
+import { parse, subscribe, validate } from "graphql";
+import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
+import { importedConfig } from "#nitro-internal-virtual/graphql-config";
+import { moduleConfig } from "#nitro-internal-virtual/module-config";
+import { directives } from "#nitro-internal-virtual/server-directives";
+import { resolvers } from "#nitro-internal-virtual/server-resolvers";
+import { schemas } from "#nitro-internal-virtual/server-schemas";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+import { defineWebSocketHandler } from "h3";
+
+//#region src/routes/graphql-yoga-ws.ts
+const isDev = process.env.NODE_ENV === "development";
+function devLog(message, ...args) {
+	if (isDev) console.log(message, ...args);
+}
+const DEFAULT_MAX_SUBSCRIPTIONS_PER_PEER = 20;
+const DEFAULT_PING_INTERVAL_MS = 15e3;
+const DEFAULT_PONG_TIMEOUT_MS = 5e3;
+function sendMessage(peer, message) {
+	peer.send(JSON.stringify(message));
+}
+function sendErrorMessage(peer, id, errors) {
+	sendMessage(peer, {
+		id,
+		type: "error",
+		payload: errors
+	});
+}
+function sendNextMessage(peer, id, payload) {
+	sendMessage(peer, {
+		id,
+		type: "next",
+		payload
+	});
+}
+function sendCompleteMessage(peer, id) {
+	sendMessage(peer, {
+		id,
+		type: "complete"
+	});
+}
+async function handleConnectionInit(peer, payload) {
+	if (payload) peer.context.connectionParams = payload;
+	const onConnect = importedConfig?.websocket?.onConnect;
+	if (onConnect) try {
+		const result = await onConnect({
+			connectionParams: payload || {},
+			headers: Object.fromEntries(peer.request.headers.entries()),
+			peerId: peer.id,
+			remoteAddress: peer.remoteAddress
+		});
+		if (result === false) {
+			sendMessage(peer, {
+				type: "connection_error",
+				payload: { message: "Connection rejected by server" }
+			});
+			peer.close();
+			return;
+		}
+		if (result && typeof result === "object") peer.context.connectionContext = result;
+	} catch (error) {
+		sendMessage(peer, {
+			type: "connection_error",
+			payload: { message: error instanceof Error ? error.message : "Connection validation failed" }
+		});
+		peer.close();
+		return;
+	}
+	sendMessage(peer, { type: "connection_ack" });
+	startKeepAlive(peer);
+}
+function handlePing(peer) {
+	sendMessage(peer, { type: "pong" });
+}
+function handlePong(peer) {
+	if (peer.context.pongTimeout) {
+		clearTimeout(peer.context.pongTimeout);
+		peer.context.pongTimeout = null;
+	}
+}
+function startKeepAlive(peer) {
+	stopKeepAlive(peer);
+	peer.context.pingInterval = setInterval(() => {
+		sendMessage(peer, { type: "ping" });
+		peer.context.pongTimeout = setTimeout(() => {
+			devLog("[GraphQL WS] Peer did not respond to ping, closing connection");
+			peer.close();
+		}, DEFAULT_PONG_TIMEOUT_MS);
+	}, DEFAULT_PING_INTERVAL_MS);
+}
+function stopKeepAlive(peer) {
+	if (peer.context.pingInterval) {
+		clearInterval(peer.context.pingInterval);
+		peer.context.pingInterval = null;
+	}
+	if (peer.context.pongTimeout) {
+		clearTimeout(peer.context.pongTimeout);
+		peer.context.pongTimeout = null;
+	}
+}
+async function handleSubscribe(peer, msg, schema) {
+	if (!msg.id || !msg.payload) {
+		sendErrorMessage(peer, msg.id, [{ message: "Invalid subscribe message" }]);
+		return;
+	}
+	const subscriptions = peer.context.subscriptions;
+	const connectionParams = peer.context.connectionParams;
+	const connectionContext = peer.context.connectionContext;
+	if (subscriptions.has(msg.id)) {
+		sendErrorMessage(peer, msg.id, [{ message: `Subscription with ID "${msg.id}" already exists` }]);
+		return;
+	}
+	if (subscriptions.size >= DEFAULT_MAX_SUBSCRIPTIONS_PER_PEER) {
+		sendErrorMessage(peer, msg.id, [{ message: `Maximum subscriptions limit (${DEFAULT_MAX_SUBSCRIPTIONS_PER_PEER}) reached` }]);
+		return;
+	}
+	try {
+		const { query, variables, operationName } = msg.payload;
+		const document = typeof query === "string" ? parse(query) : query;
+		const validationErrors = validate(schema, document);
+		if (validationErrors.length > 0) {
+			sendErrorMessage(peer, msg.id, validationErrors.map((err) => ({
+				message: err.message,
+				locations: err.locations,
+				path: err.path
+			})));
+			return;
+		}
+		const result = await subscribe({
+			schema,
+			document,
+			variableValues: variables,
+			operationName,
+			contextValue: {
+				connectionParams,
+				...connectionContext,
+				headers: Object.fromEntries(peer.request.headers.entries()),
+				authorization: peer.request.headers.get("authorization") || connectionParams?.authorization,
+				peerId: peer.id,
+				remoteAddress: peer.remoteAddress
+			}
+		});
+		if (Symbol.asyncIterator in result) {
+			const abortController = new AbortController();
+			const trackedSub = {
+				iterator: result,
+				abortController
+			};
+			subscriptions.set(msg.id, trackedSub);
+			const iterateSubscription = async () => {
+				const subscriptionId = msg.id;
+				const signal = abortController.signal;
+				try {
+					for await (const value of result) {
+						if (signal.aborted) break;
+						sendNextMessage(peer, subscriptionId, value);
+					}
+					if (!signal.aborted) sendCompleteMessage(peer, subscriptionId);
+				} catch (error) {
+					if (signal.aborted) return;
+					console.error("[GraphQL WS] Subscription error:", error);
+					sendErrorMessage(peer, subscriptionId, [{ message: error instanceof Error ? error.message : "Subscription error" }]);
+				} finally {
+					subscriptions.delete(subscriptionId);
+				}
+			};
+			iterateSubscription();
+		} else {
+			sendNextMessage(peer, msg.id, result);
+			sendCompleteMessage(peer, msg.id);
+		}
+	} catch (error) {
+		console.error("[GraphQL WS] Operation error:", error);
+		sendErrorMessage(peer, msg.id, [{ message: error instanceof Error ? error.message : "Operation failed" }]);
+	}
+}
+async function handleComplete(peer, msg) {
+	if (!msg.id) return;
+	const subscriptions = peer.context.subscriptions;
+	const tracked = subscriptions.get(msg.id);
+	if (tracked) {
+		tracked.abortController.abort();
+		if (typeof tracked.iterator.return === "function") try {
+			await tracked.iterator.return();
+		} catch {}
+		subscriptions.delete(msg.id);
+	}
+}
+async function cleanupSubscriptions(peer, sendComplete = false) {
+	const subscriptions = peer.context.subscriptions;
+	if (!subscriptions) return;
+	for (const [id, tracked] of subscriptions.entries()) {
+		if (sendComplete) try {
+			sendCompleteMessage(peer, id);
+		} catch {}
+		tracked.abortController.abort();
+		if (typeof tracked.iterator.return === "function") try {
+			await tracked.iterator.return();
+		} catch (error) {
+			console.error(`[GraphQL WS] Error cleaning up subscription ${id}:`, error);
+		}
+	}
+	subscriptions.clear();
+}
+let buildSubgraphSchema = null;
+async function loadFederationSupport() {
+	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
+	try {
+		buildSubgraphSchema = (await import("@apollo/subgraph")).buildSubgraphSchema;
+	} catch {
+		buildSubgraphSchema = false;
+	}
+	return buildSubgraphSchema;
+}
+async function createMergedSchema() {
+	const typeDefs = mergeTypeDefs([schemas.map((schema$1) => schema$1.def).join("\n\n")], {
+		throwOnConflict: true,
+		commentDescriptions: true,
+		sort: true
+	});
+	const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
+	const federationEnabled = moduleConfig.federation?.enabled;
+	let schema;
+	if (federationEnabled) {
+		const buildSubgraph = await loadFederationSupport();
+		if (buildSubgraph) schema = buildSubgraph({
+			typeDefs: typeof typeDefs === "string" ? parse(typeDefs) : typeDefs,
+			resolvers: mergedResolvers
+		});
+		else {
+			console.warn("[GraphQL WS] Federation enabled but @apollo/subgraph not available");
+			schema = makeExecutableSchema({
+				typeDefs,
+				resolvers: mergedResolvers
+			});
+		}
+	} else schema = makeExecutableSchema({
+		typeDefs,
+		resolvers: mergedResolvers
+	});
+	if (directives && directives.length > 0) {
+		for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
+	}
+	return schema;
+}
+let schemaPromise = null;
+async function getSchema() {
+	if (!schemaPromise) schemaPromise = createMergedSchema();
+	return schemaPromise;
+}
+var graphql_yoga_ws_default = defineWebSocketHandler({
+	async open(peer) {
+		devLog("[GraphQL WS] Client connected");
+		peer.context.subscriptions = /* @__PURE__ */ new Map();
+	},
+	async message(peer, message) {
+		try {
+			const data = message.text();
+			const msg = JSON.parse(data);
+			const currentSchema = await getSchema();
+			switch (msg.type) {
+				case "connection_init":
+					await handleConnectionInit(peer, msg.payload);
+					break;
+				case "ping":
+					handlePing(peer);
+					break;
+				case "pong":
+					handlePong(peer);
+					break;
+				case "subscribe":
+					await handleSubscribe(peer, msg, currentSchema);
+					break;
+				case "complete":
+					await handleComplete(peer, msg);
+					break;
+				default: devLog("[GraphQL WS] Unknown message type:", msg.type);
+			}
+		} catch (error) {
+			console.error("[GraphQL WS] Message handling error:", error);
+			sendMessage(peer, {
+				type: "error",
+				payload: [{ message: "Invalid message format" }]
+			});
+		}
+	},
+	async close(peer, details) {
+		devLog("[GraphQL WS] Client disconnected:", details);
+		stopKeepAlive(peer);
+		await cleanupSubscriptions(peer, true);
+	},
+	async error(_peer, error) {
+		console.error("[GraphQL WS] WebSocket error:", error);
+	}
+});
+
+//#endregion
+export { graphql_yoga_ws_default as default };

package/dist/routes/graphql-yoga.d.mts

@@ -1,6 +1,6 @@
-import * as h33 from "h3";
+import * as h37 from "h3";
 
 //#region src/routes/graphql-yoga.d.ts
-declare const _default: h33.EventHandler<h33.EventHandlerRequest, Promise<Response>>;
+declare const _default: h37.EventHandler<h37.EventHandlerRequest, Promise<Response>>;
 //#endregion
 export { _default as default };

package/dist/routes/health.d.mts

@@ -1,7 +1,7 @@
-import * as h35 from "h3";
+import * as h31 from "h3";
 
 //#region src/routes/health.d.ts
-declare const _default: h35.EventHandler<h35.EventHandlerRequest, Promise<{
+declare const _default: h31.EventHandler<h31.EventHandlerRequest, Promise<{
   status: string;
   message: string;
   timestamp: string;

package/dist/subscribe/index.d.mts

@@ -0,0 +1,146 @@
+//#region src/subscribe/index.d.ts
+/**
+ * GraphQL Subscription Client
+ * Framework-agnostic subscription client supporting WebSocket and SSE transports
+ *
+ * Uses native browser WebSocket API and EventSource for maximum compatibility.
+ *
+ * @example WebSocket (default)
+ * ```typescript
+ * import { createSubscriptionClient } from 'nitro-graphql/subscribe'
+ *
+ * const client = createSubscriptionClient({ wsEndpoint: '/api/graphql/ws' })
+ *
+ * // Simple subscription
+ * client.subscribe(
+ *   'subscription { countdown(from: 10) }',
+ *   {},
+ *   (data) => console.log(data),
+ *   (error) => console.error(error)
+ * )
+ *
+ * // Multiplexed session (multiple subscriptions, single connection)
+ * const session = client.createSession()
+ * session.subscribe(query1, vars1, onData1)
+ * session.subscribe(query2, vars2, onData2)
+ * ```
+ *
+ * @example SSE Transport (same API, different transport)
+ * ```typescript
+ * // Use SSE when WebSocket is blocked (corporate firewalls, etc.)
+ * client.subscribe(
+ *   'subscription { countdown(from: 10) }',
+ *   {},
+ *   (data) => console.log(data),
+ *   (error) => console.error(error),
+ *   { transport: 'sse' }
+ * )
+ * ```
+ *
+ * @example Auto Transport (WebSocket first, SSE fallback)
+ * ```typescript
+ * // Automatically fallback to SSE if WebSocket fails
+ * client.subscribe(
+ *   'subscription { countdown(from: 10) }',
+ *   {},
+ *   (data) => console.log(data),
+ *   (error) => console.error(error),
+ *   { transport: 'auto' }
+ * )
+ * ```
+ *
+ * @module nitro-graphql/subscribe
+ */
+type ConnectionState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'error';
+/** Transport type for subscriptions */
+type SubscriptionTransport = 'websocket' | 'sse' | 'auto';
+/** Transport options for subscribe calls */
+interface TransportOptions {
+  /** Transport type: 'websocket' (default), 'sse', or 'auto' (WS first, SSE fallback) */
+  transport?: SubscriptionTransport;
+  /** Shorthand for { transport: 'sse' } */
+  sse?: boolean;
+}
+interface SubscriptionOptions<TVariables = Record<string, unknown>> {
+  query: string;
+  variables?: TVariables;
+  onData?: (data: unknown) => void;
+  onError?: (error: Error) => void;
+  onConnected?: () => void;
+  onReconnected?: () => void;
+  onDisconnected?: () => void;
+  onRetrying?: (attempt: number, maxAttempts: number) => void;
+  onMaxRetriesReached?: () => void;
+  onStateChange?: (state: ConnectionState) => void;
+  maxRetries?: number;
+  connectionTimeoutMs?: number;
+  connectionParams?: Record<string, unknown>;
+}
+interface SubscriptionHandle {
+  unsubscribe: () => void;
+  readonly isConnected: boolean;
+  readonly state: ConnectionState;
+  readonly id: string;
+  /** The active transport type */
+  readonly transport: 'websocket' | 'sse';
+}
+type StateChangeCallback = (state: ConnectionState, subscriptionCount: number) => void;
+interface SubscriptionSession {
+  subscribe: <TData = unknown, TVariables = Record<string, unknown>>(query: string, variables?: TVariables, onData?: (data: TData) => void, onError?: (error: Error) => void) => SubscriptionHandle;
+  readonly state: ConnectionState;
+  readonly isConnected: boolean;
+  readonly subscriptionCount: number;
+  close: () => void;
+  onStateChange: (callback: StateChangeCallback) => () => void;
+}
+interface SubscriptionClientConfig {
+  /** WebSocket endpoint (default: '/api/graphql/ws') */
+  wsEndpoint?: string;
+  /** SSE endpoint for SSE transport (default: '/api/graphql') */
+  sseEndpoint?: string;
+  /** Connection parameters for WebSocket handshake */
+  connectionParams?: Record<string, unknown> | (() => Record<string, unknown> | Promise<Record<string, unknown>>);
+  /** Connection timeout in ms (default: 10000) */
+  connectionTimeoutMs?: number;
+  /** Maximum retry attempts (default: 5) */
+  maxRetries?: number;
+}
+interface SubscriptionClient {
+  subscribe: <TData = unknown, TVariables = Record<string, unknown>>(query: string, variables?: TVariables, onData?: (data: TData) => void, onError?: (error: Error) => void, transportOptions?: TransportOptions) => SubscriptionHandle;
+  subscribeAsync: <_TData = unknown, TVariables = Record<string, unknown>>(options: SubscriptionOptions<TVariables>, transportOptions?: TransportOptions) => Promise<SubscriptionHandle>;
+  createSession: () => SubscriptionSession;
+}
+declare function createSubscriptionClient(config?: SubscriptionClientConfig): SubscriptionClient;
+interface SseSubscriptionOptions<TVariables = Record<string, unknown>> {
+  query: string;
+  variables?: TVariables;
+  onData?: (data: unknown) => void;
+  onError?: (error: Error) => void;
+  onConnected?: () => void;
+  onReconnected?: () => void;
+  onDisconnected?: () => void;
+  onStateChange?: (state: ConnectionState) => void;
+}
+interface SseSubscriptionHandle {
+  close: () => void;
+}
+/**
+ * Create an SSE subscription using native EventSource (legacy API)
+ * Use this when WebSocket is blocked (corporate firewalls, etc.)
+ *
+ * @deprecated Use the unified client with { transport: 'sse' } instead
+ *
+ * @example
+ * ```typescript
+ * const handle = createSseSubscription('/api/graphql', {
+ *   query: 'subscription { countdown(from: 10) }',
+ *   onData: (data) => console.log(data),
+ * })
+ *
+ * // Later...
+ * handle.close()
+ * ```
+ */
+declare function createSseSubscription<TData = unknown, TVariables = Record<string, unknown>>(endpoint: string, options: SseSubscriptionOptions<TVariables>): SseSubscriptionHandle;
+//#endregion
+export { ConnectionState, SseSubscriptionHandle, SseSubscriptionOptions, StateChangeCallback, SubscriptionClient, SubscriptionClientConfig, SubscriptionHandle, SubscriptionOptions, SubscriptionSession, SubscriptionTransport, TransportOptions, createSseSubscription, createSubscriptionClient };