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

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

@@ -0,0 +1,55 @@
+import * as nitro_deps_h30 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_h30.EventHandlerWithFetch<nitro_deps_h30.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/extend-loader.d.mts

@@ -0,0 +1,19 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup/extend-loader.d.ts
+
+/**
+ * Resolve extend directories for file watching
+ * Called early in setup (before watcher) to get directories to watch
+ */
+declare function resolveExtendDirs(nitro: Nitro): Promise<string[]>;
+interface ResolveExtendOptions {
+  silent?: boolean;
+}
+/**
+ * Resolve extend configuration and add files to scan results
+ * Must be called AFTER scanGraphQLFiles to append to results
+ */
+declare function resolveExtendConfig(nitro: Nitro, options?: ResolveExtendOptions): Promise<void>;
+//#endregion
+export { resolveExtendConfig, resolveExtendDirs };

package/dist/nitro/setup/extend-loader.mjs

@@ -0,0 +1,129 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import { loadPackageConfig, resolvePackageFiles } from "../../core/manifest.mjs";
+import { parseSingleFile } from "../../core/scanning/ast-scanner.mjs";
+import { parseResolverCall } from "../../core/scanning/resolvers.mjs";
+import consola from "consola";
+import { dirname, resolve } from "pathe";
+
+//#region src/nitro/setup/extend-loader.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Resolve extend directories for file watching
+* Called early in setup (before watcher) to get directories to watch
+*/
+async function resolveExtendDirs(nitro) {
+	const extend = nitro.options.graphql?.extend;
+	if (!extend || !Array.isArray(extend) || extend.length === 0) return [];
+	const dirs = [];
+	for (const source of extend) if (typeof source === "string") {
+		const pkg = await loadPackageConfig(source, nitro.options.rootDir);
+		if (pkg) {
+			const serverDir = resolve(pkg.baseDir, pkg.config.serverDir || "server/graphql");
+			dirs.push(serverDir);
+		}
+	} else if (source && typeof source === "object") {
+		const obj = source;
+		if (obj.schemas) {
+			const schemas = Array.isArray(obj.schemas) ? obj.schemas : [obj.schemas];
+			for (const schemaPath of schemas) dirs.push(dirname(resolve(nitro.options.rootDir, schemaPath)));
+		}
+		if (obj.resolvers) {
+			const resolvers = Array.isArray(obj.resolvers) ? obj.resolvers : [obj.resolvers];
+			for (const resolverPath of resolvers) dirs.push(dirname(resolve(nitro.options.rootDir, resolverPath)));
+		}
+	}
+	return [...new Set(dirs)];
+}
+/**
+* Resolve extend configuration and add files to scan results
+* Must be called AFTER scanGraphQLFiles to append to results
+*/
+async function resolveExtendConfig(nitro, options = {}) {
+	const extend = nitro.options.graphql?.extend;
+	if (!extend || !Array.isArray(extend) || extend.length === 0) return;
+	let schemasAdded = 0;
+	let resolversAdded = 0;
+	for (const source of extend) {
+		const result = await processExtendSource(source, nitro, options.silent);
+		schemasAdded += result.schemas;
+		resolversAdded += result.resolvers;
+	}
+	if (!options.silent && (schemasAdded > 0 || resolversAdded > 0)) logger.info(`Extended with ${schemasAdded} schema(s), ${resolversAdded} resolver file(s)`);
+}
+/**
+* Process a single extend source (package name or explicit config)
+*/
+async function processExtendSource(source, nitro, silent) {
+	if (typeof source === "string") return loadFromPackage(source, nitro, silent);
+	if (source && typeof source === "object") return processExplicitPaths(source, nitro);
+	return {
+		schemas: 0,
+		resolvers: 0
+	};
+}
+/**
+* Load and scan files from a package's nitro-graphql.config.ts
+*/
+async function loadFromPackage(packageName, nitro, silent) {
+	const pkg = await loadPackageConfig(packageName, nitro.options.rootDir);
+	if (!pkg) throw new Error(`[nitro-graphql] Config not found for "${packageName}". Create a nitro-graphql.config.ts file in the package root.`);
+	const files = await resolvePackageFiles(pkg);
+	if (!silent) logger.info(`Loaded config from ${packageName}`);
+	return addPackageFiles(files, nitro);
+}
+/**
+* Add files from a resolved package to scan results
+*/
+async function addPackageFiles(files, nitro) {
+	let schemasAdded = 0;
+	let resolversAdded = 0;
+	for (const schemaPath of files.schemas) if (!nitro.scanSchemas.includes(schemaPath)) {
+		nitro.scanSchemas.push(schemaPath);
+		schemasAdded++;
+	}
+	for (const resolverPath of files.resolvers) {
+		const parsed = await parseSingleFile(resolverPath, parseResolverCall);
+		if (parsed?.imports.length) {
+			nitro.scanResolvers.push(parsed);
+			resolversAdded++;
+		}
+	}
+	return {
+		schemas: schemasAdded,
+		resolvers: resolversAdded
+	};
+}
+/**
+* Process explicit paths (legacy format)
+*/
+async function processExplicitPaths(source, nitro) {
+	let schemasAdded = 0;
+	let resolversAdded = 0;
+	if (source.schemas) {
+		const schemas = Array.isArray(source.schemas) ? source.schemas : [source.schemas];
+		for (const schemaPath of schemas) {
+			const fullPath = resolve(nitro.options.rootDir, schemaPath);
+			if (!nitro.scanSchemas.includes(fullPath)) {
+				nitro.scanSchemas.push(fullPath);
+				schemasAdded++;
+			}
+		}
+	}
+	if (source.resolvers) {
+		const resolvers = Array.isArray(source.resolvers) ? source.resolvers : [source.resolvers];
+		for (const resolverPath of resolvers) {
+			const parsed = await parseSingleFile(resolve(nitro.options.rootDir, resolverPath), parseResolverCall);
+			if (parsed?.imports.length) {
+				nitro.scanResolvers.push(parsed);
+				resolversAdded++;
+			}
+		}
+	}
+	return {
+		schemas: schemasAdded,
+		resolvers: resolversAdded
+	};
+}
+
+//#endregion
+export { resolveExtendConfig, resolveExtendDirs };

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, extendDirs?: string[]): string[];
+//#endregion
+export { getWatchDirectories, setupFileWatcher };

package/dist/nitro/setup/file-watcher.mjs

@@ -0,0 +1,98 @@
+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 { resolveExtendConfig } from "./extend-loader.mjs";
+import consola from "consola";
+import { join, resolve } from "pathe";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { watch } from "chokidar";
+
+//#region src/nitro/setup/file-watcher.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Touch config.ts to trigger Rolldown's file watcher
+* This is needed because Rolldown doesn't detect changes to .graphql files in external packages
+*/
+function triggerRolldownRebuild(nitro) {
+	const configPath = resolve(nitro.graphql.serverDir, "config.ts");
+	if (existsSync(configPath)) try {
+		const content = readFileSync(configPath, "utf-8");
+		const timestampComment = `// HMR trigger: ${Date.now()}`;
+		writeFileSync(configPath, `${content.replace(/\/\/ HMR trigger: \d+\n?$/, "")}\n${timestampComment}\n`);
+	} catch {}
+}
+/**
+* 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) => {
+		if (path.includes("/sdk.ts") || path.includes("/sdk.js") || path.endsWith("/config.ts")) return;
+		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;
+			await resolveExtendConfig(nitro, { silent: true });
+			logger.success("Types regenerated");
+			await generateServerTypes(nitro, { silent: true });
+			await generateClientTypes(nitro, { silent: true });
+			if (isGraphQLFile) triggerRolldownRebuild(nitro);
+			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, extendDirs = []) {
+	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);
+	}
+	for (const dir of extendDirs) if (!watchDirs.includes(dir)) watchDirs.push(dir);
+	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 };