nitro-graphql 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/utils/path-resolver.mjs

@@ -0,0 +1,127 @@
+import { isAbsolute, resolve } from "pathe";
+
+//#region src/utils/path-resolver.ts
+/**
+* Replace placeholders in a path string
+* Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverGraphql}, {clientGraphql}
+*/
+function replacePlaceholders(path, placeholders) {
+	return path.replace(/\{serviceName\}/g, placeholders.serviceName || "default").replace(/\{buildDir\}/g, placeholders.buildDir).replace(/\{rootDir\}/g, placeholders.rootDir).replace(/\{framework\}/g, placeholders.framework).replace(/\{typesDir\}/g, placeholders.typesDir).replace(/\{serverGraphql\}/g, placeholders.serverGraphql).replace(/\{clientGraphql\}/g, placeholders.clientGraphql);
+}
+/**
+* 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 pathsConfig = nitro.options.graphql?.paths || {};
+	const defaultServerGraphql = pathsConfig.serverGraphql || resolve(rootDir, "server", "graphql");
+	const defaultClientGraphql = pathsConfig.clientGraphql || resolve(rootDir, isNuxt ? "app/graphql" : "graphql");
+	const defaultBuildDir = pathsConfig.buildDir || buildDir;
+	const defaultTypesDir = pathsConfig.typesDir || resolve(defaultBuildDir, "types");
+	return {
+		serviceName: "default",
+		buildDir: defaultBuildDir,
+		rootDir,
+		framework: isNuxt ? "nuxt" : "nitro",
+		typesDir: defaultTypesDir,
+		serverGraphql: defaultServerGraphql,
+		clientGraphql: defaultClientGraphql
+	};
+}
+/**
+* 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 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) {
+	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 { getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateSDK, shouldGenerateScaffold, shouldGenerateTypes };

package/dist/utils/{server-codegen.d.ts → server-codegen.d.mts}

@@ -1,4 +1,4 @@
-import { NitroGraphQLOptions } from "../types/index.js";
+import { NitroGraphQLOptions } from "../types/index.mjs";
 import { GraphQLSchema } from "graphql";
 
 //#region src/utils/server-codegen.d.ts

package/dist/utils/{server-codegen.js → server-codegen.mjs}

@@ -1,5 +1,5 @@
-import consola from "consola";
 import { defu as defu$1 } from "defu";
+import consola from "consola";
 import { parse } from "graphql";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
 import { codegen } from "@graphql-codegen/core";
@@ -37,7 +37,7 @@ async function generateTypes(selectFremework, schema, config = {}, outputPath) {
 		},
 		defaultScalarType: "unknown",
 		defaultMapper: `ResolverReturnType<{T}>`,
-		contextType: "h3#H3Event",
+		contextType: "nitro/h3#H3Event",
 		maybeValue: "T | null | undefined",
 		inputMaybeValue: "T | undefined",
 		declarationKind: "interface",
@@ -61,7 +61,7 @@ async function generateTypes(selectFremework, schema, config = {}, outputPath) {
 				return {
 					prepend: [
 						`import schemas from '#graphql/schema'`,
-						`import type { StandardSchemaV1 } from 'nitro-graphql'`,
+						`import type { StandardSchemaV1 } from 'nitro-graphql/types'`,
 						`
 export interface NPMConfig {
   framework: '${selectFremework || "graphql-yoga"}';

package/dist/utils/type-generation.d.mts

@@ -0,0 +1,12 @@
+import { Nitro } from "nitro/types";
+
+//#region src/utils/type-generation.d.ts
+declare function serverTypeGeneration(app: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+declare function clientTypeGeneration(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
+//#endregion
+export { clientTypeGeneration, serverTypeGeneration };

package/dist/utils/type-generation.mjs

@@ -0,0 +1,420 @@
+import { downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes, loadExternalSchema, loadGraphQLDocuments } from "./client-codegen.mjs";
+import { writeFileIfNotExists } from "./file-generator.mjs";
+import { getClientUtilsConfig, getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldGenerateClientUtils, shouldGenerateTypes } from "./path-resolver.mjs";
+import { generateTypes } from "./server-codegen.mjs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import consola from "consola";
+import { basename, dirname, join, resolve } from "pathe";
+import { buildSchema, parse } from "graphql";
+import { loadFilesSync } from "@graphql-tools/load-files";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+
+//#region src/utils/type-generation.ts
+const logger = consola.withTag("nitro-graphql");
+let buildSubgraphSchema = null;
+async function loadFederationSupport() {
+	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
+	try {
+		buildSubgraphSchema = (await import("@apollo/subgraph")).buildSubgraphSchema;
+	} catch {
+		buildSubgraphSchema = false;
+	}
+	return buildSubgraphSchema;
+}
+function generateGraphQLIndexFile(nitro, clientDir, externalServices = []) {
+	if (!shouldGenerateClientUtils(nitro)) return;
+	const placeholders = getDefaultPaths(nitro);
+	const clientUtilsConfig = getClientUtilsConfig(nitro);
+	const indexPath = resolveFilePath(clientUtilsConfig.index, clientUtilsConfig.enabled, true, "{clientGraphql}/index.ts", placeholders);
+	if (!indexPath) return;
+	if (!existsSync(indexPath)) {
+		let indexContent = `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+//
+// Export your main GraphQL service (auto-generated)
+export * from './default/ofetch'
+
+// Export external GraphQL services (auto-generated for existing services)
+// When you add new external services, don't forget to add their exports here:
+// export * from './yourServiceName/ofetch'
+`;
+		for (const service of externalServices) indexContent += `export * from './${service.name}/ofetch'\n`;
+		writeFileIfNotExists(indexPath, indexContent, "client index.ts");
+	}
+}
+function generateNuxtOfetchClient(nitro, clientDir, serviceName = "default") {
+	if (!shouldGenerateClientUtils(nitro)) return;
+	const placeholders = {
+		...getDefaultPaths(nitro),
+		serviceName
+	};
+	const clientUtilsConfig = getClientUtilsConfig(nitro);
+	const ofetchPath = resolveFilePath(clientUtilsConfig.ofetch, clientUtilsConfig.enabled, true, "{clientGraphql}/{serviceName}/ofetch.ts", placeholders);
+	if (!ofetchPath) return;
+	const serviceDir = dirname(ofetchPath);
+	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
+	if (existsSync(ofetchPath)) return;
+	writeFileIfNotExists(ofetchPath, nitro.options.framework?.name === "nuxt" ? `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Requester } from './sdk'
+import { getSdk } from './sdk'
+
+export function createGraphQLClient(endpoint: string): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const headers = import.meta.server ? useRequestHeaders() : undefined
+
+    const result = await $fetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $sdk = getSdk(createGraphQLClient('/api/graphql'))` : `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Requester } from './sdk'
+import { ofetch } from 'ofetch'
+import { getSdk } from './sdk'
+
+export function createGraphQLClient(endpoint: string): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const result = await ofetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $sdk = getSdk(createGraphQLClient('/api/graphql'))`, `${serviceName} ofetch.ts`);
+}
+function generateExternalOfetchClient(nitro, service, endpoint) {
+	if (!shouldGenerateClientUtils(nitro)) return;
+	const serviceName = service.name;
+	const placeholders = {
+		...getDefaultPaths(nitro),
+		serviceName
+	};
+	const clientUtilsConfig = getClientUtilsConfig(nitro);
+	const ofetchPath = resolveFilePath(service.paths?.ofetch ?? clientUtilsConfig.ofetch, clientUtilsConfig.enabled, true, "{clientGraphql}/{serviceName}/ofetch.ts", placeholders);
+	if (!ofetchPath) return;
+	const serviceDir = dirname(ofetchPath);
+	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
+	if (!existsSync(ofetchPath)) {
+		const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
+		writeFileIfNotExists(ofetchPath, nitro.options.framework?.name === "nuxt" ? `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Sdk, Requester } from './sdk'
+import { getSdk } from './sdk'
+
+export function create${capitalizedServiceName}GraphQLClient(endpoint: string = '${endpoint}'): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const headers = import.meta.server ? useRequestHeaders() : undefined
+
+    const result = await $fetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedServiceName}GraphQLClient())` : `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Sdk, Requester } from './sdk'
+import { ofetch } from 'ofetch'
+import { getSdk } from './sdk'
+
+export function create${capitalizedServiceName}GraphQLClient(endpoint: string = '${endpoint}'): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const result = await ofetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedServiceName}GraphQLClient())`, `${serviceName} external ofetch.ts`);
+	}
+}
+/**
+* Check for duplicate type definitions using a simpler approach
+* Try to build each schema individually - if that succeeds but merging fails, we have duplicates
+* @returns true if validation passes, false if duplicates found
+*/
+function validateNoDuplicateTypes(schemas, schemaStrings) {
+	const individualSchemasByFile = /* @__PURE__ */ new Map();
+	schemaStrings.forEach((schemaContent, index) => {
+		const schemaPath = schemas[index];
+		const fileName = basename(schemaPath);
+		try {
+			parse(schemaContent);
+			individualSchemasByFile.set(fileName, schemaContent);
+		} catch (error) {
+			consola.warn(`Invalid GraphQL syntax in ${fileName}:`, error);
+			throw error;
+		}
+	});
+	try {
+		mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: false,
+			commentDescriptions: true,
+			sort: true
+		});
+		mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+	} catch (conflictError) {
+		if (conflictError?.message?.includes("already defined with a different type")) throw conflictError;
+	}
+	const typeNames = /* @__PURE__ */ new Set();
+	const duplicateTypes = [];
+	schemaStrings.forEach((schemaContent, index) => {
+		const fileName = basename(schemas[index]);
+		try {
+			parse(schemaContent).definitions.forEach((def) => {
+				if (def.kind === "ObjectTypeDefinition" || def.kind === "InterfaceTypeDefinition" || def.kind === "UnionTypeDefinition" || def.kind === "EnumTypeDefinition" || def.kind === "InputObjectTypeDefinition" || def.kind === "ScalarTypeDefinition") {
+					const typeName = def.name.value;
+					if ([
+						"String",
+						"Int",
+						"Float",
+						"Boolean",
+						"ID",
+						"DateTime",
+						"JSON"
+					].includes(typeName)) return;
+					if (typeNames.has(typeName)) {
+						const existing = duplicateTypes.find((d) => d.type === typeName);
+						if (existing) existing.files.push(fileName);
+						else {
+							const firstFile = schemas.find((_, i) => {
+								const content = schemaStrings[i];
+								if (!content) return false;
+								try {
+									return parse(content).definitions.some((d) => (d.kind === "ObjectTypeDefinition" || d.kind === "InterfaceTypeDefinition" || d.kind === "UnionTypeDefinition" || d.kind === "EnumTypeDefinition" || d.kind === "InputObjectTypeDefinition" || d.kind === "ScalarTypeDefinition") && d.name.value === typeName);
+								} catch {
+									return false;
+								}
+							});
+							duplicateTypes.push({
+								type: typeName,
+								files: [basename(firstFile || ""), fileName]
+							});
+						}
+					} else typeNames.add(typeName);
+				}
+			});
+		} catch {}
+	});
+	if (duplicateTypes.length > 0) {
+		let errorMessage = "⚠️  DUPLICATE TYPE DEFINITIONS DETECTED!\n\n";
+		duplicateTypes.forEach(({ type, files }) => {
+			errorMessage += `❌ Type "${type}" is defined in multiple files:\n`;
+			files.forEach((fileName) => {
+				const fullPath = schemas.find((path) => basename(path) === fileName) || fileName;
+				errorMessage += `   • ${fullPath}\n`;
+			});
+			errorMessage += "\n";
+		});
+		errorMessage += "💡 Each GraphQL type should only be defined once.\n";
+		errorMessage += "   Consider using \"extend type\" syntax instead of duplicate definitions.\n";
+		errorMessage += `\n🔍 Found ${duplicateTypes.length} duplicate type(s): ${duplicateTypes.map((d) => d.type).join(", ")}`;
+		consola.error(errorMessage);
+		return false;
+	}
+	return true;
+}
+async function serverTypeGeneration(app, options = {}) {
+	try {
+		if (!shouldGenerateTypes(app)) {
+			logger.debug("Server type generation is disabled");
+			return;
+		}
+		const schemas = app.scanSchemas || [];
+		if (!schemas.length) {
+			if (!options.silent) consola.info("No GraphQL definitions found for server type generation.");
+			return;
+		}
+		const schemaStrings = loadFilesSync(schemas).map((schema$1) => typeof schema$1 === "string" ? schema$1 : schema$1.loc?.source?.body || "").filter(Boolean);
+		if (!validateNoDuplicateTypes(schemas, schemaStrings)) return;
+		const federationEnabled = app.options.graphql?.federation?.enabled === true;
+		const mergedSchemas = mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+		let schema;
+		if (federationEnabled) {
+			const buildSubgraph = await loadFederationSupport();
+			if (!buildSubgraph) throw new Error("Federation is enabled but @apollo/subgraph is not installed. Run: pnpm add @apollo/subgraph");
+			schema = buildSubgraph([{ typeDefs: parse(mergedSchemas) }]);
+		} else schema = buildSchema(mergedSchemas);
+		const data = await generateTypes(app.options.graphql?.framework || "graphql-yoga", schema, app.options.graphql ?? {});
+		const printSchema = printSchemaWithDirectives(schema);
+		const schemaPath = resolve(app.graphql.buildDir, "schema.graphql");
+		mkdirSync(dirname(schemaPath), { recursive: true });
+		writeFileSync(schemaPath, printSchema, "utf-8");
+		const placeholders = getDefaultPaths(app);
+		const typesConfig = getTypesConfig(app);
+		const serverTypesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+		if (serverTypesPath) {
+			mkdirSync(dirname(serverTypesPath), { recursive: true });
+			writeFileSync(serverTypesPath, data, "utf-8");
+			if (!options.silent) logger.success(`Generated server types at: ${serverTypesPath}`);
+		}
+	} catch (error) {
+		logger.error("Server schema generation error:", error);
+	}
+}
+async function clientTypeGeneration(nitro, options = {}) {
+	try {
+		if (nitro.scanSchemas && nitro.scanSchemas.length > 0) await generateMainClientTypes(nitro, options);
+		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro, options);
+	} catch (error) {
+		logger.error("Client schema generation error:", error);
+	}
+}
+/**
+* Check for old structure files and warn user about manual migration
+*/
+function checkOldStructure(clientDir) {
+	const oldOfetchPath = resolve(clientDir, "ofetch.ts");
+	const oldSdkPath = resolve(clientDir, "sdk.ts");
+	if (existsSync(oldOfetchPath) || existsSync(oldSdkPath)) {
+		const foundFiles = [];
+		if (existsSync(oldOfetchPath)) foundFiles.push("app/graphql/ofetch.ts");
+		if (existsSync(oldSdkPath)) foundFiles.push("app/graphql/sdk.ts");
+		consola.error(`⚠️  OLD GRAPHQL STRUCTURE DETECTED!
+
+📁 Found old files in app/graphql/ directory that need to be moved:
+   • ${foundFiles.join("\n   • ")}
+
+🔄 Please manually move these files to the new structure:
+   • app/graphql/ofetch.ts → app/graphql/default/ofetch.ts
+   • app/graphql/sdk.ts → app/graphql/default/sdk.ts
+
+📝 Also update your app/graphql/index.ts to include:
+   export * from './default/ofetch'
+
+💡 After moving, update your imports to use:
+   import { $sdk } from "#graphql/client"
+
+🚫 The old files will cause import conflicts until moved!`);
+	}
+}
+async function generateMainClientTypes(nitro, options = {}) {
+	checkOldStructure(nitro.graphql.clientDir);
+	const docs = nitro.scanDocuments;
+	const loadDocs = await loadGraphQLDocuments(docs);
+	const schemaFilePath = join(nitro.graphql.buildDir, "schema.graphql");
+	if (!existsSync(schemaFilePath)) {
+		if (!options.silent) consola.info("Schema file not ready yet for client type generation. Server types need to be generated first.");
+		return;
+	}
+	const graphqlString = readFileSync(schemaFilePath, "utf-8");
+	const federationEnabled = nitro.options.graphql?.federation?.enabled === true;
+	let schema;
+	if (federationEnabled) {
+		const buildSubgraph = await loadFederationSupport();
+		if (!buildSubgraph) throw new Error("Federation is enabled but @apollo/subgraph is not installed. Run: pnpm add @apollo/subgraph");
+		schema = buildSubgraph([{ typeDefs: parse(graphqlString) }]);
+	} else schema = buildSchema(graphqlString);
+	const types = await generateClientTypes(schema, loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {}, void 0, void 0, void 0, options);
+	if (types === false) return;
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	const sdkConfig = getSdkConfig(nitro);
+	const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+	if (clientTypesPath) {
+		mkdirSync(dirname(clientTypesPath), { recursive: true });
+		writeFileSync(clientTypesPath, types.types, "utf-8");
+		if (!options.silent) logger.success(`Generated client types at: ${clientTypesPath}`);
+	}
+	const sdkPath = resolveFilePath(sdkConfig.main, sdkConfig.enabled, true, "{clientGraphql}/default/sdk.ts", placeholders);
+	if (sdkPath) {
+		mkdirSync(dirname(sdkPath), { recursive: true });
+		writeFileSync(sdkPath, types.sdk, "utf-8");
+		if (!options.silent) logger.success(`Generated SDK at: ${sdkPath}`);
+	}
+	generateNuxtOfetchClient(nitro, nitro.graphql.clientDir, "default");
+	const externalServices = nitro.options.graphql?.externalServices || [];
+	if (externalServices.length > 0) generateGraphQLIndexFile(nitro, nitro.graphql.clientDir, externalServices);
+}
+async function generateExternalServicesTypes(nitro, options = {}) {
+	const externalServices = nitro.options.graphql?.externalServices || [];
+	for (const service of externalServices) try {
+		if (!options.silent) consola.info(`[graphql:${service.name}] Processing external service`);
+		await downloadAndSaveSchema(service, nitro.options.buildDir);
+		const schema = await loadExternalSchema(service, nitro.options.buildDir);
+		if (!schema) {
+			consola.warn(`[graphql:${service.name}] Failed to load schema, skipping`);
+			continue;
+		}
+		const documentPatterns = service.documents || [];
+		let loadDocs = [];
+		if (documentPatterns.length > 0) try {
+			loadDocs = await loadGraphQLDocuments(documentPatterns);
+			if (!loadDocs || loadDocs.length === 0) {
+				consola.warn(`[graphql:${service.name}] No GraphQL documents found, skipping service generation`);
+				continue;
+			}
+		} catch (error) {
+			consola.warn(`[graphql:${service.name}] No documents found, skipping service generation:`, error);
+			continue;
+		}
+		const types = await generateExternalClientTypes(service, schema, loadDocs);
+		if (types === false) {
+			consola.warn(`[graphql:${service.name}] Type generation failed`);
+			continue;
+		}
+		const placeholders = {
+			...getDefaultPaths(nitro),
+			serviceName: service.name
+		};
+		const typesConfig = getTypesConfig(nitro);
+		const sdkConfig = getSdkConfig(nitro);
+		const serviceTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", placeholders);
+		if (serviceTypesPath) {
+			mkdirSync(dirname(serviceTypesPath), { recursive: true });
+			writeFileSync(serviceTypesPath, types.types, "utf-8");
+			if (!options.silent) consola.success(`[graphql:${service.name}] Generated types at: ${serviceTypesPath}`);
+		}
+		const serviceSdkPath = resolveFilePath(service.paths?.sdk ?? sdkConfig.external, sdkConfig.enabled, true, "{clientGraphql}/{serviceName}/sdk.ts", placeholders);
+		if (serviceSdkPath) {
+			mkdirSync(dirname(serviceSdkPath), { recursive: true });
+			writeFileSync(serviceSdkPath, types.sdk, "utf-8");
+			if (!options.silent) consola.success(`[graphql:${service.name}] Generated SDK at: ${serviceSdkPath}`);
+		}
+		generateExternalOfetchClient(nitro, service, service.endpoint);
+		if (!options.silent) consola.success(`[graphql:${service.name}] External service types generated successfully`);
+	} catch (error) {
+		consola.error(`[graphql:${service.name}] External service generation failed:`, error);
+	}
+}
+
+//#endregion
+export { clientTypeGeneration, serverTypeGeneration };

package/dist/virtual/debug-info.d.mts

@@ -0,0 +1,9 @@
+//#region src/virtual/debug-info.d.ts
+/**
+ * Virtual module stub for #nitro-graphql/debug-info
+ * This file is only used during build/bundling to prevent import resolution errors.
+ * At runtime, Nitro will override this with the actual virtual module.
+ */
+declare const debugInfo: Record<string, any>;
+//#endregion
+export { debugInfo };

package/dist/virtual/debug-info.mjs

@@ -0,0 +1,26 @@
+//#region src/virtual/debug-info.ts
+/**
+* Virtual module stub for #nitro-graphql/debug-info
+* This file is only used during build/bundling to prevent import resolution errors.
+* At runtime, Nitro will override this with the actual virtual module.
+*/
+const debugInfo = {
+	isDev: false,
+	framework: "",
+	graphqlFramework: "",
+	federation: {},
+	scanned: {
+		schemas: 0,
+		schemaFiles: [],
+		resolvers: 0,
+		resolverFiles: [],
+		directives: 0,
+		directiveFiles: [],
+		documents: 0,
+		documentFiles: []
+	},
+	virtualModules: {}
+};
+
+//#endregion
+export { debugInfo };

package/dist/virtual/graphql-config.d.mts

@@ -0,0 +1,9 @@
+//#region src/virtual/graphql-config.d.ts
+/**
+ * Virtual module stub for #nitro-graphql/graphql-config
+ * This file is only used during build/bundling to prevent import resolution errors.
+ * At runtime, Nitro will override this with the actual virtual module.
+ */
+declare const importedConfig: {};
+//#endregion
+export { importedConfig };

package/dist/virtual/graphql-config.mjs

@@ -0,0 +1,10 @@
+//#region src/virtual/graphql-config.ts
+/**
+* Virtual module stub for #nitro-graphql/graphql-config
+* This file is only used during build/bundling to prevent import resolution errors.
+* At runtime, Nitro will override this with the actual virtual module.
+*/
+const importedConfig = {};
+
+//#endregion
+export { importedConfig };

package/dist/virtual/module-config.d.mts

@@ -0,0 +1,9 @@
+//#region src/virtual/module-config.d.ts
+/**
+ * Virtual module stub for #nitro-graphql/module-config
+ * This file is only used during build/bundling to prevent import resolution errors.
+ * At runtime, Nitro will override this with the actual virtual module.
+ */
+declare const moduleConfig: Record<string, any>;
+//#endregion
+export { moduleConfig };

package/dist/virtual/module-config.mjs

@@ -0,0 +1,10 @@
+//#region src/virtual/module-config.ts
+/**
+* Virtual module stub for #nitro-graphql/module-config
+* This file is only used during build/bundling to prevent import resolution errors.
+* At runtime, Nitro will override this with the actual virtual module.
+*/
+const moduleConfig = {};
+
+//#endregion
+export { moduleConfig };