nitro-graphql 2.0.0-beta.11 → 2.0.0-beta.13

package/README.md

@@ -5,6 +5,7 @@
 # Nitro GraphQL
 
 [![npm version][npm-version-src]][npm-version-href]
+[![Beta Status][beta-src]][beta-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
 [![bundle][bundle-src]][bundle-href]
 [![License][license-src]][license-href]
@@ -18,6 +19,13 @@
 
 </div>
 
+> [!IMPORTANT]
+> **v2.0 Beta (Current - Main Branch)**
+> This is the **v2.0** beta branch with Nitro v3 and H3 v2 support. Includes Rolldown optimization, improved chunking, and enhanced Vite integration.
+>
+> **Looking for v1.x?**
+> For the stable v1 version (Nitro v2), see the [`v1` branch](https://github.com/productdevbook/nitro-graphql/tree/v1).
+
 ---
 
 ## 🎥 Watch & Learn
@@ -34,6 +42,14 @@
 - 🎮 **Developer-friendly** - Built-in Apollo Sandbox for testing
 - 🔧 **Zero config** - Sensible defaults, customize when needed
 
+### 🆕 What's New in v2.0 Beta
+
+- 🚀 **Nitro v3 & H3 v2** - Full compatibility with the latest Nitro and H3
+- ⚙️ **Rolldown Support** - Optimized for both Rolldown (Vite 7+) and Rollup
+- 📦 **Smart Chunking** - GraphQL code split into separate chunks (~98% size reduction)
+- 🔍 **Debug Dashboard** - Built-in diagnostics at `/_nitro/graphql/debug` (dev only)
+- 🎨 **Enhanced Vite Integration** - Better custom path support and virtual module resolution
+
 ## 🚀 Quick Start
 
 ### 1. Install
@@ -147,6 +163,7 @@ pnpm dev
 - **Endpoint**: `http://localhost:3000/api/graphql`
 - **Playground**: `http://localhost:3000/api/graphql` (browser)
 - **Health**: `http://localhost:3000/api/graphql/health`
+- **Debug Dashboard**: `http://localhost:3000/_nitro/graphql/debug` (dev mode only)
 
 ## 🎮 Examples
 
@@ -159,6 +176,13 @@ Try these working examples:
 | [**Nuxt Integration**](./playgrounds/nuxt/) | Full Nuxt app with client types | `pnpm playground:nuxt` |
 | [**Apollo Federation**](./playgrounds/federation/) | Federated GraphQL services | `pnpm playground:federation` |
 
+### 🧪 Test Projects
+
+Real-world test projects using nitro-graphql v2:
+
+- [**Vite + Nitro + Rolldown**](https://github.com/productdevbook/vite-nitro-graphql/tree/rolldown) - Testing with Rolldown bundler (Vite 7+)
+- [**Vite + Nitro (Main)**](https://github.com/productdevbook/vite-nitro-graphql) - Standard Vite integration tests
+
 ## 🏗️ Building Your First Feature
 
 Let's create a complete user management system:
@@ -1248,4 +1272,6 @@ pnpm lint
 [license-src]: https://img.shields.io/github/license/productdevbook/nitro-graphql.svg?style=flat&colorA=080f12&colorB=1fa669
 [license-href]: https://github.com/productdevbook/nitro-graphql/blob/main/LICENSE
 [docs-src]: https://img.shields.io/badge/docs-read-blue?style=flat&colorA=080f12&colorB=1fa669
-[docs-href]: https://nitro-graphql.pages.dev
+[docs-href]: https://nitro-graphql.pages.dev
+[beta-src]: https://img.shields.io/npm/v/nitro-graphql/beta?style=flat&logo=rocket&logoColor=white&label=beta&color=7c3aed&colorA=080f12
+[beta-href]: https://github.com/productdevbook/nitro-graphql/releases

package/dist/ecosystem/nuxt.js

@@ -1,5 +1,6 @@
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../utils/path-resolver.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join, resolve } from "pathe";
+import { dirname, join, relative, resolve } from "pathe";
 import { defineNuxtModule, getLayerDirectories } from "@nuxt/kit";
 
 //#region src/ecosystem/nuxt.ts
@@ -11,24 +12,65 @@ var nuxt_default = defineNuxtModule({
 	},
 	setup: async (_options, nuxt) => {
 		nuxt.hooks.hook("prepare:types", (options) => {
-			options.references.push({ path: "types/nitro-graphql-client.d.ts" });
-			options.tsConfig ??= {};
-			options.tsConfig.compilerOptions ??= {};
-			options.tsConfig.compilerOptions.paths ??= {};
-			options.tsConfig.compilerOptions.paths["#graphql/client"] = ["./types/nitro-graphql-client.d.ts"];
+			const mockNitro$1 = { options: {
+				rootDir: nuxt.options.rootDir,
+				buildDir: nuxt.options.buildDir,
+				framework: { name: "nuxt" },
+				graphql: nuxt.options.nitro?.graphql
+			} };
+			const placeholders$1 = getDefaultPaths(mockNitro$1);
+			const typesConfig$1 = getTypesConfig(mockNitro$1);
+			const tsconfigDir = dirname(join(nuxt.options.buildDir, "tsconfig.json"));
+			const relativeWithDot = (from, to) => {
+				const rel = relative(from, to);
+				return rel.startsWith(".") ? rel : `./${rel}`;
+			};
+			const clientTypesPath$1 = resolveFilePath(typesConfig$1.client, typesConfig$1.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders$1);
+			if (clientTypesPath$1) {
+				const relativePath = relativeWithDot(tsconfigDir, clientTypesPath$1);
+				options.references.push({ path: relativePath });
+				options.tsConfig ??= {};
+				options.tsConfig.compilerOptions ??= {};
+				options.tsConfig.compilerOptions.paths ??= {};
+				options.tsConfig.compilerOptions.paths["#graphql/client"] = [relativePath];
+				options.tsConfig.include = options.tsConfig.include || [];
+				options.tsConfig.include.push(relativePath);
+			}
 			const externalServices$1 = nuxt.options.nitro?.graphql?.externalServices || [];
 			for (const service of externalServices$1) {
-				options.references.push({ path: `types/nitro-graphql-client-${service.name}.d.ts` });
-				options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [`./types/nitro-graphql-client-${service.name}.d.ts`];
+				const servicePlaceholders = {
+					...placeholders$1,
+					serviceName: service.name
+				};
+				const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig$1.external, typesConfig$1.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+				if (externalTypesPath) {
+					const relativePath = relativeWithDot(tsconfigDir, externalTypesPath);
+					options.references.push({ path: relativePath });
+					options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativePath];
+					options.tsConfig.include.push(relativePath);
+				}
 			}
-			options.tsConfig.include = options.tsConfig.include || [];
-			options.tsConfig.include.push("./types/nitro-graphql-client.d.ts");
-			for (const service of externalServices$1) options.tsConfig.include.push(`./types/nitro-graphql-client-${service.name}.d.ts`);
 		});
 		nuxt.options.alias = nuxt.options.alias || {};
-		nuxt.options.alias["#graphql/client"] = join(nuxt.options.buildDir, "types/nitro-graphql-client.d.ts");
+		const mockNitro = { options: {
+			rootDir: nuxt.options.rootDir,
+			buildDir: nuxt.options.buildDir,
+			framework: { name: "nuxt" },
+			graphql: nuxt.options.nitro?.graphql
+		} };
+		const placeholders = getDefaultPaths(mockNitro);
+		const typesConfig = getTypesConfig(mockNitro);
+		const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+		if (clientTypesPath) nuxt.options.alias["#graphql/client"] = clientTypesPath;
 		const externalServices = nuxt.options.nitro?.graphql?.externalServices || [];
-		for (const service of externalServices) nuxt.options.alias[`#graphql/client/${service.name}`] = join(nuxt.options.buildDir, `types/nitro-graphql-client-${service.name}.d.ts`);
+		for (const service of externalServices) {
+			const servicePlaceholders = {
+				...placeholders,
+				serviceName: service.name
+			};
+			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+			if (externalTypesPath) nuxt.options.alias[`#graphql/client/${service.name}`] = externalTypesPath;
+		}
 		nuxt.hook("imports:dirs", (dirs) => {
 			const graphqlServerPath = nuxt.options.nitro?.graphql?.serverDir || resolve(nuxt.options.srcDir, "graphql");
 			dirs.push(graphqlServerPath);

package/dist/index.d.ts

@@ -3,6 +3,10 @@ import { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGr
 import * as nitro_types0 from "nitro/types";
 
 //#region src/index.d.ts
+/**
+ * Nitro GraphQL module
+ * Can be used via modules array in nitro.config.ts
+ */
 declare const _default: nitro_types0.NitroModule;
 //#endregion
 export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, StandardSchemaV1, TypesConfig, _default as default };

package/dist/index.js

@@ -1,323 +1,14 @@
-import { generateDirectiveSchemas } from "./utils/directive-parser.js";
-import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.js";
-import { writeFileIfNotExists } from "./utils/file-generator.js";
-import { getScaffoldConfig, resolveFilePath, shouldGenerateScaffold } from "./utils/path-resolver.js";
-import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
-import { rollupConfig } from "./rollup.js";
-import { existsSync, mkdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { watch } from "chokidar";
-import consola from "consola";
-import defu from "defu";
-import { dirname, join, relative, resolve } from "pathe";
+import { setupNitroGraphQL } from "./setup.js";
 
 //#region src/index.ts
+/**
+* Nitro GraphQL module
+* Can be used via modules array in nitro.config.ts
+*/
 var src_default = defineNitroModule({
 	name: "nitro-graphql",
 	async setup(nitro) {
-		if (!nitro.options.graphql?.framework) consola.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
-		if (nitro.options.graphql?.externalServices?.length) {
-			const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
-			if (validationErrors.length > 0) {
-				consola.error("External services configuration errors:");
-				for (const error of validationErrors) consola.error(`  - ${error}`);
-				throw new Error("Invalid external services configuration");
-			}
-			consola.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
-		}
-		const { getDefaultPaths: getDefaultPaths$1 } = await import("./utils/path-resolver.js");
-		const defaultPaths = getDefaultPaths$1(nitro);
-		nitro.graphql ||= {
-			buildDir: "",
-			watchDirs: [],
-			clientDir: defaultPaths.clientGraphql,
-			serverDir: defaultPaths.serverGraphql,
-			dir: {
-				build: relative(nitro.options.rootDir, nitro.options.buildDir),
-				client: "graphql",
-				server: "server"
-			}
-		};
-		nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
-			rollupConfig$1.external = rollupConfig$1.external || [];
-			const codegenExternals = ["oxc-parser", "@oxc-parser"];
-			if (Array.isArray(rollupConfig$1.external)) rollupConfig$1.external.push(...codegenExternals);
-			else if (typeof rollupConfig$1.external === "function") {
-				const originalExternal = rollupConfig$1.external;
-				rollupConfig$1.external = (id, parent, isResolved) => {
-					if (codegenExternals.some((external) => id.includes(external))) return true;
-					return originalExternal(id, parent, isResolved);
-				};
-			}
-		});
-		nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
-			endpoint: {
-				graphql: "/api/graphql",
-				healthCheck: "/api/graphql/health"
-			},
-			playground: true
-		});
-		if (nitro.options.graphql?.federation?.enabled) consola.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
-		const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
-		nitro.graphql.buildDir = graphqlBuildDir;
-		const watchDirs = [];
-		switch (nitro.options.framework.name) {
-			case "nuxt": {
-				nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
-				nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
-				watchDirs.push(nitro.graphql.clientDir);
-				const layerServerDirs = getLayerServerDirectories(nitro);
-				const layerAppDirs = getLayerAppDirectories(nitro);
-				for (const layerServerDir of layerServerDirs) watchDirs.push(join(layerServerDir, "graphql"));
-				for (const layerAppDir of layerAppDirs) watchDirs.push(join(layerAppDir, "graphql"));
-				break;
-			}
-			case "nitro":
-				nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
-				nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
-				watchDirs.push(nitro.graphql.clientDir);
-				watchDirs.push(nitro.graphql.serverDir);
-				break;
-			default:
-		}
-		if (nitro.options.graphql?.externalServices?.length) {
-			for (const service of nitro.options.graphql.externalServices) if (service.documents?.length) for (const pattern of service.documents) {
-				if (!pattern) continue;
-				const baseDir = pattern.split("**")[0]?.replace(/\/$/, "") || ".";
-				const resolvedDir = resolve(nitro.options.rootDir, baseDir);
-				if (!watchDirs.includes(resolvedDir)) watchDirs.push(resolvedDir);
-			}
-		}
-		const watcher = watch(watchDirs, {
-			persistent: true,
-			ignoreInitial: true,
-			ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns(nitro)]
-		}).on("all", async (_, path) => {
-			if (path.endsWith(".graphql") || path.endsWith(".gql")) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql")) {
-				await serverTypeGeneration(nitro);
-				await clientTypeGeneration(nitro);
-				await nitro.hooks.callHook("dev:reload");
-			} else await clientTypeGeneration(nitro);
-		});
-		nitro.hooks.hook("close", () => {
-			watcher.close();
-		});
-		const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
-		const typesDir = resolve(nitro.options.buildDir, "types");
-		nitro.scanSchemas = await scanSchemas(nitro);
-		nitro.scanDocuments = await scanDocs(nitro);
-		nitro.scanResolvers = await scanResolvers(nitro);
-		const directives = await scanDirectives(nitro);
-		nitro.scanDirectives = directives;
-		await generateDirectiveSchemas(nitro, directives);
-		nitro.hooks.hook("dev:start", async () => {
-			const schemas = await scanSchemas(nitro);
-			nitro.scanSchemas = schemas;
-			const resolvers = await scanResolvers(nitro);
-			nitro.scanResolvers = resolvers;
-			const directives$1 = await scanDirectives(nitro);
-			nitro.scanDirectives = directives$1;
-			await generateDirectiveSchemas(nitro, directives$1);
-			const docs = await scanDocs(nitro);
-			nitro.scanDocuments = docs;
-			if (nitro.options.dev) {
-				consola.box({
-					title: "Nitro GraphQL",
-					message: [
-						`Framework: ${nitro.options.graphql?.framework || "Not configured"}`,
-						`Schemas: ${schemas.length}`,
-						`Resolvers: ${resolvers.length}`,
-						`Directives: ${directives$1.length}`,
-						`Documents: ${docs.length}`,
-						"",
-						"Debug Dashboard: /_nitro/graphql/debug"
-					].join("\n"),
-					style: {
-						borderColor: "cyan",
-						borderStyle: "rounded"
-					}
-				});
-				if (resolvers.length > 0) {
-					const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
-					const typeCount = {
-						query: 0,
-						mutation: 0,
-						resolver: 0,
-						type: 0,
-						subscription: 0,
-						directive: 0
-					};
-					for (const resolver of resolvers) for (const imp of resolver.imports) if (imp.type in typeCount) typeCount[imp.type]++;
-					const breakdown = [];
-					if (typeCount.query > 0) breakdown.push(`${typeCount.query} query`);
-					if (typeCount.mutation > 0) breakdown.push(`${typeCount.mutation} mutation`);
-					if (typeCount.resolver > 0) breakdown.push(`${typeCount.resolver} resolver`);
-					if (typeCount.type > 0) breakdown.push(`${typeCount.type} type`);
-					if (typeCount.subscription > 0) breakdown.push(`${typeCount.subscription} subscription`);
-					if (typeCount.directive > 0) breakdown.push(`${typeCount.directive} directive`);
-					if (breakdown.length > 0) consola.success(`[nitro-graphql] ${totalExports} resolver export(s): ${breakdown.join(", ")}`);
-				} else consola.warn("[nitro-graphql] No resolvers found. Check /_nitro/graphql/debug for details.");
-			}
-		});
-		await rollupConfig(nitro);
-		await serverTypeGeneration(nitro);
-		await clientTypeGeneration(nitro);
-		nitro.hooks.hook("close", async () => {
-			await serverTypeGeneration(nitro);
-			await clientTypeGeneration(nitro);
-		});
-		const runtime = fileURLToPath(new URL("routes", import.meta.url));
-		const methods = [
-			"GET",
-			"POST",
-			"OPTIONS"
-		];
-		if (nitro.options.graphql?.framework === "graphql-yoga") for (const method of methods) nitro.options.handlers.push({
-			route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
-			handler: join(runtime, "graphql-yoga"),
-			method
-		});
-		if (nitro.options.graphql?.framework === "apollo-server") for (const method of methods) nitro.options.handlers.push({
-			route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
-			handler: join(runtime, "apollo-server"),
-			method
-		});
-		nitro.options.handlers.push({
-			route: nitro.options.runtimeConfig.graphql?.endpoint?.healthCheck || "/api/graphql/health",
-			handler: join(runtime, "health"),
-			method: "GET"
-		});
-		if (nitro.options.dev) {
-			nitro.options.handlers.push({
-				route: "/_nitro/graphql/debug",
-				handler: join(runtime, "debug"),
-				method: "GET"
-			});
-			consola.info("[nitro-graphql] Debug dashboard available at: /_nitro/graphql/debug");
-		}
-		if (nitro.options.imports) {
-			nitro.options.imports.presets ??= [];
-			nitro.options.imports.presets.push({
-				from: fileURLToPath(new URL("utils/define", import.meta.url)),
-				imports: [
-					"defineResolver",
-					"defineMutation",
-					"defineQuery",
-					"defineSubscription",
-					"defineType",
-					"defineGraphQLConfig",
-					"defineSchema",
-					"defineDirective"
-				]
-			});
-		}
-		nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
-			const manualChunks = rollupConfig$1.output?.manualChunks;
-			const chunkFiles = rollupConfig$1.output?.chunkFileNames;
-			if (!rollupConfig$1.output.inlineDynamicImports) {
-				rollupConfig$1.output.manualChunks = (id, meta) => {
-					if (id.endsWith(".graphql") || id.endsWith(".gql")) return "schemas";
-					if (id.endsWith(".resolver.ts")) return "resolvers";
-					if (typeof manualChunks === "function") return manualChunks(id, meta);
-				};
-				rollupConfig$1.output.advancedChunks = { groups: [{
-					name: "schemas",
-					test: /\.(?:graphql|gql)$/
-				}, {
-					name: "resolvers",
-					test: /\.resolver\.ts$/
-				}] };
-			}
-			rollupConfig$1.output.chunkFileNames = (chunkInfo) => {
-				if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => id.endsWith(".graphql") || id.endsWith(".resolver.ts") || id.endsWith(".gql"))) return `chunks/graphql/[name].mjs`;
-				if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
-				return `chunks/_/[name].mjs`;
-			};
-		});
-		nitro.options.typescript.strict = true;
-		nitro.hooks.hook("types:extend", (types) => {
-			types.tsConfig ||= {};
-			types.tsConfig.compilerOptions ??= {};
-			types.tsConfig.compilerOptions.paths ??= {};
-			types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-server.d.ts"))];
-			types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-client.d.ts"))];
-			types.tsConfig.compilerOptions.paths["#graphql/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
-			if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) types.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativeWithDot(tsconfigDir, join(typesDir, `nitro-graphql-client-${service.name}.d.ts`))];
-			types.tsConfig.include = types.tsConfig.include || [];
-			types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-server.d.ts")), relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-client.d.ts")), relativeWithDot(tsconfigDir, join(typesDir, "graphql.d.ts")));
-			if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(typesDir, `nitro-graphql-client-${service.name}.d.ts`)));
-		});
-		if (nitro.options.framework?.name === "nuxt" && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
-			const nuxtOptions = nitro._nuxt?.options;
-			if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
-		});
-		if (shouldGenerateScaffold(nitro)) {
-			const placeholders = getDefaultPaths$1(nitro);
-			const scaffoldConfig = getScaffoldConfig(nitro);
-			const graphqlConfigPath = resolveFilePath(scaffoldConfig.graphqlConfig, scaffoldConfig.enabled, true, "graphql.config.ts", placeholders);
-			if (graphqlConfigPath) writeFileIfNotExists(graphqlConfigPath, `
-import type { IGraphQLConfig } from 'graphql-config'
-
-export default <IGraphQLConfig> {
-    projects: {
-      default: {
-        schema: [
-          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"))}',
-        ],
-        documents: [
-          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"))}',
-        ],
-      },
-    },
-}`, "graphql.config.ts");
-			const serverSchemaPath = resolveFilePath(scaffoldConfig.serverSchema, scaffoldConfig.enabled, true, "{serverGraphql}/schema.ts", placeholders);
-			const serverConfigPath = resolveFilePath(scaffoldConfig.serverConfig, scaffoldConfig.enabled, true, "{serverGraphql}/config.ts", placeholders);
-			const serverContextPath = resolveFilePath(scaffoldConfig.serverContext, scaffoldConfig.enabled, true, "{serverGraphql}/context.ts", placeholders);
-			if (serverSchemaPath || serverConfigPath || serverContextPath) {
-				if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
-			}
-			if (serverSchemaPath) writeFileIfNotExists(serverSchemaPath, `export default defineSchema({
-
-})
-`, "server schema.ts");
-			if (serverConfigPath) writeFileIfNotExists(serverConfigPath, `// Example GraphQL config file please change it to your needs
-// import * as tables from '../drizzle/schema/index'
-// import { useDatabase } from '../utils/useDb'
-import { defineGraphQLConfig } from 'nitro-graphql/utils/define'
-
-export default defineGraphQLConfig({
-// graphql-yoga example config
-// context: () => {
-//   return {
-//     context: {
-//       useDatabase,
-//       tables,
-//     },
-//   }
-// },
-})
-`, "server config.ts");
-			if (serverContextPath) writeFileIfNotExists(serverContextPath, `// Example context definition - please change it to your needs
-// import type { Database } from '../utils/useDb'
-
-declare module 'h3' {
-  interface H3EventContext {
-    // Add your custom context properties here
-    // useDatabase: () => Database
-    // tables: typeof import('../drizzle/schema')
-    // auth?: {
-    //   user?: {
-    //     id: string
-    //     role: 'admin' | 'user'
-    //   }
-    // }
-  }
-}`, "server context.ts");
-			if (existsSync(join(nitro.graphql.serverDir, "context.d.ts"))) {
-				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");
-			}
-		} else consola.info("[nitro-graphql] Scaffold file generation is disabled (library mode)");
+		await setupNitroGraphQL(nitro);
 	}
 });
 

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

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

package/dist/routes/debug.d.ts

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

package/dist/routes/debug.js

@@ -2,7 +2,7 @@ import { moduleConfig } from "#nitro-graphql/module-config";
 import { directives } from "#nitro-graphql/server-directives";
 import { resolvers } from "#nitro-graphql/server-resolvers";
 import { schemas } from "#nitro-graphql/server-schemas";
-import { defineEventHandler, getQuery, setResponseHeader } from "h3";
+import { defineEventHandler, getQuery } from "h3";
 import { debugInfo } from "#nitro-graphql/debug-info";
 
 //#region src/routes/debug.ts
@@ -15,10 +15,6 @@ import { debugInfo } from "#nitro-graphql/debug-info";
 * - /_nitro/graphql/debug?format=json - JSON API
 */
 var debug_default = defineEventHandler(async (event) => {
-	if (!debugInfo.isDev) {
-		setResponseHeader(event, "Content-Type", "text/plain");
-		return "Debug endpoint is only available in development mode";
-	}
 	const format = getQuery(event).format || "html";
 	const processedResolverFiles = debugInfo.scanned.resolverFiles.map((r) => {
 		const parts = r.specifier.split("/");
@@ -94,10 +90,10 @@ var debug_default = defineEventHandler(async (event) => {
 		}
 	};
 	if (format === "json") {
-		setResponseHeader(event, "Content-Type", "application/json");
+		event.res.headers.set("Content-Type", "application/json");
 		return fullDebugInfo;
 	}
-	setResponseHeader(event, "Content-Type", "text/html");
+	event.res.headers.set("Content-Type", "text/html");
 	return generateHtmlDashboard(fullDebugInfo);
 });
 function generateHtmlDashboard(debugInfo$1) {

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

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

package/dist/routes/health.d.ts

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

package/dist/setup.js

@@ -0,0 +1,345 @@
+import { generateDirectiveSchemas } from "./utils/directive-parser.js";
+import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.js";
+import { writeFileIfNotExists } from "./utils/file-generator.js";
+import { getScaffoldConfig, getTypesConfig, resolveFilePath, shouldGenerateScaffold } from "./utils/path-resolver.js";
+import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
+import { rollupConfig } from "./rollup.js";
+import { existsSync, mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { watch } from "chokidar";
+import consola from "consola";
+import defu from "defu";
+import { dirname, join, relative, resolve } from "pathe";
+
+//#region src/setup.ts
+/**
+* Shared setup logic for nitro-graphql module
+* Used by both the direct Nitro module export and the Vite plugin's nitro: hook
+*/
+async function setupNitroGraphQL(nitro) {
+	if (!nitro.options.graphql?.framework) consola.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
+	if (nitro.options.graphql?.externalServices?.length) {
+		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
+		if (validationErrors.length > 0) {
+			consola.error("External services configuration errors:");
+			for (const error of validationErrors) consola.error(`  - ${error}`);
+			throw new Error("Invalid external services configuration");
+		}
+		consola.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+	}
+	const { getDefaultPaths } = await import("./utils/path-resolver.js");
+	const defaultPaths = getDefaultPaths(nitro);
+	nitro.graphql ||= {
+		buildDir: "",
+		watchDirs: [],
+		clientDir: defaultPaths.clientGraphql,
+		serverDir: defaultPaths.serverGraphql,
+		dir: {
+			build: relative(nitro.options.rootDir, nitro.options.buildDir),
+			client: "graphql",
+			server: "server"
+		}
+	};
+	nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
+		rollupConfig$1.external = rollupConfig$1.external || [];
+		const codegenExternals = ["oxc-parser", "@oxc-parser"];
+		if (Array.isArray(rollupConfig$1.external)) rollupConfig$1.external.push(...codegenExternals);
+		else if (typeof rollupConfig$1.external === "function") {
+			const originalExternal = rollupConfig$1.external;
+			rollupConfig$1.external = (id, parent, isResolved) => {
+				if (codegenExternals.some((external) => id.includes(external))) return true;
+				return originalExternal(id, parent, isResolved);
+			};
+		}
+	});
+	nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
+		endpoint: {
+			graphql: "/api/graphql",
+			healthCheck: "/api/graphql/health"
+		},
+		playground: true
+	});
+	if (nitro.options.graphql?.federation?.enabled) consola.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
+	const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
+	nitro.graphql.buildDir = graphqlBuildDir;
+	const watchDirs = [];
+	switch (nitro.options.framework.name) {
+		case "nuxt": {
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			watchDirs.push(nitro.graphql.clientDir);
+			const layerServerDirs = getLayerServerDirectories(nitro);
+			const layerAppDirs = getLayerAppDirectories(nitro);
+			for (const layerServerDir of layerServerDirs) watchDirs.push(join(layerServerDir, "graphql"));
+			for (const layerAppDir of layerAppDirs) watchDirs.push(join(layerAppDir, "graphql"));
+			break;
+		}
+		case "nitro":
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			watchDirs.push(nitro.graphql.clientDir);
+			watchDirs.push(nitro.graphql.serverDir);
+			break;
+		default:
+	}
+	if (nitro.options.graphql?.externalServices?.length) {
+		for (const service of nitro.options.graphql.externalServices) if (service.documents?.length) for (const pattern of service.documents) {
+			if (!pattern) continue;
+			const baseDir = pattern.split("**")[0]?.replace(/\/$/, "") || ".";
+			const resolvedDir = resolve(nitro.options.rootDir, baseDir);
+			if (!watchDirs.includes(resolvedDir)) watchDirs.push(resolvedDir);
+		}
+	}
+	const watcher = watch(watchDirs, {
+		persistent: true,
+		ignoreInitial: true,
+		ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns(nitro)]
+	}).on("all", async (_, path) => {
+		if (path.endsWith(".graphql") || path.endsWith(".gql")) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql")) {
+			await serverTypeGeneration(nitro);
+			await clientTypeGeneration(nitro);
+			await nitro.hooks.callHook("dev:reload");
+		} else await clientTypeGeneration(nitro);
+	});
+	nitro.hooks.hook("close", () => {
+		watcher.close();
+	});
+	const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
+	nitro.scanSchemas = await scanSchemas(nitro);
+	nitro.scanDocuments = await scanDocs(nitro);
+	nitro.scanResolvers = await scanResolvers(nitro);
+	const directives = await scanDirectives(nitro);
+	nitro.scanDirectives = directives;
+	await generateDirectiveSchemas(nitro, directives);
+	nitro.hooks.hook("dev:start", async () => {
+		const schemas = await scanSchemas(nitro);
+		nitro.scanSchemas = schemas;
+		const resolvers = await scanResolvers(nitro);
+		nitro.scanResolvers = resolvers;
+		const directives$1 = await scanDirectives(nitro);
+		nitro.scanDirectives = directives$1;
+		await generateDirectiveSchemas(nitro, directives$1);
+		const docs = await scanDocs(nitro);
+		nitro.scanDocuments = docs;
+		if (nitro.options.dev) {
+			consola.box({
+				title: "Nitro GraphQL",
+				message: [
+					`Framework: ${nitro.options.graphql?.framework || "Not configured"}`,
+					`Schemas: ${schemas.length}`,
+					`Resolvers: ${resolvers.length}`,
+					`Directives: ${directives$1.length}`,
+					`Documents: ${docs.length}`,
+					"",
+					"Debug Dashboard: /_nitro/graphql/debug"
+				].join("\n"),
+				style: {
+					borderColor: "cyan",
+					borderStyle: "rounded"
+				}
+			});
+			if (resolvers.length > 0) {
+				const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
+				const typeCount = {
+					query: 0,
+					mutation: 0,
+					resolver: 0,
+					type: 0,
+					subscription: 0,
+					directive: 0
+				};
+				for (const resolver of resolvers) for (const imp of resolver.imports) if (imp.type in typeCount) typeCount[imp.type]++;
+				const breakdown = [];
+				if (typeCount.query > 0) breakdown.push(`${typeCount.query} query`);
+				if (typeCount.mutation > 0) breakdown.push(`${typeCount.mutation} mutation`);
+				if (typeCount.resolver > 0) breakdown.push(`${typeCount.resolver} resolver`);
+				if (typeCount.type > 0) breakdown.push(`${typeCount.type} type`);
+				if (typeCount.subscription > 0) breakdown.push(`${typeCount.subscription} subscription`);
+				if (typeCount.directive > 0) breakdown.push(`${typeCount.directive} directive`);
+				if (breakdown.length > 0) consola.success(`[nitro-graphql] ${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+			} else consola.warn("[nitro-graphql] No resolvers found. Check /_nitro/graphql/debug for details.");
+		}
+	});
+	await rollupConfig(nitro);
+	await serverTypeGeneration(nitro);
+	await clientTypeGeneration(nitro);
+	nitro.hooks.hook("close", async () => {
+		await serverTypeGeneration(nitro);
+		await clientTypeGeneration(nitro);
+	});
+	const runtime = fileURLToPath(new URL("routes", import.meta.url));
+	const methods = [
+		"GET",
+		"POST",
+		"OPTIONS"
+	];
+	if (nitro.options.graphql?.framework === "graphql-yoga") for (const method of methods) nitro.options.handlers.push({
+		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+		handler: join(runtime, "graphql-yoga"),
+		method
+	});
+	if (nitro.options.graphql?.framework === "apollo-server") for (const method of methods) nitro.options.handlers.push({
+		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+		handler: join(runtime, "apollo-server"),
+		method
+	});
+	nitro.options.handlers.push({
+		route: nitro.options.runtimeConfig.graphql?.endpoint?.healthCheck || "/api/graphql/health",
+		handler: join(runtime, "health"),
+		method: "GET"
+	});
+	if (nitro.options.dev) {
+		nitro.options.handlers.push({
+			route: "/_nitro/graphql/debug",
+			handler: join(runtime, "debug"),
+			method: "GET"
+		});
+		consola.info("[nitro-graphql] Debug dashboard available at: /_nitro/graphql/debug");
+	}
+	if (nitro.options.imports) {
+		nitro.options.imports.presets ??= [];
+		nitro.options.imports.presets.push({
+			from: fileURLToPath(new URL("utils/define", import.meta.url)),
+			imports: [
+				"defineResolver",
+				"defineMutation",
+				"defineQuery",
+				"defineSubscription",
+				"defineType",
+				"defineGraphQLConfig",
+				"defineSchema",
+				"defineDirective"
+			]
+		});
+	}
+	nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
+		const manualChunks = rollupConfig$1.output?.manualChunks;
+		const chunkFiles = rollupConfig$1.output?.chunkFileNames;
+		if (!rollupConfig$1.output.inlineDynamicImports) {
+			rollupConfig$1.output.manualChunks = (id, meta) => {
+				if (id.endsWith(".graphql") || id.endsWith(".gql")) return "schemas";
+				if (id.endsWith(".resolver.ts")) return "resolvers";
+				if (typeof manualChunks === "function") return manualChunks(id, meta);
+			};
+			rollupConfig$1.output.advancedChunks = { groups: [{
+				name: "schemas",
+				test: /\.(?:graphql|gql)$/
+			}, {
+				name: "resolvers",
+				test: /\.resolver\.ts$/
+			}] };
+		}
+		rollupConfig$1.output.chunkFileNames = (chunkInfo) => {
+			if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => id.endsWith(".graphql") || id.endsWith(".resolver.ts") || id.endsWith(".gql"))) return `chunks/graphql/[name].mjs`;
+			if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
+			return `chunks/_/[name].mjs`;
+		};
+	});
+	nitro.options.typescript.strict = true;
+	nitro.hooks.hook("types:extend", (types) => {
+		types.tsConfig ||= {};
+		types.tsConfig.compilerOptions ??= {};
+		types.tsConfig.compilerOptions.paths ??= {};
+		const placeholders = getDefaultPaths(nitro);
+		const typesConfig = getTypesConfig(nitro);
+		const serverTypesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+		if (serverTypesPath) types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, serverTypesPath)];
+		const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+		if (clientTypesPath) types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, clientTypesPath)];
+		types.tsConfig.compilerOptions.paths["#graphql/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
+		if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) {
+			const servicePlaceholders = {
+				...placeholders,
+				serviceName: service.name
+			};
+			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+			if (externalTypesPath) types.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativeWithDot(tsconfigDir, externalTypesPath)];
+		}
+		types.tsConfig.include = types.tsConfig.include || [];
+		if (serverTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, serverTypesPath));
+		if (clientTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, clientTypesPath));
+		types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(placeholders.typesDir, "graphql.d.ts")));
+		if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) {
+			const servicePlaceholders = {
+				...placeholders,
+				serviceName: service.name
+			};
+			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+			if (externalTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, externalTypesPath));
+		}
+	});
+	if (nitro.options.framework?.name === "nuxt" && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
+		const nuxtOptions = nitro._nuxt?.options;
+		if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
+	});
+	if (shouldGenerateScaffold(nitro)) {
+		const placeholders = getDefaultPaths(nitro);
+		const scaffoldConfig = getScaffoldConfig(nitro);
+		const graphqlConfigPath = resolveFilePath(scaffoldConfig.graphqlConfig, scaffoldConfig.enabled, true, "graphql.config.ts", placeholders);
+		if (graphqlConfigPath) writeFileIfNotExists(graphqlConfigPath, `
+import type { IGraphQLConfig } from 'graphql-config'
+
+export default <IGraphQLConfig> {
+    projects: {
+      default: {
+        schema: [
+          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"))}',
+        ],
+        documents: [
+          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"))}',
+        ],
+      },
+    },
+}`, "graphql.config.ts");
+		const serverSchemaPath = resolveFilePath(scaffoldConfig.serverSchema, scaffoldConfig.enabled, true, "{serverGraphql}/schema.ts", placeholders);
+		const serverConfigPath = resolveFilePath(scaffoldConfig.serverConfig, scaffoldConfig.enabled, true, "{serverGraphql}/config.ts", placeholders);
+		const serverContextPath = resolveFilePath(scaffoldConfig.serverContext, scaffoldConfig.enabled, true, "{serverGraphql}/context.ts", placeholders);
+		if (serverSchemaPath || serverConfigPath || serverContextPath) {
+			if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
+		}
+		if (serverSchemaPath) writeFileIfNotExists(serverSchemaPath, `export default defineSchema({
+
+})
+`, "server schema.ts");
+		if (serverConfigPath) writeFileIfNotExists(serverConfigPath, `// Example GraphQL config file please change it to your needs
+// import * as tables from '../drizzle/schema/index'
+// import { useDatabase } from '../utils/useDb'
+import { defineGraphQLConfig } from 'nitro-graphql/utils/define'
+
+export default defineGraphQLConfig({
+// graphql-yoga example config
+// context: () => {
+//   return {
+//     context: {
+//       useDatabase,
+//       tables,
+//     },
+//   }
+// },
+})
+`, "server config.ts");
+		if (serverContextPath) writeFileIfNotExists(serverContextPath, `// Example context definition - please change it to your needs
+// import type { Database } from '../utils/useDb'
+
+declare module 'h3' {
+  interface H3EventContext {
+    // Add your custom context properties here
+    // useDatabase: () => Database
+    // tables: typeof import('../drizzle/schema')
+    // auth?: {
+    //   user?: {
+    //     id: string
+    //     role: 'admin' | 'user'
+    //   }
+    // }
+  }
+}`, "server context.ts");
+		if (existsSync(join(nitro.graphql.serverDir, "context.d.ts"))) {
+			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");
+		}
+	} else consola.info("[nitro-graphql] Scaffold file generation is disabled (library mode)");
+}
+
+//#endregion
+export { setupNitroGraphQL };

package/dist/utils/client-codegen.d.ts

@@ -23,14 +23,14 @@ declare function loadExternalSchema(service: ExternalGraphQLService, buildDir?:
  */
 declare function downloadAndSaveSchema(service: ExternalGraphQLService, buildDir: string): Promise<string | undefined>;
 declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
-declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string): Promise<false | {
+declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string, virtualTypesPath?: string): Promise<false | {
   types: string;
   sdk: string;
 }>;
 /**
  * Generate client types for external GraphQL service
  */
-declare function generateExternalClientTypes(service: ExternalGraphQLService, schema: GraphQLSchema, docs: Source[]): Promise<{
+declare function generateExternalClientTypes(service: ExternalGraphQLService, schema: GraphQLSchema, docs: Source[], virtualTypesPath?: string): Promise<{
   types: string;
   sdk: string;
 } | false>;

package/dist/utils/client-codegen.js

@@ -165,7 +165,7 @@ async function loadGraphQLDocuments(patterns) {
 		else throw e;
 	}
 }
-async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName) {
+async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath) {
 	if (docs.length === 0 && !serviceName) {
 		consola$1.info("No client GraphQL files found. Skipping client type generation.");
 		return false;
@@ -252,7 +252,7 @@ export function getSdk(requester: Requester): Sdk {
 				typescriptOperations: { plugin: plugin$2 }
 			}
 		});
-		const typesPath = serviceName ? `#graphql/client/${serviceName}` : "#graphql/client";
+		const typesPath = virtualTypesPath || (serviceName ? `#graphql/client/${serviceName}` : "#graphql/client");
 		const sdkOutput = await preset.buildGeneratesSection({
 			baseOutputDir: outputPath || "client-types.generated.ts",
 			schema: parse(printSchemaWithDirectives(schema)),
@@ -282,8 +282,8 @@ export function getSdk(requester: Requester): Sdk {
 /**
 * Generate client types for external GraphQL service
 */
-async function generateExternalClientTypes(service, schema, docs) {
-	return generateClientTypes(schema, docs, service.codegen?.client || {}, service.codegen?.clientSDK || {}, void 0, service.name);
+async function generateExternalClientTypes(service, schema, docs, virtualTypesPath) {
+	return generateClientTypes(schema, docs, service.codegen?.client || {}, service.codegen?.clientSDK || {}, void 0, service.name, virtualTypesPath);
 }
 
 //#endregion

package/dist/utils/path-resolver.js

@@ -1,4 +1,4 @@
-import { resolve } from "pathe";
+import { isAbsolute, resolve } from "pathe";
 
 //#region src/utils/path-resolver.ts
 /**
@@ -49,7 +49,7 @@ function resolveFilePath(config, categoryEnabled, topLevelEnabled, defaultPath,
 	if (!shouldGenerateFile(config, categoryEnabled, topLevelEnabled)) return null;
 	if (typeof config === "string") {
 		const customPath = replacePlaceholders(config, placeholders);
-		return resolve(placeholders.rootDir, customPath);
+		return isAbsolute(customPath) ? customPath : resolve(placeholders.rootDir, customPath);
 	}
 	const resolvedDefault = replacePlaceholders(defaultPath, placeholders);
 	return resolve(placeholders.rootDir, resolvedDefault);

package/dist/vite.d.ts

@@ -1,10 +1,12 @@
+import { NitroGraphQLOptions } from "./types/index.js";
 import { Plugin } from "vite";
 
 //#region src/vite.d.ts
 
 /**
- * Vite plugin to load GraphQL files as strings
+ * Vite plugin to load GraphQL files as strings AND auto-register Nitro module
  * This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+ * and automatically sets up the nitro-graphql module via the nitro: hook
  *
  * @example
  * ```ts
@@ -14,12 +16,12 @@ import { Plugin } from "vite";
  *
  * export default defineConfig({
  *   plugins: [
- *     graphql(), // Must be before nitro()
+ *     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
  *     nitro()
  *   ]
  * })
  * ```
  */
-declare function graphql(): Plugin;
+declare function graphql(options?: NitroGraphQLOptions): Plugin;
 //#endregion
 export { graphql };

package/dist/vite.js

@@ -1,9 +1,12 @@
+import { setupNitroGraphQL } from "./setup.js";
+import defu from "defu";
 import { readFile } from "node:fs/promises";
 
 //#region src/vite.ts
 /**
-* Vite plugin to load GraphQL files as strings
+* Vite plugin to load GraphQL files as strings AND auto-register Nitro module
 * This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+* and automatically sets up the nitro-graphql module via the nitro: hook
 *
 * @example
 * ```ts
@@ -13,13 +16,13 @@ import { readFile } from "node:fs/promises";
 *
 * export default defineConfig({
 *   plugins: [
-*     graphql(), // Must be before nitro()
+*     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
 *     nitro()
 *   ]
 * })
 * ```
 */
-function graphql() {
+function graphql(options) {
 	return {
 		name: "nitro-graphql:vite",
 		enforce: "pre",
@@ -32,7 +35,11 @@ function graphql() {
 				if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
 				throw error;
 			}
-		}
+		},
+		nitro: { async setup(nitro) {
+			if (options) nitro.options.graphql = defu(nitro.options.graphql || {}, options);
+			await setupNitroGraphQL(nitro);
+		} }
 	};
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "2.0.0-beta.11",
+  "version": "2.0.0-beta.13",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,