nitro-graphql 1.6.1 → 1.7.0-beta.0

package/dist/ecosystem/nuxt.mjs

@@ -46,7 +46,10 @@ var nuxt_default = defineNuxtModule({
 				if (externalTypesPath) {
 					const relativePath = relativeWithDot(tsconfigDir, externalTypesPath);
 					options.references.push({ path: relativePath });
+					options.tsConfig.compilerOptions ??= {};
+					options.tsConfig.compilerOptions.paths ??= {};
 					options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativePath];
+					options.tsConfig.include ??= [];
 					options.tsConfig.include.push(relativePath);
 				}
 			}

package/dist/index.d.mts

@@ -1,8 +1,8 @@
 import { StandardSchemaV1 } from "./types/standard-schema.mjs";
-import { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, TypesConfig } from "./types/index.mjs";
+import { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, SubscriptionsConfig, TypesConfig } from "./types/index.mjs";
 import * as nitropack0 from "nitropack";
 
 //#region src/index.d.ts
 declare const _default: nitropack0.NitroModule;
 //#endregion
-export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, StandardSchemaV1, TypesConfig, _default as default };
+export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, StandardSchemaV1, SubscriptionsConfig, TypesConfig, _default as default };

package/dist/index.mjs

@@ -4,6 +4,7 @@ import { writeFileIfNotExists } from "./utils/file-generator.mjs";
 import { getDefaultPaths, getScaffoldConfig, getTypesConfig, resolveFilePath, shouldGenerateScaffold } from "./utils/path-resolver.mjs";
 import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.mjs";
 import { rollupConfig } from "./rollup.mjs";
+import { subscribeClientTemplate } from "./templates/subscribe-client.mjs";
 import { existsSync, mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { watch } from "chokidar";
@@ -52,7 +53,8 @@ var src_default = defineNitroModule({
 		nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
 			endpoint: {
 				graphql: "/api/graphql",
-				healthCheck: "/api/graphql/health"
+				healthCheck: "/api/graphql/health",
+				ws: "/api/graphql/ws"
 			},
 			playground: true
 		});
@@ -182,6 +184,20 @@ var src_default = defineNitroModule({
 			handler: join(runtime, "health"),
 			method: "get"
 		});
+		if (nitro.options.graphql?.subscriptions?.enabled) {
+			nitro.options.experimental ||= {};
+			nitro.options.experimental.websocket = true;
+			const wsEndpoint = nitro.options.runtimeConfig.graphql?.endpoint?.ws || nitro.options.graphql?.subscriptions?.endpoint || "/api/graphql/ws";
+			if (nitro.options.graphql?.framework === "graphql-yoga") nitro.options.handlers.push({
+				route: wsEndpoint,
+				handler: join(runtime, "graphql-yoga-ws")
+			});
+			if (nitro.options.graphql?.framework === "apollo-server") nitro.options.handlers.push({
+				route: wsEndpoint,
+				handler: join(runtime, "apollo-server-ws")
+			});
+			consola.info(`[nitro-graphql] WebSocket subscriptions enabled at: ${wsEndpoint}`);
+		}
 		if (nitro.options.dev) {
 			nitro.options.handlers.push({
 				route: "/_nitro/graphql/debug",
@@ -323,6 +339,12 @@ declare module 'h3' {
 				consola.warn("nitro-graphql: Found context.d.ts file. Please rename it to context.ts for the new structure.");
 				consola.info("The context file should now be context.ts instead of context.d.ts");
 			}
+			if (nitro.options.graphql?.subscriptions?.enabled) {
+				if (!existsSync(nitro.graphql.clientDir)) mkdirSync(nitro.graphql.clientDir, { recursive: true });
+				const defaultDir = resolve(nitro.graphql.clientDir, "default");
+				if (!existsSync(defaultDir)) mkdirSync(defaultDir, { recursive: true });
+				writeFileIfNotExists(resolve(defaultDir, "subscribe.ts"), subscribeClientTemplate, "subscribe.ts");
+			}
 		} else consola.info("[nitro-graphql] Scaffold file generation is disabled (library mode)");
 	}
 });

package/dist/rollup.mjs

@@ -15,7 +15,7 @@ async function rollupConfig(app) {
 	virtualDebugInfo(app);
 	app.hooks.hook("rollup:before", (nitro, rollupConfig$1) => {
 		rollupConfig$1.plugins = rollupConfig$1.plugins || [];
-		const { include = /\.(graphql|gql)$/i, exclude, validate = false } = app.options.graphql?.loader || {};
+		const { include = /\.(graphql|gql)$/i, exclude, validate: validate$1 = false } = app.options.graphql?.loader || {};
 		if (Array.isArray(rollupConfig$1.plugins)) {
 			rollupConfig$1.plugins.push({
 				name: "nitro-graphql",
@@ -24,7 +24,7 @@ async function rollupConfig(app) {
 					if (!include.test(id)) return null;
 					try {
 						const content = await readFile(id, "utf-8");
-						if (validate) parse(content);
+						if (validate$1) parse(content);
 						return `export default ${JSON.stringify(content)}`;
 					} catch (error) {
 						if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;

package/dist/routes/apollo-server-ws.d.mts

@@ -0,0 +1,6 @@
+import * as h30 from "h3";
+
+//#region src/routes/apollo-server-ws.d.ts
+declare const _default: h30.EventHandler<h30.EventHandlerRequest, never>;
+//#endregion
+export { _default as default };

package/dist/routes/apollo-server-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/apollo-server-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("[Apollo 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("[Apollo 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("[Apollo 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(`[Apollo 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("[Apollo 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 apollo_server_ws_default = defineWebSocketHandler({
+	async open(peer) {
+		devLog("[Apollo 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("[Apollo WS] Unknown message type:", msg.type);
+			}
+		} catch (error) {
+			console.error("[Apollo WS] Message handling error:", error);
+			sendMessage(peer, {
+				type: "error",
+				payload: [{ message: "Invalid message format" }]
+			});
+		}
+	},
+	async close(peer, details) {
+		devLog("[Apollo WS] Client disconnected:", details);
+		stopKeepAlive(peer);
+		await cleanupSubscriptions(peer, true);
+	},
+	async error(_peer, error) {
+		console.error("[Apollo WS] WebSocket error:", error);
+	}
+});
+
+//#endregion
+export { apollo_server_ws_default as default };

package/dist/routes/apollo-server.d.mts

@@ -1,6 +1,6 @@
-import * as h30 from "h3";
+import * as h31 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h30.EventHandler<h30.EventHandlerRequest, Promise<any>>;
+declare const _default: h31.EventHandler<h31.EventHandlerRequest, Promise<any>>;
 //#endregion
 export { _default as default };

package/dist/routes/apollo-server.mjs

@@ -7,10 +7,10 @@ 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 { ApolloServer } from "@apollo/server";
-import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
 import { makeExecutableSchema } from "@graphql-tools/schema";
 import { defineEventHandler } from "h3";
+import { ApolloServer } from "@apollo/server";
+import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
 import { startServerAndCreateH3Handler } from "nitro-graphql/utils/apollo";
 
 //#region src/routes/apollo-server.ts

package/dist/routes/debug.d.mts

@@ -1,4 +1,4 @@
-import * as h31 from "h3";
+import * as h33 from "h3";
 
 //#region src/routes/debug.d.ts
 
@@ -10,7 +10,7 @@ import * as h31 from "h3";
  * - /_nitro/graphql/debug - HTML dashboard
  * - /_nitro/graphql/debug?format=json - JSON API
  */
-declare const _default: h31.EventHandler<h31.EventHandlerRequest, Promise<string | {
+declare const _default: h33.EventHandler<h33.EventHandlerRequest, Promise<string | {
   timestamp: string;
   environment: {
     dev: any;

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

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