nitro-graphql 2.0.0-beta.72 → 2.0.0-beta.73

package/dist/nitro/routes/apollo-server-ws.mjs

@@ -1,50 +1,15 @@
-import { createMergedSchema } from "../../core/schema/builder.mjs";
+import { wsHooks } from "./_ws-handler.mjs";
 import { defineWebSocketHandler } from "nitro/h3";
-import { handleProtocols } from "graphql-ws";
-import { makeHooks } from "graphql-ws/use/crossws";
-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";
 //#region src/nitro/routes/apollo-server-ws.ts
-let schema = null;
 /**
-* Get or create the merged GraphQL schema
+* Apollo Server WebSocket handler for subscriptions
+* Uses shared WebSocket handler with graphql-ws and crossws
+*
+* Note: This handler works independently from Apollo Server for subscriptions,
+* as Apollo Server v5 requires separate WebSocket handling.
+*
+* @see https://github.com/enisdenjo/graphql-ws
 */
-async function getSchema() {
-	if (!schema) schema = await createMergedSchema({
-		schemas,
-		resolvers,
-		directives,
-		moduleConfig
-	});
-	return schema;
-}
-var apollo_server_ws_default = defineWebSocketHandler({
-	upgrade(request) {
-		const selected = handleProtocols(request.headers.get("sec-websocket-protocol") || "");
-		if (selected) return { headers: { "Sec-WebSocket-Protocol": selected } };
-		return {};
-	},
-	...makeHooks({
-		schema: () => getSchema(),
-		context: async (ctx) => {
-			const baseContext = { connectionParams: ctx.connectionParams };
-			if (typeof importedConfig.context === "function") {
-				const userContext = await importedConfig.context(baseContext);
-				return {
-					...baseContext,
-					...userContext
-				};
-			}
-			if (importedConfig.context && typeof importedConfig.context === "object") return {
-				...baseContext,
-				...importedConfig.context
-			};
-			return baseContext;
-		}
-	})
-});
+var apollo_server_ws_default = defineWebSocketHandler(wsHooks);
 //#endregion
 export { apollo_server_ws_default as default };

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

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

package/dist/nitro/routes/apollo-server.mjs

@@ -1,69 +1,30 @@
-import { createMergedSchema } from "../../core/schema/builder.mjs";
-import defu from "defu";
-import { ApolloServer } from "@apollo/server";
+import { BASE_SCHEMA_DEF } from "../../core/schema/builder.mjs";
+import { createApolloServerInstance } from "../../core/server/apollo.mjs";
 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 { ApolloServerPluginLandingPageDisabled } from "@apollo/server/plugin/disabled";
-import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
 import { startServerAndCreateH3Handler } from "nitro-graphql/apollo";
 //#region src/nitro/routes/apollo-server.ts
-let apolloServer = null;
-let serverStarted = false;
-async function createApolloServer() {
-	if (!apolloServer) {
-		const schema = await createMergedSchema({
-			schemas,
-			resolvers,
-			directives,
-			moduleConfig
-		});
-		const securityConfig = moduleConfig.security || {
-			introspection: true,
-			playground: true,
-			maskErrors: false,
-			disableSuggestions: false
-		};
-		const plugins = [];
-		if (securityConfig.playground) plugins.push(ApolloServerPluginLandingPageLocalDefault({ embed: true }));
-		else plugins.push(ApolloServerPluginLandingPageDisabled());
-		const userFacingCodes = [
-			"BAD_USER_INPUT",
-			"GRAPHQL_VALIDATION_FAILED",
-			"UNAUTHENTICATED",
-			"FORBIDDEN",
-			"BAD_REQUEST"
-		];
-		apolloServer = new ApolloServer(defu({
-			schema,
-			introspection: securityConfig.introspection,
-			plugins,
-			formatError: securityConfig.maskErrors ? (formattedError, _error) => {
-				const code = formattedError?.extensions?.code;
-				if (code && userFacingCodes.includes(code)) return formattedError;
-				return {
-					message: "Internal server error",
-					extensions: { code: "INTERNAL_SERVER_ERROR" }
-				};
-			} : void 0
-		}, importedConfig));
-		if (!serverStarted) {
-			await apolloServer.start();
-			serverStarted = true;
-		}
-	}
-	return apolloServer;
-}
 let serverPromise = null;
+let cachedH3Handler = null;
 var apollo_server_default = defineEventHandler(async (event) => {
-	if (!serverPromise) serverPromise = createApolloServer();
-	return startServerAndCreateH3Handler(await serverPromise, {
-		context: async () => ({ event }),
+	if (!serverPromise) serverPromise = createApolloServerInstance({
+		schemas: [BASE_SCHEMA_DEF, ...schemas],
+		resolvers,
+		directives,
+		moduleConfig,
+		security: moduleConfig.security,
+		importedConfig
+	});
+	const server = await serverPromise;
+	if (!cachedH3Handler) cachedH3Handler = startServerAndCreateH3Handler(server, {
+		context: async (req) => ({ event: req.event }),
 		serverAlreadyStarted: true
-	})(event);
+	});
+	return cachedH3Handler(event);
 });
 //#endregion
 export { apollo_server_default as default };

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

@@ -9,7 +9,7 @@ import * as nitro_h30 from "nitro/h3";
  * - /_nitro/graphql/debug - HTML dashboard
  * - /_nitro/graphql/debug?format=json - JSON API
  */
-declare const _default: nitro_h30.EventHandlerWithFetch<nitro_h30.EventHandlerRequest, Promise<string | {
+declare const _default: nitro_h30.EventHandlerWithFetch<nitro_h30.EventHandlerRequest, Promise<string | Response | {
   timestamp: string;
   environment: {
     dev: any;

package/dist/nitro/routes/debug.mjs

@@ -15,6 +15,7 @@ import { debugInfo } from "#nitro-graphql/debug-info";
 * - /_nitro/graphql/debug?format=json - JSON API
 */
 var debug_default = defineEventHandler(async (event) => {
+	if (import.meta.env?.PROD || process.env.NODE_ENV === "production") return new Response("Not Found", { status: 404 });
 	const format = getQuery(event).format || "html";
 	const processedResolverFiles = debugInfo.scanned.resolverFiles.map((r) => {
 		return {

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

@@ -3,7 +3,7 @@ import * as nitro_h30 from "nitro/h3";
 //#region src/nitro/routes/graphql-yoga-ws.d.ts
 /**
  * GraphQL Yoga WebSocket handler for subscriptions
- * Uses graphql-ws library with crossws adapter for proper protocol handling
+ * Uses shared WebSocket handler with graphql-ws and crossws
  *
  * @see https://github.com/enisdenjo/graphql-ws
  */

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

@@ -1,50 +1,12 @@
-import { createMergedSchema } from "../../core/schema/builder.mjs";
+import { wsHooks } from "./_ws-handler.mjs";
 import { defineWebSocketHandler } from "nitro/h3";
-import { handleProtocols } from "graphql-ws";
-import { makeHooks } from "graphql-ws/use/crossws";
-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";
 //#region src/nitro/routes/graphql-yoga-ws.ts
-let schema = null;
 /**
-* Get or create the merged GraphQL schema
+* GraphQL Yoga WebSocket handler for subscriptions
+* Uses shared WebSocket handler with graphql-ws and crossws
+*
+* @see https://github.com/enisdenjo/graphql-ws
 */
-async function getSchema() {
-	if (!schema) schema = await createMergedSchema({
-		schemas,
-		resolvers,
-		directives,
-		moduleConfig
-	});
-	return schema;
-}
-var graphql_yoga_ws_default = defineWebSocketHandler({
-	upgrade(request) {
-		const selected = handleProtocols(request.headers.get("sec-websocket-protocol") || "");
-		if (selected) return { headers: { "Sec-WebSocket-Protocol": selected } };
-		return {};
-	},
-	...makeHooks({
-		schema: () => getSchema(),
-		context: async (ctx) => {
-			const baseContext = { connectionParams: ctx.connectionParams };
-			if (typeof importedConfig.context === "function") {
-				const userContext = await importedConfig.context(baseContext);
-				return {
-					...baseContext,
-					...userContext
-				};
-			}
-			if (importedConfig.context && typeof importedConfig.context === "object") return {
-				...baseContext,
-				...importedConfig.context
-			};
-			return baseContext;
-		}
-	})
-});
+var graphql_yoga_ws_default = defineWebSocketHandler(wsHooks);
 //#endregion
 export { graphql_yoga_ws_default as default };

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

@@ -1,4 +1,5 @@
-import { BASE_SCHEMA, createYogaServer } from "../../core/server/yoga.mjs";
+import { BASE_SCHEMA_DEF } from "../../core/schema/builder.mjs";
+import { createYogaServer } from "../../core/server/yoga.mjs";
 import { defineEventHandler, getQuery } from "nitro/h3";
 import { importedConfig } from "#nitro-graphql/graphql-config";
 import { moduleConfig } from "#nitro-graphql/module-config";
@@ -10,19 +11,20 @@ const PLAYGROUND_CACHE_HEADER = "public, max-age=2592000, stale-while-revalidate
 let server = null;
 var graphql_yoga_default = defineEventHandler(async (event) => {
 	if (!server) server = await createYogaServer({
-		schemas: [BASE_SCHEMA, ...schemas],
+		schemas: [BASE_SCHEMA_DEF, ...schemas],
 		resolvers,
 		directives,
 		moduleConfig,
-		endpoint: "/api/graphql",
+		endpoint: moduleConfig.endpoint?.graphql || "/api/graphql",
 		security: moduleConfig.security,
 		importedConfig
 	});
 	const response = await server.fetch(event.req, event);
 	const isPlaygroundRequest = event.req.method === "GET" && !getQuery(event).query;
 	if (event.res.status && event.res.status !== 200) return new Response(response.body, {
-		...response,
-		status: event.res.status
+		status: event.res.status,
+		statusText: response.statusText,
+		headers: response.headers
 	});
 	if (isPlaygroundRequest && response.headers.get("content-type")?.includes("text/html")) {
 		const headers = new Headers(response.headers);

package/dist/nitro/routes/health.mjs

@@ -1,36 +1,34 @@
+import { createMergedSchema } from "../../core/schema/builder.mjs";
+import { execute, parse } from "graphql";
 import { defineEventHandler } from "nitro/h3";
-import { useRuntimeConfig } from "nitro/runtime-config";
-import { $fetch } from "ofetch";
+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";
 //#region src/nitro/routes/health.ts
+let schema = null;
+async function getSchema() {
+	if (!schema) schema = await createMergedSchema({
+		schemas,
+		resolvers,
+		directives,
+		moduleConfig
+	});
+	return schema;
+}
+const HEALTH_QUERY = parse("query Health { __typename }");
 var health_default = defineEventHandler(async (event) => {
-	const runtime = useRuntimeConfig();
-	if (!runtime.graphql || !runtime.graphql.endpoint?.graphql) {
-		event.res.status = 404;
-		event.res.statusText = "Not Found";
-		return {
-			status: "error",
-			message: "GraphQL health check endpoint is not configured",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString()
-		};
-	}
 	try {
-		const response = await $fetch(runtime.graphql.endpoint?.graphql, {
-			method: "POST",
-			body: {
-				query: "query Health { __typename }",
-				operationName: "Health"
-			},
-			headers: {
-				"Content-Type": "application/json",
-				"Accept": "application/json"
-			}
+		const result = await execute({
+			schema: await getSchema(),
+			document: HEALTH_QUERY
 		});
-		if (response && typeof response === "object" && "data" in response) return {
+		if (result.data) return {
 			status: "healthy",
 			message: "GraphQL server is running",
 			timestamp: (/* @__PURE__ */ new Date()).toISOString()
 		};
-		throw new Error("Invalid response from GraphQL server");
+		throw new Error(result.errors?.map((e) => e.message).join(", ") || "Invalid response from GraphQL server");
 	} catch (error) {
 		event.res.status = 503;
 		event.res.statusText = "Service Unavailable";

package/dist/nitro/setup/extend-loader.d.mts

@@ -1,3 +1,4 @@
+import { GraphQLScanState } from "../types/augmentation.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro/setup/extend-loader.d.ts
@@ -5,12 +6,12 @@ import { Nitro } from "nitro/types";
  * Resolve extend directories for file watching
  */
 declare function resolveExtendDirs(nitro: Nitro): Promise<string[]>;
-interface ResolveExtendOptions {
-  silent?: boolean;
-}
 /**
- * Resolve extend configuration and add files to Nitro scan results
+ * Resolve extend configuration and merge into scan state.
+ * Returns a new frozen state — does NOT mutate nitro.
  */
-declare function resolveExtendConfig(nitro: Nitro, options?: ResolveExtendOptions): Promise<void>;
+declare function resolveExtendConfig(nitro: Nitro, state: GraphQLScanState, options?: {
+  silent?: boolean;
+}): Promise<GraphQLScanState>;
 //#endregion
 export { resolveExtendConfig, resolveExtendDirs };

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

@@ -1,6 +1,7 @@
 import { LOG_TAG } from "../../core/constants.mjs";
 import { generateDirectiveSchemas } from "../../core/utils/directive-parser.mjs";
 import { resolveExtendDirs as resolveExtendDirs$1, scanAllExtendSources } from "../../core/extend/loader.mjs";
+import { mergeScanState } from "../state.mjs";
 import consola from "consola";
 //#region src/nitro/setup/extend-loader.ts
 const logger = consola.withTag(LOG_TAG);
@@ -12,69 +13,40 @@ async function resolveExtendDirs(nitro) {
 	return resolveExtendDirs$1(extend, nitro.options.rootDir);
 }
 /**
-* Resolve extend configuration and add files to Nitro scan results
+* Resolve extend configuration and merge into scan state.
+* Returns a new frozen state — does NOT mutate nitro.
 */
-async function resolveExtendConfig(nitro, options = {}) {
+async function resolveExtendConfig(nitro, state, options = {}) {
 	const extend = nitro.options.graphql?.extend;
-	if (!extend || !Array.isArray(extend) || extend.length === 0) return;
-	const stats = applyExtendResult(nitro, await scanAllExtendSources(extend, nitro.options.rootDir));
-	if (stats.directives > 0) {
-		const directiveSchemas = await generateDirectiveSchemas(nitro.scanDirectives, nitro.graphql.buildDir);
-		nitro.graphql.directiveSchemas = directiveSchemas;
-	}
-	if (!options.silent && (stats.schemas > 0 || stats.resolvers > 0 || stats.directives > 0 || stats.documents > 0)) {
+	if (!extend || !Array.isArray(extend) || extend.length === 0) return state;
+	const result = await scanAllExtendSources(extend, nitro.options.rootDir);
+	let newState = mergeScanState(state, result);
+	if (result.directives.length > 0) {
+		const directiveSchemas = await generateDirectiveSchemas([...newState.directives], nitro.graphql.buildDir);
+		newState = Object.freeze({
+			...newState,
+			directiveSchemas
+		});
+	}
+	const added = {
+		schemas: newState.schemas.length - state.schemas.length,
+		resolvers: newState.resolvers.length - state.resolvers.length,
+		directives: newState.directives.length - state.directives.length,
+		documents: newState.documents.length - state.documents.length,
+		configs: newState.extendConfigs.length - state.extendConfigs.length,
+		programmaticSchemas: newState.extendSchemas.length - state.extendSchemas.length
+	};
+	if (!options.silent && Object.values(added).some((v) => v > 0)) {
 		const parts = [];
-		if (stats.schemas > 0) parts.push(`${stats.schemas} schema(s)`);
-		if (stats.resolvers > 0) parts.push(`${stats.resolvers} resolver(s)`);
-		if (stats.directives > 0) parts.push(`${stats.directives} directive(s)`);
-		if (stats.documents > 0) parts.push(`${stats.documents} document(s)`);
-		if (stats.configs > 0) parts.push(`${stats.configs} config(s)`);
-		if (stats.programmaticSchemas > 0) parts.push(`${stats.programmaticSchemas} programmatic schema(s)`);
+		if (added.schemas > 0) parts.push(`${added.schemas} schema(s)`);
+		if (added.resolvers > 0) parts.push(`${added.resolvers} resolver(s)`);
+		if (added.directives > 0) parts.push(`${added.directives} directive(s)`);
+		if (added.documents > 0) parts.push(`${added.documents} document(s)`);
+		if (added.configs > 0) parts.push(`${added.configs} config(s)`);
+		if (added.programmaticSchemas > 0) parts.push(`${added.programmaticSchemas} programmatic schema(s)`);
 		logger.info(`Extended with ${parts.join(", ")}`);
 	}
-}
-/**
-* Apply extend scan result to Nitro state
-*/
-function applyExtendResult(nitro, result) {
-	let schemasAdded = 0;
-	let resolversAdded = 0;
-	let directivesAdded = 0;
-	let documentsAdded = 0;
-	let configsAdded = 0;
-	let programmaticSchemasAdded = 0;
-	for (const schemaPath of result.schemas) if (!nitro.scanSchemas.includes(schemaPath)) {
-		nitro.scanSchemas.push(schemaPath);
-		schemasAdded++;
-	}
-	for (const resolver of result.resolvers) if (!nitro.scanResolvers.some((r) => r.specifier === resolver.specifier)) {
-		nitro.scanResolvers.push(resolver);
-		resolversAdded++;
-	}
-	for (const directive of result.directives) if (!nitro.scanDirectives.some((d) => d.specifier === directive.specifier)) {
-		nitro.scanDirectives.push(directive);
-		directivesAdded++;
-	}
-	for (const docPath of result.documents) if (!nitro.scanDocuments.includes(docPath)) {
-		nitro.scanDocuments.push(docPath);
-		documentsAdded++;
-	}
-	if (result.configPath && !nitro.graphql.extendConfigs.includes(result.configPath)) {
-		nitro.graphql.extendConfigs.push(result.configPath);
-		configsAdded++;
-	}
-	if (result.schemaPath && !nitro.graphql.extendSchemas.includes(result.schemaPath)) {
-		nitro.graphql.extendSchemas.push(result.schemaPath);
-		programmaticSchemasAdded++;
-	}
-	return {
-		schemas: schemasAdded,
-		resolvers: resolversAdded,
-		directives: directivesAdded,
-		documents: documentsAdded,
-		configs: configsAdded,
-		programmaticSchemas: programmaticSchemasAdded
-	};
+	return newState;
 }
 //#endregion
 export { resolveExtendConfig, resolveExtendDirs };

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

@@ -1,7 +1,9 @@
 import { LOG_TAG } from "../../core/constants.mjs";
-import { generateClientTypes, generateServerTypes } from "../codegen.mjs";
-import { createCoreWatcher } from "../../core/watcher/index.mjs";
+import { refreshVirtualModules } from "../virtual/index.mjs";
+import { createCoreWatcher } from "../../core/watcher/create-watcher.mjs";
+import { generateClientTypes } from "../codegen/client-types.mjs";
 import { performGraphQLScan, shouldScanLocalFiles } from "./scanner.mjs";
+import { regenerateTypes } from "./type-generation.mjs";
 import consola from "consola";
 import { join } from "pathe";
 //#region src/nitro/setup/file-watcher.ts
@@ -24,8 +26,8 @@ function setupFileWatcher(nitro, watchDirs) {
 				silent: true,
 				isRescan: true
 			});
-			await generateServerTypes(nitro, { silent: true });
-			await generateClientTypes(nitro, { silent: true });
+			refreshVirtualModules(nitro);
+			await regenerateTypes(nitro, { silent: true });
 			logger.success("Types regenerated");
 			await nitro.hooks.callHook("dev:reload");
 		},

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

@@ -1,16 +1,9 @@
-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 };
+export { logStartupInfo };

package/dist/nitro/setup/logging.mjs

@@ -1,40 +1,25 @@
+import { resolveSecurityConfig } from "./security.mjs";
 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 { state } = nitro.graphql;
 	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}`,
+				`Schemas: ${state.schemas.length}`,
+				`Resolvers: ${state.resolvers.length}`,
 				externalServicesCount > 0 ? `External Services: ${externalServicesCount}` : "",
-				docs.length > 0 ? `Documents: ${docs.length}` : "",
+				state.documents.length > 0 ? `Documents: ${state.documents.length}` : "",
 				"",
 				"Security:",
 				`├─ Introspection: ${securityConfig.introspection ? "enabled" : "disabled"}`,
@@ -52,7 +37,7 @@ function logStartupInfo(nitro, serverEnabled) {
 		message: [
 			"Server mode: disabled",
 			`External Services: ${externalServicesCount}`,
-			`Documents: ${docs.length}`
+			`Documents: ${state.documents.length}`
 		].join("\n"),
 		style: {
 			borderColor: "blue",
@@ -61,4 +46,4 @@ function logStartupInfo(nitro, serverEnabled) {
 	});
 }
 //#endregion
-export { logStartupInfo, resolveSecurityConfig };
+export { logStartupInfo };

package/dist/nitro/setup/rollup-integration.mjs

@@ -1,3 +1,4 @@
+import { CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_UNKNOWN, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../../core/constants.mjs";
 //#region src/nitro/setup/rollup-integration.ts
 const NITRO_GRAPHQL_ROUTES_RE = /nitro-graphql[/\\]dist[/\\]nitro[/\\]routes/;
 const NITRO_GRAPHQL_SCHEMA_RE = /nitro-graphql[/\\]dist[/\\]core[/\\]schema/;
@@ -20,7 +21,37 @@ function setupNoExternals(nitro) {
 * interfering with Nitro's node_modules chunking which uses advancedChunks.
 */
 function setupRollupChunking(nitro) {
-	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {});
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		if (rollupConfig.output.inlineDynamicImports) return;
+		const output = rollupConfig.output;
+		if (output.advancedChunks || "codeSplitting" in output) return;
+		const existingManualChunks = rollupConfig.output?.manualChunks;
+		rollupConfig.output.manualChunks = (id, meta) => {
+			if (isGraphQLFile(id)) return `graphql/${CHUNK_NAME_SCHEMAS}`;
+			if (isResolverFile(id)) return `graphql/${CHUNK_NAME_RESOLVERS}`;
+			if (typeof existingManualChunks === "function") return existingManualChunks(id, meta);
+		};
+		const existingChunkFileNames = rollupConfig.output.chunkFileNames;
+		rollupConfig.output.chunkFileNames = (chunkInfo) => {
+			const name = chunkInfo.name || "";
+			if (name.startsWith("graphql/")) return `chunks/${name}.mjs`;
+			if (typeof existingChunkFileNames === "function") return existingChunkFileNames(chunkInfo);
+			if (typeof existingChunkFileNames === "string") return existingChunkFileNames;
+			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));
 }
 /**
 * Configure external dependencies for Rollup