nitro-graphql 2.0.0-beta.31 → 2.0.0-beta.32

package/dist/constants.mjs

@@ -0,0 +1,91 @@
+//#region src/constants.ts
+/**
+* Constants and magic strings used throughout nitro-graphql
+* Centralizing these values prevents typos and makes refactoring easier
+*/
+/**
+* GraphQL schema file extensions
+*/
+const GRAPHQL_EXTENSIONS = [".graphql", ".gql"];
+/**
+* Resolver file extensions
+*/
+const RESOLVER_EXTENSIONS = [".resolver.ts", ".resolver.js"];
+/**
+* Directive file extensions
+*/
+const DIRECTIVE_EXTENSIONS = [".directive.ts", ".directive.js"];
+/**
+* Framework names
+*/
+const FRAMEWORK_NUXT = "nuxt";
+const FRAMEWORK_NITRO = "nitro";
+/**
+* Default directory names for GraphQL files
+*/
+const DIR_SERVER_GRAPHQL = "server/graphql";
+/**
+* Windows-compatible server GraphQL directory
+*/
+const DIR_SERVER_GRAPHQL_WIN = "server\\graphql";
+/**
+* Default GraphQL endpoint paths
+*/
+const ENDPOINT_GRAPHQL = "/api/graphql";
+const ENDPOINT_HEALTH = "/api/graphql/health";
+const ENDPOINT_DEBUG = "/_nitro/graphql/debug";
+/**
+* Configuration and scaffold file names
+*/
+const FILE_GRAPHQL_CONFIG = "graphql.config.ts";
+const FILE_SCHEMA_TS = "schema.ts";
+const FILE_CONFIG_TS = "config.ts";
+const FILE_CONTEXT_DTS = "context.d.ts";
+const FILE_CONTEXT_TS = "context.ts";
+const FILE_INDEX_TS = "index.ts";
+/**
+* Rollup/Rolldown chunk output paths
+*/
+const CHUNK_PATH_GRAPHQL = "chunks/graphql/[name].mjs";
+const CHUNK_PATH_UNKNOWN = "chunks/_/[name].mjs";
+/**
+* Default chunk names
+*/
+const CHUNK_NAME_SCHEMAS = "schemas";
+const CHUNK_NAME_RESOLVERS = "resolvers";
+/**
+* Built-in GraphQL scalar types (should not be flagged as duplicates)
+*/
+const BUILTIN_SCALARS = [
+	"String",
+	"Int",
+	"Float",
+	"Boolean",
+	"ID",
+	"DateTime",
+	"JSON"
+];
+/**
+* Supported HTTP methods for GraphQL endpoints
+*/
+const GRAPHQL_HTTP_METHODS = [
+	"GET",
+	"POST",
+	"OPTIONS"
+];
+/**
+* Default paths for type generation (relative to buildDir)
+*/
+const DEFAULT_SERVER_TYPES_PATH = ".graphql/nitro-graphql-server.d.ts";
+const DEFAULT_CLIENT_TYPES_PATH = ".graphql/nitro-graphql-client.d.ts";
+/**
+* Logger tag for nitro-graphql module
+*/
+const LOG_TAG = "nitro-graphql";
+/**
+* Default service directory name for main service
+*/
+const SERVICE_DEFAULT = "default";
+
+//#endregion
+export { BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_SERVER_TYPES_PATH, DIRECTIVE_EXTENSIONS, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_GRAPHQL_CONFIG, FILE_INDEX_TS, FILE_SCHEMA_TS, FRAMEWORK_NITRO, FRAMEWORK_NUXT, GRAPHQL_EXTENSIONS, GRAPHQL_HTTP_METHODS, LOG_TAG, RESOLVER_EXTENSIONS, SERVICE_DEFAULT };

package/dist/ecosystem/nuxt.mjs

@@ -1,6 +1,6 @@
 import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../utils/path-resolver.mjs";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { defineNuxtModule, getLayerDirectories } from "@nuxt/kit";
 
 //#region src/ecosystem/nuxt.ts
@@ -46,8 +46,8 @@ var nuxt_default = defineNuxtModule({
 				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);
+					if (options.tsConfig.compilerOptions) options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativePath];
+					if (options.tsConfig.include) options.tsConfig.include.push(relativePath);
 				}
 			}
 		});

package/dist/rollup.d.mts

@@ -1,12 +1,12 @@
 import { Nitro } from "nitro/types";
 
 //#region src/rollup.d.ts
-declare function rollupConfig(app: Nitro): Promise<void>;
-declare function virtualSchemas(app: Nitro): void;
-declare function virtualResolvers(app: Nitro): void;
-declare function virtualDirectives(app: Nitro): void;
-declare function getGraphQLConfig(app: Nitro): void;
-declare function virtualModuleConfig(app: Nitro): void;
-declare function virtualDebugInfo(app: Nitro): void;
+declare function rollupConfig(nitro: Nitro): Promise<void>;
+declare function virtualSchemas(nitro: Nitro): void;
+declare function virtualResolvers(nitro: Nitro): void;
+declare function virtualDirectives(nitro: Nitro): void;
+declare function getGraphQLConfig(nitro: Nitro): void;
+declare function virtualModuleConfig(nitro: Nitro): void;
+declare function virtualDebugInfo(nitro: Nitro): void;
 //#endregion
 export { getGraphQLConfig, rollupConfig, virtualDebugInfo, virtualDirectives, virtualModuleConfig, virtualResolvers, virtualSchemas };

package/dist/rollup.mjs

@@ -1,5 +1,5 @@
 import { getImportId, scanGraphql } from "./utils/index.mjs";
-import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.mjs";
+import { clientTypeGeneration, serverTypeGeneration } from "./codegen/index.mjs";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { resolve } from "pathe";
@@ -7,23 +7,23 @@ import { parse } from "graphql";
 import { genImport } from "knitwork";
 
 //#region src/rollup.ts
-async function rollupConfig(app) {
-	virtualSchemas(app);
-	virtualResolvers(app);
-	virtualDirectives(app);
-	getGraphQLConfig(app);
-	virtualModuleConfig(app);
-	virtualDebugInfo(app);
-	app.hooks.hook("rollup:before", (nitro, rollupConfig$1) => {
+async function rollupConfig(nitro) {
+	virtualSchemas(nitro);
+	virtualResolvers(nitro);
+	virtualDirectives(nitro);
+	getGraphQLConfig(nitro);
+	virtualModuleConfig(nitro);
+	virtualDebugInfo(nitro);
+	nitro.hooks.hook("rollup:before", (_, 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 = false } = nitro.options.graphql?.loader || {};
 		if (Array.isArray(rollupConfig$1.plugins)) {
 			rollupConfig$1.plugins.push({
 				name: "nitro-graphql:virtual",
 				resolveId: {
 					order: "pre",
 					filter: { id: /^#nitro-graphql\// },
-					async handler(id, parent, options) {
+					async handler(id, parent, _options) {
 						if (id.startsWith("#nitro-graphql/")) return `\0virtual:${id}`;
 						if (parent?.startsWith("\0virtual:#nitro-graphql")) {
 							const runtimeDir = fileURLToPath(new URL("routes", import.meta.url));
@@ -41,7 +41,7 @@ async function rollupConfig(app) {
 					async handler(id) {
 						if (id.startsWith("\0virtual:#nitro-graphql/")) {
 							const moduleName = id.slice(9);
-							const generator = app.options.virtual?.[moduleName];
+							const generator = nitro.options.virtual?.[moduleName];
 							if (typeof generator === "function") try {
 								return {
 									code: await generator(),
@@ -81,7 +81,7 @@ async function rollupConfig(app) {
 					}
 				}
 			});
-			if (app.options.dev) rollupConfig$1.plugins.push({
+			if (nitro.options.dev) rollupConfig$1.plugins.push({
 				name: "nitro-graphql-watcher",
 				buildStart: {
 					order: "pre",
@@ -93,19 +93,19 @@ async function rollupConfig(app) {
 			});
 		}
 	});
-	app.hooks.hook("dev:reload", async () => {
-		await serverTypeGeneration(app, { silent: true });
-		await clientTypeGeneration(app, { silent: true });
+	nitro.hooks.hook("dev:reload", async () => {
+		await serverTypeGeneration(nitro, { silent: true });
+		await clientTypeGeneration(nitro, { silent: true });
 	});
 }
-function virtualSchemas(app) {
-	const getSchemas = () => [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/server-schemas"] = () => {
+function virtualSchemas(nitro) {
+	const getSchemas = () => [...nitro.scanSchemas, ...nitro.options.graphql?.typedefs ?? []];
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/server-schemas"] = () => {
 		try {
 			const imports = getSchemas();
 			if (imports.length === 0) {
-				if (app.options.dev) app.logger.warn("[nitro-graphql] No schemas found. Virtual module will export empty array.");
+				if (nitro.options.dev) nitro.logger.warn("[nitro-graphql] No schemas found. Virtual module will export empty array.");
 				return "export const schemas = []";
 			}
 			const importStatements = imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`);
@@ -118,38 +118,38 @@ ${schemaArray.join(",\n")}
 ];
     `;
 		} catch (error) {
-			app.logger.error("[nitro-graphql] Failed to generate virtual schema module:", error);
+			nitro.logger.error("[nitro-graphql] Failed to generate virtual schema module:", error);
 			return "export const schemas = []";
 		}
 	};
 }
-function virtualResolvers(app) {
-	const getResolvers = () => [...app.scanResolvers];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/server-resolvers"] = () => {
+function virtualResolvers(nitro) {
+	const getResolvers = () => [...nitro.scanResolvers];
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/server-resolvers"] = () => {
 		try {
 			const imports = getResolvers();
 			if (imports.length === 0) {
-				if (app.options.dev) app.logger.warn("[nitro-graphql] No resolvers found. Virtual module will export empty array.");
+				if (nitro.options.dev) nitro.logger.warn("[nitro-graphql] No resolvers found. Virtual module will export empty array.");
 				return "export const resolvers = []";
 			}
 			const importsContent = [];
 			const invalidImports = [];
-			for (const { specifier, imports: importList, options } of imports) try {
+			for (const { specifier, imports: importList, options: options$1 } of imports) try {
 				if (!importList || importList.length === 0) {
 					invalidImports.push(`${specifier}: No exports found`);
 					continue;
 				}
-				const importCode = genImport(specifier, importList, options);
+				const importCode = genImport(specifier, importList, options$1);
 				importsContent.push(importCode);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				invalidImports.push(`${specifier}: ${message}`);
-				if (app.options.dev) app.logger.error(`[nitro-graphql] Failed to generate import for ${specifier}:`, error);
+				if (nitro.options.dev) nitro.logger.error(`[nitro-graphql] Failed to generate import for ${specifier}:`, error);
 			}
-			if (invalidImports.length > 0 && app.options.dev) {
-				app.logger.warn("[nitro-graphql] Some resolver imports could not be generated:");
-				for (const msg of invalidImports) app.logger.warn(`  - ${msg}`);
+			if (invalidImports.length > 0 && nitro.options.dev) {
+				nitro.logger.warn("[nitro-graphql] Some resolver imports could not be generated:");
+				for (const msg of invalidImports) nitro.logger.warn(`  - ${msg}`);
 			}
 			const data = imports.map(({ imports: importList }) => importList.map((i) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
 			return [
@@ -161,35 +161,35 @@ function virtualResolvers(app) {
 				""
 			].join("\n");
 		} catch (error) {
-			app.logger.error("[nitro-graphql] Failed to generate virtual resolver module:", error);
+			nitro.logger.error("[nitro-graphql] Failed to generate virtual resolver module:", error);
 			return "export const resolvers = []";
 		}
 	};
 }
-function virtualDirectives(app) {
-	const getDirectives = () => app.scanDirectives || [];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/server-directives"] = () => {
+function virtualDirectives(nitro) {
+	const getDirectives = () => nitro.scanDirectives || [];
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/server-directives"] = () => {
 		try {
 			const imports = getDirectives();
 			if (imports.length === 0) return "export const directives = []";
 			const importsContent = [];
 			const invalidImports = [];
-			for (const { specifier, imports: importList, options } of imports) try {
+			for (const { specifier, imports: importList, options: options$1 } of imports) try {
 				if (!importList || importList.length === 0) {
 					invalidImports.push(`${specifier}: No exports found`);
 					continue;
 				}
-				const importCode = genImport(specifier, importList, options);
+				const importCode = genImport(specifier, importList, options$1);
 				importsContent.push(importCode);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
 				invalidImports.push(`${specifier}: ${message}`);
-				if (app.options.dev) app.logger.error(`[nitro-graphql] Failed to generate import for directive ${specifier}:`, error);
+				if (nitro.options.dev) nitro.logger.error(`[nitro-graphql] Failed to generate import for directive ${specifier}:`, error);
 			}
-			if (invalidImports.length > 0 && app.options.dev) {
-				app.logger.warn("[nitro-graphql] Some directive imports could not be generated:");
-				for (const msg of invalidImports) app.logger.warn(`  - ${msg}`);
+			if (invalidImports.length > 0 && nitro.options.dev) {
+				nitro.logger.warn("[nitro-graphql] Some directive imports could not be generated:");
+				for (const msg of invalidImports) nitro.logger.warn(`  - ${msg}`);
 			}
 			const data = imports.map(({ imports: importList }) => importList.map((i) => `{ directive: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
 			return [
@@ -201,76 +201,76 @@ function virtualDirectives(app) {
 				""
 			].join("\n");
 		} catch (error) {
-			app.logger.error("[nitro-graphql] Failed to generate virtual directive module:", error);
+			nitro.logger.error("[nitro-graphql] Failed to generate virtual directive module:", error);
 			return "export const directives = []";
 		}
 	};
 }
-function getGraphQLConfig(app) {
-	const configPath = resolve(app.graphql.serverDir, "config.ts");
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/graphql-config"] = () => {
+function getGraphQLConfig(nitro) {
+	const configPath = resolve(nitro.graphql.serverDir, "config.ts");
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/graphql-config"] = () => {
 		return `import config from '${configPath}'
 const importedConfig = config
 export { importedConfig }
 `;
 	};
 }
-function virtualModuleConfig(app) {
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/module-config"] = () => {
-		const moduleConfig = app.options.graphql || {};
+function virtualModuleConfig(nitro) {
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/module-config"] = () => {
+		const moduleConfig = nitro.options.graphql || {};
 		return `export const moduleConfig = ${JSON.stringify(moduleConfig, null, 2)};`;
 	};
 }
-function virtualDebugInfo(app) {
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/debug-info"] = () => {
+function virtualDebugInfo(nitro) {
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/debug-info"] = () => {
 		const virtualModuleCodes = {};
 		try {
-			const schemasGenerator = app.options.virtual["#nitro-graphql/server-schemas"];
+			const schemasGenerator = nitro.options.virtual["#nitro-graphql/server-schemas"];
 			if (schemasGenerator && typeof schemasGenerator === "function") virtualModuleCodes["server-schemas"] = schemasGenerator();
 		} catch (error) {
 			virtualModuleCodes["server-schemas"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
 		}
 		try {
-			const resolversGenerator = app.options.virtual["#nitro-graphql/server-resolvers"];
+			const resolversGenerator = nitro.options.virtual["#nitro-graphql/server-resolvers"];
 			if (resolversGenerator && typeof resolversGenerator === "function") virtualModuleCodes["server-resolvers"] = resolversGenerator();
 		} catch (error) {
 			virtualModuleCodes["server-resolvers"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
 		}
 		try {
-			const directivesGenerator = app.options.virtual["#nitro-graphql/server-directives"];
+			const directivesGenerator = nitro.options.virtual["#nitro-graphql/server-directives"];
 			if (directivesGenerator && typeof directivesGenerator === "function") virtualModuleCodes["server-directives"] = directivesGenerator();
 		} catch (error) {
 			virtualModuleCodes["server-directives"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
 		}
 		try {
-			const moduleConfigGenerator = app.options.virtual["#nitro-graphql/module-config"];
+			const moduleConfigGenerator = nitro.options.virtual["#nitro-graphql/module-config"];
 			if (moduleConfigGenerator && typeof moduleConfigGenerator === "function") virtualModuleCodes["module-config"] = moduleConfigGenerator();
 		} catch (error) {
 			virtualModuleCodes["module-config"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
 		}
 		try {
-			const graphqlConfigGenerator = app.options.virtual["#nitro-graphql/graphql-config"];
+			const graphqlConfigGenerator = nitro.options.virtual["#nitro-graphql/graphql-config"];
 			if (graphqlConfigGenerator && typeof graphqlConfigGenerator === "function") virtualModuleCodes["graphql-config"] = graphqlConfigGenerator();
 		} catch (error) {
 			virtualModuleCodes["graphql-config"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
 		}
 		const debugInfo = {
-			isDev: app.options.dev,
-			framework: app.options.framework.name,
-			graphqlFramework: app.options.graphql?.framework,
-			federation: app.options.graphql?.federation,
+			isDev: nitro.options.dev,
+			framework: nitro.options.framework.name,
+			graphqlFramework: nitro.options.graphql?.framework,
+			federation: nitro.options.graphql?.federation,
 			scanned: {
-				schemas: app.scanSchemas?.length || 0,
-				schemaFiles: app.scanSchemas || [],
-				resolvers: app.scanResolvers?.length || 0,
-				resolverFiles: app.scanResolvers || [],
-				directives: app.scanDirectives?.length || 0,
-				directiveFiles: app.scanDirectives || [],
-				documents: app.scanDocuments?.length || 0,
-				documentFiles: app.scanDocuments || []
+				schemas: nitro.scanSchemas?.length || 0,
+				schemaFiles: nitro.scanSchemas || [],
+				resolvers: nitro.scanResolvers?.length || 0,
+				resolverFiles: nitro.scanResolvers || [],
+				directives: nitro.scanDirectives?.length || 0,
+				directiveFiles: nitro.scanDirectives || [],
+				documents: nitro.scanDocuments?.length || 0,
+				documentFiles: nitro.scanDocuments || []
 			},
 			virtualModules: virtualModuleCodes
 		};

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

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

package/dist/routes/debug.d.mts

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

package/dist/routes/health.d.mts

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

package/dist/setup/file-watcher.mjs

@@ -0,0 +1,80 @@
+import { DIRECTIVE_EXTENSIONS, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, GRAPHQL_EXTENSIONS, LOG_TAG, RESOLVER_EXTENSIONS } from "../constants.mjs";
+import { DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT } from "../config/defaults.mjs";
+import { generateDirectiveSchemas } from "../utils/directive-parser.mjs";
+import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerServerDirectories, scanDirectives, scanResolvers, scanSchemas } from "../utils/index.mjs";
+import { clientTypeGeneration, serverTypeGeneration } from "../codegen/index.mjs";
+import consola from "consola";
+import { join } from "pathe";
+import { watch } from "chokidar";
+
+//#region src/setup/file-watcher.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Setup file watcher for GraphQL files (schemas, resolvers, directives, documents)
+* Watches for changes and triggers type regeneration and dev server reload
+*/
+function setupFileWatcher(nitro, watchDirs) {
+	const watcher = watch(watchDirs, {
+		persistent: DEFAULT_WATCHER_PERSISTENT,
+		ignoreInitial: DEFAULT_WATCHER_IGNORE_INITIAL,
+		ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns()]
+	});
+	watcher.on("all", async (_, path) => {
+		const isGraphQLFile = GRAPHQL_EXTENSIONS.some((ext) => path.endsWith(ext));
+		const isResolverFile = RESOLVER_EXTENSIONS.some((ext) => path.endsWith(ext));
+		const isDirectiveFile = DIRECTIVE_EXTENSIONS.some((ext) => path.endsWith(ext));
+		if (isGraphQLFile || isResolverFile || isDirectiveFile) if (path.includes(nitro.graphql.serverDir) || path.includes(DIR_SERVER_GRAPHQL) || path.includes(DIR_SERVER_GRAPHQL_WIN) || isResolverFile || isDirectiveFile) {
+			const directives = await scanDirectives(nitro);
+			nitro.scanDirectives = directives;
+			if (!nitro.scanSchemas) nitro.scanSchemas = [];
+			const directivesPath = await generateDirectiveSchemas(nitro, directives);
+			const schemas = await scanSchemas(nitro);
+			if (directivesPath && !schemas.includes(directivesPath)) schemas.push(directivesPath);
+			nitro.scanSchemas = schemas;
+			await scanResolvers(nitro).then((r) => nitro.scanResolvers = r);
+			logger.success("Types regenerated");
+			await serverTypeGeneration(nitro, { silent: true });
+			await clientTypeGeneration(nitro, { silent: true });
+			await nitro.hooks.callHook("dev:reload");
+		} else {
+			logger.success("Types regenerated");
+			await clientTypeGeneration(nitro, { silent: true });
+		}
+	});
+	return watcher;
+}
+/**
+* Determine which directories to watch based on framework and configuration
+*/
+function getWatchDirectories(nitro) {
+	const watchDirs = [];
+	switch (nitro.options.framework.name) {
+		case "nuxt": {
+			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":
+			watchDirs.push(nitro.graphql.clientDir);
+			watchDirs.push(nitro.graphql.serverDir);
+			break;
+		default:
+			watchDirs.push(nitro.graphql.clientDir);
+			watchDirs.push(nitro.graphql.serverDir);
+	}
+	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 = join(nitro.options.rootDir, baseDir);
+			if (!watchDirs.includes(resolvedDir)) watchDirs.push(resolvedDir);
+		}
+	}
+	return watchDirs;
+}
+
+//#endregion
+export { getWatchDirectories, setupFileWatcher };

package/dist/setup/rollup-integration.mjs

@@ -0,0 +1,90 @@
+import { CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../constants.mjs";
+
+//#region src/setup/rollup-integration.ts
+/**
+* Setup Rollup/Rolldown chunking configuration for GraphQL files
+* Creates separate chunks for schemas and resolvers to optimize bundle size
+*/
+function setupRollupChunking(nitro) {
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		const manualChunks = rollupConfig.output?.manualChunks;
+		const chunkFiles = rollupConfig.output?.chunkFileNames;
+		if (!rollupConfig.output.inlineDynamicImports) {
+			rollupConfig.output.manualChunks = (id, _meta) => {
+				if (isGraphQLFile(id)) return getSchemaChunkName(id);
+				if (isResolverFile(id)) return getResolverChunkName(id);
+				if (typeof manualChunks === "function") return manualChunks(id, meta);
+			};
+			rollupConfig.output.advancedChunks = {
+				groups: [{
+					name: CHUNK_NAME_SCHEMAS,
+					test: /* @__PURE__ */ new RegExp(`\\.(${GRAPHQL_EXTENSIONS.map((e) => e.slice(1)).join("|")})$`)
+				}, {
+					name: CHUNK_NAME_RESOLVERS,
+					test: /\.resolver\.(ts|js)$/
+				}],
+				minSize: 0,
+				minShareCount: 1
+			};
+		}
+		rollupConfig.output.chunkFileNames = (chunkInfo) => {
+			if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => isGraphQLFile(id) || isResolverFile(id))) return CHUNK_PATH_GRAPHQL;
+			if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
+			return CHUNK_PATH_UNKNOWN;
+		};
+	});
+}
+/**
+* Check if a file is a GraphQL schema file
+*/
+function isGraphQLFile(id) {
+	return GRAPHQL_EXTENSIONS.some((ext) => id.endsWith(ext));
+}
+/**
+* Check if a file is a resolver file
+*/
+function isResolverFile(id) {
+	return RESOLVER_EXTENSIONS.some((ext) => id.endsWith(ext));
+}
+/**
+* Get chunk name for GraphQL schema files
+* All schemas are bundled into a single chunk since GraphQL server
+* merges them at runtime anyway - no benefit from separate chunks
+*/
+function getSchemaChunkName(_id) {
+	return CHUNK_NAME_SCHEMAS;
+}
+/**
+* Get chunk name for resolver files
+* All resolvers are bundled into a single chunk since GraphQL server
+* requires all resolvers to be registered at startup - no runtime lazy loading
+*/
+function getResolverChunkName(_id) {
+	return CHUNK_NAME_RESOLVERS;
+}
+/**
+* Configure external dependencies for Rollup
+* Marks codegen and federation packages as external
+*/
+function setupRollupExternals(nitro) {
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		rollupConfig.external = rollupConfig.external || [];
+		const allExternals = [...["oxc-parser", "@oxc-parser"]];
+		if (!nitro.options.graphql?.federation?.enabled) allExternals.push(...[
+			"@apollo/subgraph",
+			"@apollo/federation-internals",
+			"@apollo/cache-control-types"
+		]);
+		if (Array.isArray(rollupConfig.external)) rollupConfig.external.push(...allExternals);
+		else if (typeof rollupConfig.external === "function") {
+			const originalExternal = rollupConfig.external;
+			rollupConfig.external = (id, parent, isResolved) => {
+				if (allExternals.some((external) => id.includes(external))) return true;
+				return originalExternal(id, parent, isResolved);
+			};
+		}
+	});
+}
+
+//#endregion
+export { setupRollupChunking, setupRollupExternals };