nitro-graphql 2.0.0-beta.36 → 2.0.0-beta.38

package/dist/nitro/adapter.mjs

@@ -0,0 +1,97 @@
+import { scanDirectivesCore } from "../core/scanning/directives.mjs";
+import { scanDocumentsCore } from "../core/scanning/documents.mjs";
+import { scanResolversCore } from "../core/scanning/resolvers.mjs";
+import { scanGraphqlCore, scanSchemasCore } from "../core/scanning/schemas.mjs";
+import { join, relative } from "pathe";
+
+//#region src/nitro/adapter.ts
+/**
+* Create a CoreLogger from Nitro's logger
+*/
+function createLoggerFromNitro(nitro) {
+	return {
+		info: (msg, ...args) => nitro.logger.info(msg, ...args),
+		warn: (msg, ...args) => nitro.logger.warn(msg, ...args),
+		error: (msg, ...args) => nitro.logger.error(msg, ...args),
+		success: (msg, ...args) => nitro.logger.success(msg, ...args),
+		debug: (msg, ...args) => nitro.logger.debug(msg, ...args)
+	};
+}
+/**
+* Create a ScanContext from Nitro instance
+*/
+function createScanContextFromNitro(nitro) {
+	return {
+		rootDir: nitro.options.rootDir,
+		serverDir: nitro.graphql.serverDir,
+		clientDir: nitro.graphql.clientDir,
+		ignorePatterns: nitro.options.ignore,
+		isDev: nitro.options.dev,
+		logger: createLoggerFromNitro(nitro),
+		layerServerDirs: nitro.options.graphql?.layerServerDirs || [],
+		layerAppDirs: nitro.options.graphql?.layerAppDirs || []
+	};
+}
+/**
+* Create a CoreConfig from Nitro instance
+*/
+function createCoreConfigFromNitro(nitro) {
+	const graphqlOptions = nitro.options.graphql || {};
+	const isNuxt = nitro.options.framework?.name === "nuxt";
+	const typesDir = join(nitro.graphql.buildDir, "types");
+	return {
+		rootDir: nitro.options.rootDir,
+		buildDir: nitro.graphql.buildDir,
+		serverDir: nitro.graphql.serverDir,
+		clientDir: nitro.graphql.clientDir,
+		typesDir,
+		framework: graphqlOptions.framework || "graphql-yoga",
+		isNuxt,
+		isDev: nitro.options.dev,
+		graphqlOptions: {
+			framework: graphqlOptions.framework,
+			endpoint: typeof graphqlOptions.endpoint === "object" ? graphqlOptions.endpoint?.graphql : graphqlOptions.endpoint,
+			federation: graphqlOptions.federation,
+			security: graphqlOptions.security
+		},
+		logger: createLoggerFromNitro(nitro),
+		ignorePatterns: nitro.options.ignore,
+		layerServerDirs: nitro.options.graphql?.layerServerDirs || [],
+		layerAppDirs: nitro.options.graphql?.layerAppDirs || []
+	};
+}
+/**
+* Create a CoreContext from Nitro instance
+*/
+function createCoreContextFromNitro(nitro) {
+	return {
+		config: createCoreConfigFromNitro(nitro),
+		graphqlBuildDir: nitro.graphql.buildDir,
+		watchDirs: nitro.graphql.watchDirs,
+		dir: nitro.graphql.dir
+	};
+}
+/**
+* Nitro framework adapter implementation
+*/
+const NitroAdapter = {
+	name: "nitro",
+	createCoreConfig: createCoreConfigFromNitro,
+	createCoreContext: createCoreContextFromNitro,
+	createScanContext: createScanContextFromNitro,
+	getLogger: createLoggerFromNitro,
+	scanSchemas: (nitro) => scanSchemasCore(createScanContextFromNitro(nitro)),
+	scanGraphql: (nitro) => scanGraphqlCore(createScanContextFromNitro(nitro)),
+	scanResolvers: (nitro) => scanResolversCore(createScanContextFromNitro(nitro)),
+	scanDirectives: (nitro) => scanDirectivesCore(createScanContextFromNitro(nitro)),
+	scanDocuments(nitro) {
+		return scanDocumentsCore(createScanContextFromNitro(nitro), {
+			externalServices: nitro.options.graphql?.externalServices,
+			clientDirRelative: relative(nitro.options.rootDir, nitro.graphql.clientDir)
+		});
+	}
+};
+var adapter_default = NitroAdapter;
+
+//#endregion
+export { NitroAdapter, createCoreConfigFromNitro, createCoreContextFromNitro, createLoggerFromNitro, createScanContextFromNitro, adapter_default as default };

package/dist/{utils → nitro}/apollo.d.mts

@@ -2,7 +2,7 @@ import { ApolloServer, BaseContext, ContextFunction } from "@apollo/server";
 import { EventHandler, H3Event } from "nitro/h3";
 import { Hooks } from "crossws";
 
-//#region src/utils/apollo.d.ts
+//#region src/nitro/apollo.d.ts
 type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
 interface H3ContextFunctionArgument {
   event: H3Event;

package/dist/{utils → nitro}/apollo.mjs

@@ -1,7 +1,7 @@
 import { HeaderMap } from "@apollo/server";
 import { eventHandler, getRequestURL, readBody } from "nitro/h3";
 
-//#region src/utils/apollo.ts
+//#region src/nitro/apollo.ts
 function startServerAndCreateH3Handler(server, options) {
 	const defaultContext = () => Promise.resolve({});
 	const contextFunction = options?.context ?? defaultContext;

package/dist/nitro/codegen.d.mts

@@ -0,0 +1,19 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/codegen.d.ts
+
+/**
+ * Generate server-side resolver types
+ */
+declare function generateServerTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+/**
+ * Generate client-side operation types
+ */
+declare function generateClientTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateClientTypes, generateServerTypes };

package/dist/nitro/codegen.mjs

@@ -0,0 +1,141 @@
+import { LOG_TAG } from "../core/constants.mjs";
+import { loadGraphQLDocuments } from "../core/codegen/document-loader.mjs";
+import { writeFile } from "../core/utils/file-io.mjs";
+import { downloadAndSaveSchema, loadExternalSchema } from "../core/codegen/schema-loader.mjs";
+import { generateClientTypesCore, generateExternalClientTypesCore } from "../core/codegen/client.mjs";
+import { generateServerTypesCore } from "../core/codegen/server.mjs";
+import { validateNoDuplicateTypes } from "../core/codegen/validation.mjs";
+import { loadFederationSupport } from "../core/schema/federation.mjs";
+import { getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldGenerateTypes } from "./paths.mjs";
+import consola from "consola";
+import { join, resolve } from "pathe";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { buildSchema, parse, print } from "graphql";
+import { existsSync, readFileSync } from "node:fs";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { loadFilesSync } from "@graphql-tools/load-files";
+
+//#region src/nitro/codegen.ts
+const logger = consola.withTag(LOG_TAG);
+async function buildSchemaFromString(source, federation) {
+	if (federation) {
+		const buildSubgraph = await loadFederationSupport();
+		if (!buildSubgraph) throw new Error("Federation enabled but @apollo/subgraph not installed");
+		return buildSubgraph([{ typeDefs: parse(source) }]);
+	}
+	return buildSchema(source);
+}
+/**
+* Generate server-side resolver types
+*/
+async function generateServerTypes(nitro, options = {}) {
+	if (!shouldGenerateTypes(nitro)) return;
+	const schemas = nitro.scanSchemas || [];
+	if (!schemas.length) {
+		if (!options.silent) consola.info("No GraphQL schemas found");
+		return;
+	}
+	try {
+		const strings = loadFilesSync(schemas).map((s) => typeof s === "string" ? s : s.loc?.source?.body || "").filter(Boolean);
+		if (!validateNoDuplicateTypes(schemas, strings)) return;
+		const merged = mergeTypeDefs([strings.join("\n\n")], { throwOnConflict: true });
+		const federation = nitro.options.graphql?.federation?.enabled === true;
+		const schema = await buildSchemaFromString(print(merged), federation);
+		const result = await generateServerTypesCore({
+			framework: nitro.options.graphql?.framework || "graphql-yoga",
+			schema,
+			config: nitro.options.graphql?.codegen?.server,
+			federationEnabled: federation
+		});
+		writeFile(resolve(nitro.graphql.buildDir, "schema.graphql"), printSchemaWithDirectives(schema));
+		const placeholders = getDefaultPaths(nitro);
+		const typesConfig = getTypesConfig(nitro);
+		const typesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+		if (typesPath) {
+			writeFile(typesPath, result.types);
+			if (!options.silent) logger.success(`Server types: ${typesPath}`);
+		}
+	} catch (error) {
+		logger.error("Server type generation failed:", error);
+	}
+}
+/**
+* Generate client-side operation types
+*/
+async function generateClientTypes(nitro, options = {}) {
+	try {
+		if (nitro.scanSchemas?.length) await generateMainClientTypes(nitro, options);
+		if (nitro.options.graphql?.externalServices?.length) await generateExternalTypes(nitro, options);
+	} catch (error) {
+		logger.error("Client type generation failed:", error);
+	}
+}
+async function generateMainClientTypes(nitro, options = {}) {
+	const schemaPath = join(nitro.graphql.buildDir, "schema.graphql");
+	if (!existsSync(schemaPath)) {
+		if (!options.silent) consola.info("Schema not ready for client types");
+		return;
+	}
+	const docs = await loadGraphQLDocuments(nitro.scanDocuments);
+	const federation = nitro.options.graphql?.federation?.enabled === true;
+	const types = await generateClientTypesCore({
+		schema: await buildSchemaFromString(readFileSync(schemaPath, "utf-8"), federation),
+		documents: docs,
+		config: nitro.options.graphql?.codegen?.client,
+		sdkConfig: nitro.options.graphql?.codegen?.clientSDK,
+		options
+	});
+	if (types === false) return;
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	const sdkConfig = getSdkConfig(nitro);
+	const clientPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+	if (clientPath) {
+		writeFile(clientPath, types.types);
+		if (!options.silent) logger.success(`Client types: ${clientPath}`);
+	}
+	const sdkPath = resolveFilePath(sdkConfig.main, sdkConfig.enabled, true, "{clientGraphql}/default/sdk.ts", placeholders);
+	if (sdkPath) {
+		writeFile(sdkPath, types.sdk);
+		if (!options.silent) logger.success(`SDK: ${sdkPath}`);
+	}
+}
+async function generateExternalTypes(nitro, options = {}) {
+	for (const service of nitro.options.graphql?.externalServices || []) try {
+		if (!options.silent) consola.info(`[${service.name}] Processing external service`);
+		await downloadAndSaveSchema(service, nitro.options.buildDir);
+		const schema = await loadExternalSchema(service, nitro.options.buildDir);
+		if (!schema) {
+			consola.warn(`[${service.name}] Failed to load schema`);
+			continue;
+		}
+		const docs = service.documents?.length ? await loadGraphQLDocuments(service.documents).catch(() => []) : [];
+		if (service.documents?.length && !docs.length) {
+			consola.warn(`[${service.name}] No documents found`);
+			continue;
+		}
+		const types = await generateExternalClientTypesCore(service, schema, docs);
+		if (types === false) continue;
+		const placeholders = {
+			...getDefaultPaths(nitro),
+			serviceName: service.name
+		};
+		const typesConfig = getTypesConfig(nitro);
+		const sdkConfig = getSdkConfig(nitro);
+		const typesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", placeholders);
+		if (typesPath) {
+			writeFile(typesPath, types.types);
+			if (!options.silent) consola.success(`[${service.name}] Types: ${typesPath}`);
+		}
+		const sdkPath = resolveFilePath(service.paths?.sdk ?? sdkConfig.external, sdkConfig.enabled, true, "{clientGraphql}/{serviceName}/sdk.ts", placeholders);
+		if (sdkPath) {
+			writeFile(sdkPath, types.sdk);
+			if (!options.silent) consola.success(`[${service.name}] SDK: ${sdkPath}`);
+		}
+	} catch (error) {
+		consola.error(`[${service.name}] External service failed:`, error);
+	}
+}
+
+//#endregion
+export { generateClientTypes, generateServerTypes };

package/dist/nitro/config.d.mts

@@ -0,0 +1,52 @@
+import { NitroGraphQLOptions } from "./types.mjs";
+
+//#region src/nitro/config.d.ts
+
+/**
+ * Default type generation configuration
+ */
+declare const DEFAULT_TYPES_CONFIG: {
+  readonly server: ".graphql/nitro-graphql-server.d.ts";
+  readonly client: ".graphql/nitro-graphql-client.d.ts";
+  readonly enabled: true;
+};
+/**
+ * Default runtime GraphQL configuration
+ */
+declare const DEFAULT_RUNTIME_CONFIG: NitroGraphQLOptions;
+/**
+ * Default ignore patterns for file watching
+ */
+declare const DEFAULT_IGNORE_PATTERNS: string[];
+/**
+ * Default SDK configuration
+ */
+declare const DEFAULT_SDK_CONFIG: {
+  readonly enabled: true;
+  readonly main: true;
+  readonly external: true;
+};
+/**
+ * Default paths configuration
+ * These are used as placeholders and resolved based on framework
+ */
+declare const DEFAULT_PATHS_CONFIG: {
+  readonly serverGraphql: "server/graphql";
+  readonly clientGraphql: null;
+  readonly buildDir: null;
+  readonly typesDir: null;
+};
+/**
+ * Default TypeScript strict mode setting
+ */
+declare const DEFAULT_TYPESCRIPT_STRICT: true;
+/**
+ * Default watcher persistence setting
+ */
+declare const DEFAULT_WATCHER_PERSISTENT: true;
+/**
+ * Default watcher ignore initial setting
+ */
+declare const DEFAULT_WATCHER_IGNORE_INITIAL: true;
+//#endregion
+export { DEFAULT_IGNORE_PATTERNS, DEFAULT_PATHS_CONFIG, DEFAULT_RUNTIME_CONFIG, DEFAULT_SDK_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG, DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT };

package/dist/nitro/config.mjs

@@ -0,0 +1,58 @@
+import { DEFAULT_CLIENT_TYPES_PATH, DEFAULT_SERVER_TYPES_PATH, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH } from "../core/constants.mjs";
+
+//#region src/nitro/config.ts
+/**
+* Default type generation configuration
+*/
+const DEFAULT_TYPES_CONFIG = {
+	server: DEFAULT_SERVER_TYPES_PATH,
+	client: DEFAULT_CLIENT_TYPES_PATH,
+	enabled: true
+};
+/**
+* Default runtime GraphQL configuration
+*/
+const DEFAULT_RUNTIME_CONFIG = {
+	endpoint: {
+		graphql: ENDPOINT_GRAPHQL,
+		healthCheck: ENDPOINT_HEALTH
+	},
+	playground: true
+};
+/**
+* Default ignore patterns for file watching
+*/
+const DEFAULT_IGNORE_PATTERNS = [];
+/**
+* Default SDK configuration
+*/
+const DEFAULT_SDK_CONFIG = {
+	enabled: true,
+	main: true,
+	external: true
+};
+/**
+* Default paths configuration
+* These are used as placeholders and resolved based on framework
+*/
+const DEFAULT_PATHS_CONFIG = {
+	serverGraphql: "server/graphql",
+	clientGraphql: null,
+	buildDir: null,
+	typesDir: null
+};
+/**
+* Default TypeScript strict mode setting
+*/
+const DEFAULT_TYPESCRIPT_STRICT = true;
+/**
+* Default watcher persistence setting
+*/
+const DEFAULT_WATCHER_PERSISTENT = true;
+/**
+* Default watcher ignore initial setting
+*/
+const DEFAULT_WATCHER_IGNORE_INITIAL = true;
+
+//#endregion
+export { DEFAULT_IGNORE_PATTERNS, DEFAULT_PATHS_CONFIG, DEFAULT_RUNTIME_CONFIG, DEFAULT_SDK_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG, DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT };

package/dist/nitro/index.d.mts

@@ -0,0 +1,46 @@
+import { CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, NitroGraphQLOptions, PathsConfig, SdkConfig, SecurityConfig, StandardSchemaV1, TypesConfig } from "./types.mjs";
+import { NitroAdapter } from "./adapter.mjs";
+import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { setupNitroGraphQL } from "./setup.mjs";
+import { NitroModule } from "nitro/types";
+import { Plugin } from "vite";
+
+//#region src/nitro/index.d.ts
+
+/**
+ * Vite plugin to load GraphQL files as strings AND auto-register Nitro module
+ * This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+ * and automatically sets up the nitro-graphql module via the nitro: hook
+ *
+ * @example - Vite usage
+ * ```ts
+ * import { defineConfig } from 'vite'
+ * import { nitro } from 'nitro/vite'
+ * import graphql from 'nitro-graphql'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
+ *     nitro()
+ *   ]
+ * })
+ * ```
+ *
+ *
+ * @example - Nitro direct usage
+ * ```ts
+ *
+ * import graphql from 'nitro-graphql'
+ *
+ * export default defineConfig({
+ *   modules: [
+ *    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
+ *   ]
+ * })
+ * ```
+ */
+declare function graphqlModule(options?: NitroGraphQLOptions): Plugin & {
+  nitro?: NitroModule;
+};
+//#endregion
+export { CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, NitroAdapter, NitroGraphQLOptions, PathsConfig, SdkConfig, SecurityConfig, StandardSchemaV1, TypesConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/index.mjs

@@ -0,0 +1,65 @@
+import { NitroAdapter } from "./adapter.mjs";
+import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { setupNitroGraphQL } from "./setup.mjs";
+import { readFile } from "node:fs/promises";
+import defu from "defu";
+
+//#region src/nitro/index.ts
+/**
+* Vite plugin to load GraphQL files as strings AND auto-register Nitro module
+* This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+* and automatically sets up the nitro-graphql module via the nitro: hook
+*
+* @example - Vite usage
+* ```ts
+* import { defineConfig } from 'vite'
+* import { nitro } from 'nitro/vite'
+* import graphql from 'nitro-graphql'
+*
+* export default defineConfig({
+*   plugins: [
+*     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
+*     nitro()
+*   ]
+* })
+* ```
+*
+*
+* @example - Nitro direct usage
+* ```ts
+*
+* import graphql from 'nitro-graphql'
+*
+* export default defineConfig({
+*   modules: [
+*    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
+*   ]
+* })
+* ```
+*/
+function graphqlModule(options) {
+	return {
+		name: "nitro-graphql",
+		enforce: "pre",
+		async load(id) {
+			if (!/\.(?:graphql|gql)$/i.test(id)) return null;
+			try {
+				const content = await readFile(id, "utf-8");
+				return `export default ${JSON.stringify(content)}`;
+			} catch (error) {
+				if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+				throw error;
+			}
+		},
+		nitro: { async setup(nitro) {
+			if (options) nitro.options.graphql = defu(nitro.options.graphql || {}, options);
+			nitro.options.graphql = nitro.options.graphql || {};
+			nitro.options.graphql._vitePlugin = true;
+			await setupNitroGraphQL(nitro);
+		} }
+	};
+}
+var nitro_default = graphqlModule;
+
+//#endregion
+export { NitroAdapter, nitro_default as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/{utils/path-resolver.d.mts → nitro/paths.d.mts}

@@ -1,7 +1,7 @@
-import { ClientUtilsConfig, FileGenerationConfig, ScaffoldConfig, SdkConfig, TypesConfig } from "../types/index.mjs";
+import { FileGenerationConfig, SdkConfig, TypesConfig } from "./types.mjs";
 import { Nitro } from "nitro/types";
 
-//#region src/utils/path-resolver.d.ts
+//#region src/nitro/paths.d.ts
 
 /**
  * Placeholder values for path resolution
@@ -34,22 +34,6 @@ declare function shouldGenerateFile(config: FileGenerationConfig | undefined, ca
  * Returns: resolved absolute path or null if file should not be generated
  */
 declare function resolveFilePath(config: FileGenerationConfig | undefined, categoryEnabled: boolean | undefined, topLevelEnabled: boolean, defaultPath: string, placeholders: PathPlaceholders): string | null;
-/**
- * Check if scaffold files should be generated (category-level check)
- */
-declare function shouldGenerateScaffold(nitro: Nitro): boolean;
-/**
- * Get scaffold configuration (handles false case)
- */
-declare function getScaffoldConfig(nitro: Nitro): ScaffoldConfig;
-/**
- * Check if client utilities should be generated (category-level check)
- */
-declare function shouldGenerateClientUtils(nitro: Nitro): boolean;
-/**
- * Get client utilities configuration (handles false case)
- */
-declare function getClientUtilsConfig(nitro: Nitro): ClientUtilsConfig;
 /**
  * Check if SDK files should be generated (category-level check)
  */
@@ -67,4 +51,4 @@ declare function shouldGenerateTypes(nitro: Nitro): boolean;
  */
 declare function getTypesConfig(nitro: Nitro): TypesConfig;
 //#endregion
-export { PathPlaceholders, getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateScaffold, shouldGenerateSdk, shouldGenerateTypes };
+export { PathPlaceholders, getDefaultPaths, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateFile, shouldGenerateSdk, shouldGenerateTypes };

package/dist/{utils/path-resolver.mjs → nitro/paths.mjs}

@@ -1,6 +1,6 @@
 import { isAbsolute, resolve } from "pathe";
 
-//#region src/utils/path-resolver.ts
+//#region src/nitro/paths.ts
 /**
 * Replace placeholders in a path string
 * Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverGraphql}, {clientGraphql}
@@ -55,40 +55,6 @@ function resolveFilePath(config, categoryEnabled, topLevelEnabled, defaultPath,
 	return resolve(placeholders.rootDir, resolvedDefault);
 }
 /**
-* Check if scaffold files should be generated (category-level check)
-*/
-function shouldGenerateScaffold(nitro) {
-	const scaffoldConfig = nitro.options.graphql?.scaffold;
-	if (scaffoldConfig === false) return false;
-	if (scaffoldConfig && scaffoldConfig.enabled === false) return false;
-	return true;
-}
-/**
-* Get scaffold configuration (handles false case)
-*/
-function getScaffoldConfig(nitro) {
-	const scaffoldConfig = nitro.options.graphql?.scaffold;
-	if (scaffoldConfig === false) return { enabled: false };
-	return scaffoldConfig || {};
-}
-/**
-* Check if client utilities should be generated (category-level check)
-*/
-function shouldGenerateClientUtils(nitro) {
-	const clientUtilsConfig = nitro.options.graphql?.clientUtils;
-	if (clientUtilsConfig === false) return false;
-	if (clientUtilsConfig && clientUtilsConfig.enabled === false) return false;
-	return true;
-}
-/**
-* Get client utilities configuration (handles false case)
-*/
-function getClientUtilsConfig(nitro) {
-	const clientUtilsConfig = nitro.options.graphql?.clientUtils;
-	if (clientUtilsConfig === false) return { enabled: false };
-	return clientUtilsConfig || {};
-}
-/**
 * Check if SDK files should be generated (category-level check)
 */
 function shouldGenerateSdk(nitro) {
@@ -124,4 +90,4 @@ function getTypesConfig(nitro) {
 }
 
 //#endregion
-export { getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateScaffold, shouldGenerateSdk, shouldGenerateTypes };
+export { getDefaultPaths, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateFile, shouldGenerateSdk, shouldGenerateTypes };

package/dist/{rollup.d.mts → nitro/rollup.d.mts}

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

package/dist/{rollup.mjs → nitro/rollup.mjs}

@@ -1,23 +1,13 @@
-import { generateServerTypes } from "./codegen/server-types.mjs";
-import { generateClientTypes } from "./codegen/index.mjs";
-import { scanGraphql } from "./utils/scanning/schemas.mjs";
-import { virtualGraphQLConfig, virtualModuleConfig } from "./virtual/generators/config.mjs";
-import { virtualDebugInfo } from "./virtual/generators/debug.mjs";
-import { virtualDirectives } from "./virtual/generators/directives.mjs";
-import { virtualResolvers } from "./virtual/generators/resolvers.mjs";
-import { virtualSchemas } from "./virtual/generators/schemas.mjs";
+import { NitroAdapter } from "./adapter.mjs";
+import { generateClientTypes, generateServerTypes } from "./codegen.mjs";
+import { registerAllVirtualModules } from "./virtual/generators.mjs";
 import { readFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
 import { parse } from "graphql";
+import { fileURLToPath } from "node:url";
 
-//#region src/rollup.ts
+//#region src/nitro/rollup.ts
 async function rollupConfig(nitro) {
-	virtualSchemas(nitro);
-	virtualResolvers(nitro);
-	virtualDirectives(nitro);
-	virtualGraphQLConfig(nitro);
-	virtualModuleConfig(nitro);
-	virtualDebugInfo(nitro);
+	registerAllVirtualModules(nitro);
 	nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
 		rollupConfig$1.plugins = rollupConfig$1.plugins || [];
 		const { include = /\.(?:graphql|gql)$/i, exclude, validate = false } = nitro.options.graphql?.loader || {};
@@ -31,12 +21,10 @@ async function rollupConfig(nitro) {
 						if (id.startsWith("#nitro-graphql/")) return `\0virtual:${id}`;
 						if (parent?.startsWith("\0virtual:#nitro-graphql")) {
 							const runtimeDir = fileURLToPath(new URL("routes", import.meta.url));
-							const internalRes = await this.resolve(id, runtimeDir, {
-								skipSelf: true,
-								...options
-							});
-							if (internalRes) return internalRes;
+							const internalRes = await this.resolve(id, runtimeDir, { skipSelf: true });
+							if (internalRes) return internalRes.id;
 						}
+						return null;
 					}
 				},
 				load: {
@@ -90,8 +78,8 @@ async function rollupConfig(nitro) {
 				buildStart: {
 					order: "pre",
 					async handler() {
-						const graphqlFiles = await scanGraphql(nitro);
-						for (const file of graphqlFiles) this.addWatchFile(file);
+						const result = await NitroAdapter.scanGraphql(nitro);
+						for (const file of result.items) this.addWatchFile(file);
 					}
 				}
 			});

package/dist/{routes → nitro/routes}/apollo-server.d.mts

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