nitro-graphql 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/nitro/routes/debug.d.mts

@@ -0,0 +1,55 @@
+import * as nitro_deps_h35 from "nitro/deps/h3";
+
+//#region src/nitro/routes/debug.d.ts
+
+/**
+ * Debug endpoint for inspecting virtual modules and GraphQL setup
+ * Only available in development mode
+ *
+ * Routes:
+ * - /_nitro/graphql/debug - HTML dashboard
+ * - /_nitro/graphql/debug?format=json - JSON API
+ */
+declare const _default: nitro_deps_h35.EventHandlerWithFetch<nitro_deps_h35.EventHandlerRequest, Promise<string | {
+  timestamp: string;
+  environment: {
+    dev: any;
+    framework: any;
+  };
+  graphql: {
+    framework: any;
+    federation: any;
+  };
+  scanned: {
+    schemas: any;
+    schemaFiles: any;
+    resolvers: any;
+    resolverFiles: any;
+    directives: any;
+    directiveFiles: any;
+    documents: any;
+    documentFiles: any;
+  };
+  runtime: {
+    loadedResolvers: any;
+    loadedSchemas: any;
+    loadedDirectives: any;
+  };
+  virtualModules: any;
+  virtualModuleSamples: {
+    'server-resolvers': {
+      resolverCount: any;
+      sample: any;
+    };
+    'server-schemas': {
+      schemaCount: any;
+      sample: any;
+    };
+    'server-directives': {
+      directiveCount: any;
+    };
+    'module-config': any;
+  };
+}>>;
+//#endregion
+export { _default as default };

package/dist/nitro/routes/debug.mjs

@@ -0,0 +1,102 @@
+import { generateHtmlDashboard } from "./debug-template.mjs";
+import { defineEventHandler, getQuery } from "nitro/h3";
+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 { debugInfo } from "#nitro-graphql/debug-info";
+
+//#region src/nitro/routes/debug.ts
+/**
+* Debug endpoint for inspecting virtual modules and GraphQL setup
+* Only available in development mode
+*
+* Routes:
+* - /_nitro/graphql/debug - HTML dashboard
+* - /_nitro/graphql/debug?format=json - JSON API
+*/
+var debug_default = defineEventHandler(async (event) => {
+	const format = getQuery(event).format || "html";
+	const processedResolverFiles = debugInfo.scanned.resolverFiles.map((r) => {
+		const parts = r.specifier.split("/");
+		return {
+			file: parts[parts.length - 1],
+			fullPath: r.specifier,
+			exports: r.imports.map((i) => ({
+				name: i.name,
+				type: i.type,
+				as: i.as
+			}))
+		};
+	});
+	const processedDirectiveFiles = debugInfo.scanned.directiveFiles.map((d) => {
+		const parts = d.specifier.split("/");
+		return {
+			file: parts[parts.length - 1],
+			fullPath: d.specifier,
+			exports: d.imports.map((i) => ({
+				name: i.name,
+				type: i.type,
+				as: i.as
+			}))
+		};
+	});
+	const fullDebugInfo = {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		environment: {
+			dev: debugInfo.isDev,
+			framework: debugInfo.framework
+		},
+		graphql: {
+			framework: debugInfo.graphqlFramework,
+			federation: debugInfo.federation
+		},
+		scanned: {
+			schemas: debugInfo.scanned.schemas,
+			schemaFiles: debugInfo.scanned.schemaFiles.map((s) => {
+				return s.split("/").slice(-3).join("/");
+			}),
+			resolvers: debugInfo.scanned.resolvers,
+			resolverFiles: processedResolverFiles,
+			directives: debugInfo.scanned.directives,
+			directiveFiles: processedDirectiveFiles,
+			documents: debugInfo.scanned.documents,
+			documentFiles: debugInfo.scanned.documentFiles.map((d) => {
+				return d.split("/").slice(-3).join("/");
+			})
+		},
+		runtime: {
+			loadedResolvers: resolvers.length,
+			loadedSchemas: schemas.length,
+			loadedDirectives: directives.length
+		},
+		virtualModules: debugInfo.virtualModules || {},
+		virtualModuleSamples: {
+			"server-resolvers": {
+				resolverCount: resolvers.length,
+				sample: resolvers.slice(0, 3).map((r) => ({
+					hasResolver: !!r.resolver,
+					resolverKeys: r.resolver ? Object.keys(r.resolver) : []
+				}))
+			},
+			"server-schemas": {
+				schemaCount: schemas.length,
+				sample: schemas.slice(0, 2).map((s) => ({
+					defLength: s.def?.length || 0,
+					defPreview: s.def?.substring(0, 100) || "Empty"
+				}))
+			},
+			"server-directives": { directiveCount: directives.length },
+			"module-config": moduleConfig
+		}
+	};
+	if (format === "json") {
+		event.res.headers.set("Content-Type", "application/json");
+		return fullDebugInfo;
+	}
+	event.res.headers.set("Content-Type", "text/html");
+	return generateHtmlDashboard(fullDebugInfo);
+});
+
+//#endregion
+export { debug_default as default };

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

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

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

@@ -0,0 +1,62 @@
+import { createMergedSchema } from "../../core/schema/builder.mjs";
+import defu from "defu";
+import { defineEventHandler } from "nitro/h3";
+import { importedConfig } from "#nitro-graphql/graphql-config";
+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 { createYoga } from "graphql-yoga";
+
+//#region src/nitro/routes/graphql-yoga.ts
+const apolloSandboxHtml = `<!DOCTYPE html>
+<html lang="en">
+<body style="margin: 0; overflow-x: hidden; overflow-y: hidden">
+<div id="sandbox" style="height:100vh; width:100vw;"></div>
+<script src="https://embeddable-sandbox.cdn.apollographql.com/02e2da0fccbe0240ef03d2396d6c98559bab5b06/embeddable-sandbox.umd.production.min.js"><\/script>
+<script>
+new window.EmbeddedSandbox({
+  target: "#sandbox",
+  initialEndpoint: window.location.href,
+  hideCookieToggle: false,
+  initialState: {
+    includeCookies: true
+  }
+});
+<\/script>
+</body>
+</html>`;
+let yoga;
+var graphql_yoga_default = defineEventHandler(async (event) => {
+	if (!yoga) {
+		const schema = await createMergedSchema({
+			schemas,
+			resolvers,
+			directives,
+			moduleConfig
+		});
+		const securityConfig = moduleConfig.security || {
+			introspection: true,
+			playground: true,
+			maskErrors: false,
+			disableSuggestions: false
+		};
+		yoga = createYoga(defu({
+			schema,
+			graphqlEndpoint: "/api/graphql",
+			landingPage: securityConfig.playground,
+			graphiql: securityConfig.playground ? { defaultQuery: "# Welcome to GraphQL\n#\n# Try running a query!\n" } : false,
+			renderGraphiQL: securityConfig.playground ? () => apolloSandboxHtml : void 0,
+			maskedErrors: securityConfig.maskErrors
+		}, importedConfig));
+	}
+	const response = await yoga.handleRequest(event.req, event);
+	if (event.res.status && event.res.status !== 200) return new Response(response.body, {
+		...response,
+		status: event.res.status
+	});
+	return new Response(response.body, response);
+});
+
+//#endregion
+export { graphql_yoga_default as default };

package/dist/nitro/routes/health.d.mts

@@ -0,0 +1,10 @@
+import * as nitro_deps_h33 from "nitro/deps/h3";
+
+//#region src/nitro/routes/health.d.ts
+declare const _default: nitro_deps_h33.EventHandlerWithFetch<nitro_deps_h33.EventHandlerRequest, Promise<{
+  status: string;
+  message: string;
+  timestamp: string;
+}>>;
+//#endregion
+export { _default as default };

package/dist/{routes/health.js → nitro/routes/health.mjs}

@@ -1,7 +1,8 @@
-import { defineEventHandler } from "h3";
-import { useRuntimeConfig } from "nitro/runtime";
+import { defineEventHandler } from "nitro/h3";
+import { $fetch } from "nitro/deps/ofetch";
+import { useRuntimeConfig } from "nitro/runtime-config";
 
-//#region src/routes/health.ts
+//#region src/nitro/routes/health.ts
 var health_default = defineEventHandler(async (event) => {
 	const runtime = useRuntimeConfig();
 	if (!runtime.graphql || !runtime.graphql.endpoint?.graphql) {

package/dist/nitro/setup/file-watcher.d.mts

@@ -0,0 +1,16 @@
+import { FSWatcher } from "chokidar";
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup/file-watcher.d.ts
+
+/**
+ * Setup file watcher for GraphQL files (schemas, resolvers, directives, documents)
+ * Watches for changes and triggers type regeneration and dev server reload
+ */
+declare function setupFileWatcher(nitro: Nitro, watchDirs: string[]): FSWatcher;
+/**
+ * Determine which directories to watch based on framework and configuration
+ */
+declare function getWatchDirectories(nitro: Nitro): string[];
+//#endregion
+export { getWatchDirectories, setupFileWatcher };

package/dist/nitro/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 "../../core/constants.mjs";
+import { generateDirectiveSchemas } from "../../core/utils/directive-parser.mjs";
+import { NitroAdapter } from "../adapter.mjs";
+import { generateClientTypes, generateServerTypes } from "../codegen.mjs";
+import { DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT } from "../config.mjs";
+import consola from "consola";
+import { join } from "pathe";
+import { watch } from "chokidar";
+
+//#region src/nitro/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
+	});
+	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 directivesResult = await NitroAdapter.scanDirectives(nitro);
+			nitro.scanDirectives = directivesResult.items;
+			if (!nitro.scanSchemas) nitro.scanSchemas = [];
+			const directivesPath = await generateDirectiveSchemas(nitro, directivesResult.items);
+			const schemas = (await NitroAdapter.scanSchemas(nitro)).items;
+			if (directivesPath && !schemas.includes(directivesPath)) schemas.push(directivesPath);
+			nitro.scanSchemas = schemas;
+			nitro.scanResolvers = (await NitroAdapter.scanResolvers(nitro)).items;
+			logger.success("Types regenerated");
+			await generateServerTypes(nitro, { silent: true });
+			await generateClientTypes(nitro, { silent: true });
+			await nitro.hooks.callHook("dev:reload");
+		} else {
+			logger.success("Types regenerated");
+			await generateClientTypes(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 = nitro.options.graphql?.layerServerDirs || [];
+			const layerAppDirs = nitro.options.graphql?.layerAppDirs || [];
+			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/nitro/setup/logging.d.mts

@@ -0,0 +1,17 @@
+import { SecurityConfig } from "../types.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup/logging.d.ts
+
+/**
+ * Resolves security configuration with environment-aware defaults
+ * In production: introspection off, playground off, errors masked, suggestions disabled
+ * In development: introspection on, playground on, errors shown, suggestions enabled
+ */
+declare function resolveSecurityConfig(config?: SecurityConfig): Required<SecurityConfig>;
+/**
+ * Log startup information
+ */
+declare function logStartupInfo(nitro: Nitro, serverEnabled: boolean): void;
+//#endregion
+export { logStartupInfo, resolveSecurityConfig };

package/dist/nitro/setup/logging.mjs

@@ -0,0 +1,66 @@
+import consola from "consola";
+
+//#region src/nitro/setup/logging.ts
+/**
+* Resolves security configuration with environment-aware defaults
+* In production: introspection off, playground off, errors masked, suggestions disabled
+* In development: introspection on, playground on, errors shown, suggestions enabled
+*/
+function resolveSecurityConfig(config) {
+	const isProd = process.env.NODE_ENV === "production";
+	return {
+		introspection: config?.introspection ?? !isProd,
+		playground: config?.playground ?? !isProd,
+		maskErrors: config?.maskErrors ?? isProd,
+		disableSuggestions: config?.disableSuggestions ?? isProd
+	};
+}
+/**
+* Log startup information
+*/
+function logStartupInfo(nitro, serverEnabled) {
+	const externalServicesCount = nitro.options.graphql?.externalServices?.length || 0;
+	const docs = nitro.scanDocuments || [];
+	const isProd = process.env.NODE_ENV === "production";
+	if (serverEnabled) {
+		const securityConfig = resolveSecurityConfig(nitro.options.graphql?.security);
+		const framework = nitro.options.graphql?.framework || "unknown";
+		const schemas = nitro.scanSchemas?.length || 0;
+		const resolvers = nitro.scanResolvers?.length || 0;
+		consola.box({
+			title: "Nitro GraphQL",
+			message: [
+				`Framework: ${framework}`,
+				`Environment: ${isProd ? "production" : "development"}`,
+				`Schemas: ${schemas}`,
+				`Resolvers: ${resolvers}`,
+				externalServicesCount > 0 ? `External Services: ${externalServicesCount}` : "",
+				docs.length > 0 ? `Documents: ${docs.length}` : "",
+				"",
+				"Security:",
+				`├─ Introspection: ${securityConfig.introspection ? "enabled" : "disabled"}`,
+				`├─ Playground: ${securityConfig.playground ? "enabled" : "disabled"}`,
+				`├─ Error Masking: ${securityConfig.maskErrors ? "enabled" : "disabled"}`,
+				`└─ Field Suggestions: ${securityConfig.disableSuggestions ? "disabled" : "enabled"}`
+			].filter(Boolean).join("\n"),
+			style: {
+				borderColor: isProd ? "yellow" : "cyan",
+				borderStyle: "rounded"
+			}
+		});
+	} else consola.box({
+		title: "Nitro GraphQL (Client Only)",
+		message: [
+			"Server mode: disabled",
+			`External Services: ${externalServicesCount}`,
+			`Documents: ${docs.length}`
+		].join("\n"),
+		style: {
+			borderColor: "blue",
+			borderStyle: "rounded"
+		}
+	});
+}
+
+//#endregion
+export { logStartupInfo, resolveSecurityConfig };

package/dist/nitro/setup/rollup-integration.d.mts

@@ -0,0 +1,16 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup/rollup-integration.d.ts
+
+/**
+ * Setup Rollup/Rolldown chunking configuration for GraphQL files
+ * Creates separate chunks for schemas and resolvers to optimize bundle size
+ */
+declare function setupRollupChunking(nitro: Nitro): void;
+/**
+ * Configure external dependencies for Rollup
+ * Marks codegen and federation packages as external
+ */
+declare function setupRollupExternals(nitro: Nitro): void;
+//#endregion
+export { setupRollupChunking, setupRollupExternals };

package/dist/nitro/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 "../../core/constants.mjs";
+
+//#region src/nitro/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 };

package/dist/nitro/setup/routes.d.mts

@@ -0,0 +1,10 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup/routes.d.ts
+
+/**
+ * Register GraphQL route handlers
+ */
+declare function registerRouteHandlers(nitro: Nitro): void;
+//#endregion
+export { registerRouteHandlers };

package/dist/nitro/setup/routes.mjs

@@ -0,0 +1,35 @@
+import { ENDPOINT_DEBUG, GRAPHQL_HTTP_METHODS } from "../../core/constants.mjs";
+import { join } from "pathe";
+import { fileURLToPath } from "node:url";
+
+//#region src/nitro/setup/routes.ts
+/**
+* Register GraphQL route handlers
+*/
+function registerRouteHandlers(nitro) {
+	const runtime = fileURLToPath(new URL("../routes", import.meta.url));
+	const framework = nitro.options.graphql?.framework;
+	if (framework === "graphql-yoga") for (const method of GRAPHQL_HTTP_METHODS) nitro.options.handlers.push({
+		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+		handler: join(runtime, "graphql-yoga"),
+		method
+	});
+	if (framework === "apollo-server") for (const method of GRAPHQL_HTTP_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: ENDPOINT_DEBUG,
+		handler: join(runtime, "debug"),
+		method: "GET"
+	});
+}
+
+//#endregion
+export { registerRouteHandlers };

package/dist/nitro/setup/ts-config.d.mts

@@ -0,0 +1,11 @@
+import { Nitro, NitroTypes } from "nitro/types";
+
+//#region src/nitro/setup/ts-config.d.ts
+
+/**
+ * Setup TypeScript path aliases for GraphQL types
+ * Called via nitro:config hook to extend tsconfig.json
+ */
+declare function setupTypeScriptPaths(nitro: Nitro, types: NitroTypes): void;
+//#endregion
+export { setupTypeScriptPaths };

package/dist/nitro/setup/ts-config.mjs

@@ -0,0 +1,69 @@
+import { relativeWithDot } from "../../core/utils/imports.mjs";
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../paths.mjs";
+import { dirname, join, resolve } from "pathe";
+
+//#region src/nitro/setup/ts-config.ts
+/**
+* Setup TypeScript path aliases for GraphQL types
+* Called via nitro:config hook to extend tsconfig.json
+*/
+function setupTypeScriptPaths(nitro, types) {
+	const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
+	types.tsConfig ||= {};
+	types.tsConfig.compilerOptions ??= {};
+	types.tsConfig.compilerOptions.paths ??= {};
+	types.tsConfig.include = types.tsConfig.include || [];
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	setupServerTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig);
+	setupClientTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig);
+	setupSchemaPath(nitro, types, tsconfigDir);
+	setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, typesConfig);
+	types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(placeholders.typesDir, "graphql.d.ts")));
+}
+/**
+* Setup #graphql/server path alias
+*/
+function setupServerTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	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)];
+		types.tsConfig.include.push(relativeWithDot(tsconfigDir, serverTypesPath));
+	}
+}
+/**
+* Setup #graphql/client path alias
+*/
+function setupClientTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	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.include.push(relativeWithDot(tsconfigDir, clientTypesPath));
+	}
+}
+/**
+* Setup #graphql/schema path alias
+*/
+function setupSchemaPath(nitro, types, tsconfigDir) {
+	types.tsConfig.compilerOptions.paths["#graphql/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
+}
+/**
+* Setup #graphql/client/{serviceName} path aliases for external services
+*/
+function setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	if (!nitro.options.graphql?.externalServices?.length) return;
+	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.push(relativeWithDot(tsconfigDir, externalTypesPath));
+		}
+	}
+}
+
+//#endregion
+export { setupTypeScriptPaths };