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

package/dist/nitro/paths.mjs

@@ -0,0 +1,97 @@
+import { isAbsolute, resolve } from "pathe";
+//#region src/nitro/paths.ts
+const SERVICE_NAME_RE = /\{serviceName\}/g;
+const BUILD_DIR_RE = /\{buildDir\}/g;
+const ROOT_DIR_RE = /\{rootDir\}/g;
+const FRAMEWORK_RE = /\{framework\}/g;
+const TYPES_DIR_RE = /\{typesDir\}/g;
+const SERVER_DIR_RE = /\{serverDir\}/g;
+const CLIENT_DIR_RE = /\{clientDir\}/g;
+/**
+* Replace placeholders in a path string
+* Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverDir}, {clientDir}
+*/
+function replacePlaceholders(path, placeholders) {
+	return path.replace(SERVICE_NAME_RE, placeholders.serviceName || "default").replace(BUILD_DIR_RE, placeholders.buildDir).replace(ROOT_DIR_RE, placeholders.rootDir).replace(FRAMEWORK_RE, placeholders.framework).replace(TYPES_DIR_RE, placeholders.typesDir).replace(SERVER_DIR_RE, placeholders.serverDir).replace(CLIENT_DIR_RE, placeholders.clientDir);
+}
+/**
+* Get default paths based on framework and user configuration
+*/
+function getDefaultPaths(nitro) {
+	const isNuxt = nitro.options.framework?.name === "nuxt";
+	const rootDir = nitro.options.rootDir;
+	const buildDir = nitro.options.buildDir;
+	const graphqlConfig = nitro.options.graphql || {};
+	const defaultServerDir = graphqlConfig.serverDir ? resolve(rootDir, graphqlConfig.serverDir) : resolve(rootDir, "server", "graphql");
+	const defaultClientDir = graphqlConfig.clientDir ? resolve(rootDir, graphqlConfig.clientDir) : resolve(rootDir, isNuxt ? "app/graphql" : "graphql");
+	const defaultTypesDir = graphqlConfig.typesDir ? resolve(rootDir, graphqlConfig.typesDir) : resolve(buildDir, "types");
+	return {
+		serviceName: "default",
+		buildDir,
+		rootDir,
+		framework: isNuxt ? "nuxt" : "nitro",
+		typesDir: defaultTypesDir,
+		serverDir: defaultServerDir,
+		clientDir: defaultClientDir
+	};
+}
+/**
+* Check if a file should be generated based on config
+* Returns: true if should generate, false if should skip
+*/
+function shouldGenerateFile(config, categoryEnabled, topLevelEnabled) {
+	if (config === false) return false;
+	if (config === true || typeof config === "string") return true;
+	if (categoryEnabled === false) return false;
+	if (categoryEnabled === true) return true;
+	return topLevelEnabled;
+}
+/**
+* Resolve the file path based on configuration
+* Returns: resolved absolute path or null if file should not be generated
+*/
+function resolveFilePath(config, categoryEnabled, topLevelEnabled, defaultPath, placeholders) {
+	if (!shouldGenerateFile(config, categoryEnabled, topLevelEnabled)) return null;
+	if (typeof config === "string") {
+		const customPath = replacePlaceholders(config, placeholders);
+		return isAbsolute(customPath) ? customPath : resolve(placeholders.rootDir, customPath);
+	}
+	const resolvedDefault = replacePlaceholders(defaultPath, placeholders);
+	return resolve(placeholders.rootDir, resolvedDefault);
+}
+/**
+* Check if SDK files should be generated (category-level check)
+*/
+function shouldGenerateSdk(nitro) {
+	const sdkConfig = nitro.options.graphql?.sdk;
+	if (sdkConfig === false) return false;
+	if (sdkConfig && sdkConfig.enabled === false) return false;
+	return true;
+}
+/**
+* Get SDK configuration (handles false case)
+*/
+function getSdkConfig(nitro) {
+	const sdkConfig = nitro.options.graphql?.sdk;
+	if (sdkConfig === false) return { enabled: false };
+	return sdkConfig || {};
+}
+/**
+* Check if type files should be generated (category-level check)
+*/
+function shouldGenerateTypes(nitro) {
+	const typesConfig = nitro.options.graphql?.types;
+	if (typesConfig === false) return false;
+	if (typesConfig && typesConfig.enabled === false) return false;
+	return true;
+}
+/**
+* Get types configuration (handles false case)
+*/
+function getTypesConfig(nitro) {
+	const typesConfig = nitro.options.graphql?.types;
+	if (typesConfig === false) return { enabled: false };
+	return typesConfig || {};
+}
+//#endregion
+export { getDefaultPaths, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateFile, shouldGenerateSdk, shouldGenerateTypes };

package/dist/nitro/rollup.d.mts

@@ -0,0 +1,6 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/rollup.d.ts
+declare function rollupConfig(nitro: Nitro): Promise<void>;
+//#endregion
+export { rollupConfig };

package/dist/nitro/rollup.mjs

@@ -0,0 +1,52 @@
+import { NitroAdapter } from "./adapter.mjs";
+import { registerAllVirtualModules } from "./virtual/generators.mjs";
+import { readFile } from "node:fs/promises";
+import { parse } from "graphql";
+//#region src/nitro/rollup.ts
+const GRAPHQL_FILE_RE = /\.(?:graphql|gql)$/i;
+async function rollupConfig(nitro) {
+	registerAllVirtualModules(nitro);
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		rollupConfig.plugins = rollupConfig.plugins || [];
+		const { include = GRAPHQL_FILE_RE, exclude, validate = false } = nitro.options.graphql?.loader || {};
+		if (Array.isArray(rollupConfig.plugins)) {
+			rollupConfig.plugins.push({
+				name: "nitro-graphql",
+				resolveId: {
+					order: "pre",
+					handler(id) {
+						if (GRAPHQL_FILE_RE.test(id)) return null;
+					}
+				},
+				load: {
+					order: "pre",
+					async handler(id) {
+						if (exclude?.test?.(id)) return null;
+						if (!include.test(id)) return null;
+						try {
+							const content = await readFile(id, "utf-8");
+							if (validate) parse(content);
+							return `export default ${JSON.stringify(content)}`;
+						} catch (error) {
+							if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+							const message = error instanceof Error ? error.message : String(error);
+							this.error(`Failed to read GraphQL file ${id}: ${message}`);
+						}
+					}
+				}
+			});
+			if (nitro.options.dev) rollupConfig.plugins.push({
+				name: "nitro-graphql-watcher",
+				buildStart: {
+					order: "pre",
+					async handler() {
+						const result = await NitroAdapter.scanGraphql(nitro);
+						for (const file of result.items) this.addWatchFile(file);
+					}
+				}
+			});
+		}
+	});
+}
+//#endregion
+export { rollupConfig };

package/dist/nitro/routes/apollo-sandbox-script.d.mts

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

package/dist/nitro/routes/apollo-sandbox-script.mjs

@@ -0,0 +1,12 @@
+import { createSandboxResponse } from "../../core/server/sandbox.mjs";
+import { defineEventHandler } from "nitro/h3";
+//#region src/nitro/routes/apollo-sandbox-script.ts
+/**
+* Proxy route for Apollo Sandbox script with long cache headers
+* Uses core sandbox handler for consistency with CLI.
+*/
+var apollo_sandbox_script_default = defineEventHandler(async () => {
+	return createSandboxResponse();
+});
+//#endregion
+export { apollo_sandbox_script_default as default };

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

@@ -0,0 +1,15 @@
+import * as nitro_h30 from "nitro/h3";
+
+//#region src/nitro/routes/apollo-server-ws.d.ts
+/**
+ * Apollo Server WebSocket handler for subscriptions
+ * Uses graphql-ws library with crossws adapter for proper protocol handling
+ *
+ * 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
+ */
+declare const _default: nitro_h30.EventHandler<nitro_h30.EventHandlerRequest, unknown>;
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,50 @@
+import { createMergedSchema } from "../../core/schema/builder.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
+*/
+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;
+		}
+	})
+});
+//#endregion
+export { apollo_server_ws_default as default };

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

@@ -0,0 +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>>;
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,69 @@
+import { createMergedSchema } from "../../core/schema/builder.mjs";
+import defu from "defu";
+import { ApolloServer } from "@apollo/server";
+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;
+var apollo_server_default = defineEventHandler(async (event) => {
+	if (!serverPromise) serverPromise = createApolloServer();
+	return startServerAndCreateH3Handler(await serverPromise, {
+		context: async () => ({ event }),
+		serverAlreadyStarted: true
+	})(event);
+});
+//#endregion
+export { apollo_server_default as default };

package/dist/{routes/debug.d.ts → nitro/routes/debug.d.mts}

@@ -1,7 +1,6 @@
-import * as h31 from "h3";
-
-//#region src/routes/debug.d.ts
+import * as nitro_h30 from "nitro/h3";
 
+//#region src/nitro/routes/debug.d.ts
 /**
  * Debug endpoint for inspecting virtual modules and GraphQL setup
  * Only available in development mode
@@ -10,7 +9,7 @@ import * as h31 from "h3";
  * - /_nitro/graphql/debug - HTML dashboard
  * - /_nitro/graphql/debug?format=json - JSON API
  */
-declare const _default: h31.EventHandlerWithFetch<h31.EventHandlerRequest, Promise<string | {
+declare const _default: nitro_h30.EventHandlerWithFetch<nitro_h30.EventHandlerRequest, Promise<string | {
   timestamp: string;
   environment: {
     dev: any;
@@ -31,30 +30,24 @@ declare const _default: h31.EventHandlerWithFetch<h31.EventHandlerRequest, Promi
     documentFiles: any;
   };
   runtime: {
-    loadedResolvers: number;
-    loadedSchemas: number;
-    loadedDirectives: number;
+    loadedResolvers: any;
+    loadedSchemas: any;
+    loadedDirectives: any;
   };
   virtualModules: any;
   virtualModuleSamples: {
     'server-resolvers': {
-      resolverCount: number;
-      sample: {
-        hasResolver: boolean;
-        resolverKeys: string[];
-      }[];
+      resolverCount: any;
+      sample: any;
     };
     'server-schemas': {
-      schemaCount: number;
-      sample: {
-        defLength: number;
-        defPreview: string;
-      }[];
+      schemaCount: any;
+      sample: any;
     };
     'server-directives': {
-      directiveCount: number;
+      directiveCount: any;
     };
-    'module-config': Record<string, any>;
+    'module-config': any;
   };
 }>>;
 //#endregion

package/dist/nitro/routes/debug.mjs

@@ -0,0 +1,98 @@
+import { generateDebugHtml } from "../../core/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) => {
+		return {
+			file: r.specifier.split("/").at(-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) => {
+		return {
+			file: d.specifier.split("/").at(-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 ?? null,
+			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 generateDebugHtml(fullDebugInfo);
+});
+//#endregion
+export { debug_default as default };

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

@@ -0,0 +1,12 @@
+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
+ *
+ * @see https://github.com/enisdenjo/graphql-ws
+ */
+declare const _default: nitro_h30.EventHandler<nitro_h30.EventHandlerRequest, unknown>;
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,50 @@
+import { createMergedSchema } from "../../core/schema/builder.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
+*/
+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;
+		}
+	})
+});
+//#endregion
+export { graphql_yoga_ws_default as default };

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

@@ -0,0 +1,12 @@
+import * as nitro_h30 from "nitro/h3";
+
+//#region src/nitro/routes/graphql-yoga.d.ts
+/**
+ * GraphQL Yoga Route Handler
+ *
+ * Nitro/H3 wrapper around the core GraphQL Yoga server.
+ * Uses virtual modules to load schemas, resolvers, and directives.
+ */
+declare const _default: nitro_h30.EventHandlerWithFetch<nitro_h30.EventHandlerRequest, Promise<Response>>;
+//#endregion
+export { _default as default };

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

@@ -0,0 +1,39 @@
+import { BASE_SCHEMA, 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";
+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.ts
+const PLAYGROUND_CACHE_HEADER = "public, max-age=2592000, stale-while-revalidate=86400";
+let server = null;
+var graphql_yoga_default = defineEventHandler(async (event) => {
+	if (!server) server = await createYogaServer({
+		schemas: [BASE_SCHEMA, ...schemas],
+		resolvers,
+		directives,
+		moduleConfig,
+		endpoint: "/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
+	});
+	if (isPlaygroundRequest && response.headers.get("content-type")?.includes("text/html")) {
+		const headers = new Headers(response.headers);
+		headers.set("cache-control", PLAYGROUND_CACHE_HEADER);
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	}
+	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_h30 from "nitro/h3";
+
+//#region src/nitro/routes/health.d.ts
+declare const _default: nitro_h30.EventHandlerWithFetch<nitro_h30.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,7 @@
-import { defineEventHandler } from "h3";
-import { useRuntimeConfig } from "nitro/runtime";
-
-//#region src/routes/health.ts
+import { defineEventHandler } from "nitro/h3";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import { $fetch } from "ofetch";
+//#region src/nitro/routes/health.ts
 var health_default = defineEventHandler(async (event) => {
 	const runtime = useRuntimeConfig();
 	if (!runtime.graphql || !runtime.graphql.endpoint?.graphql) {
@@ -41,6 +41,5 @@ var health_default = defineEventHandler(async (event) => {
 		};
 	}
 });
-
 //#endregion
-export { health_default as default };
+export { health_default as default };

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

@@ -0,0 +1,16 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup/extend-loader.d.ts
+/**
+ * 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
+ */
+declare function resolveExtendConfig(nitro: Nitro, options?: ResolveExtendOptions): Promise<void>;
+//#endregion
+export { resolveExtendConfig, resolveExtendDirs };