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

package/dist/rollup.js

@@ -1,114 +0,0 @@
-import { getImportId, scanGraphql } from "./utils/index.js";
-import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
-import { resolve } from "pathe";
-import { readFile } from "node:fs/promises";
-import { parse } from "graphql";
-import { genImport } from "knitwork";
-
-//#region src/rollup.ts
-async function rollupConfig(app) {
-	virtualSchemas(app);
-	virtualResolvers(app);
-	virtualDirectives(app);
-	getGraphQLConfig(app);
-	virtualModuleConfig(app);
-	app.hooks.hook("rollup:before", (nitro, rollupConfig$1) => {
-		rollupConfig$1.plugins = rollupConfig$1.plugins || [];
-		const { include = /\.(graphql|gql)$/i, exclude, validate = false } = app.options.graphql?.loader || {};
-		if (Array.isArray(rollupConfig$1.plugins)) {
-			rollupConfig$1.plugins.push({
-				name: "nitro-graphql",
-				async load(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}`);
-					}
-				}
-			});
-			rollupConfig$1.plugins.push({
-				name: "nitro-graphql-watcher",
-				async buildStart() {
-					const graphqlFiles = await scanGraphql(nitro);
-					for (const file of graphqlFiles) this.addWatchFile(file);
-				}
-			});
-		}
-	});
-	app.hooks.hook("dev:reload", async () => {
-		await serverTypeGeneration(app);
-		await clientTypeGeneration(app);
-	});
-}
-function virtualSchemas(app) {
-	const getSchemas = () => [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/server-schemas"] = () => {
-		const imports = getSchemas();
-		return `
-${imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`).join("\n")}
-
-export const schemas = [
-${imports.map((h) => `{ def: ${getImportId(h)} }`).join(",\n")}
-];
-    `;
-	};
-}
-function virtualResolvers(app) {
-	const getResolvers = () => [...app.scanResolvers];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/server-resolvers"] = () => {
-		const imports = getResolvers();
-		const importsContent = imports.map(({ specifier, imports: imports$1, options }) => genImport(specifier, imports$1, options));
-		const data = imports.map(({ imports: imports$1 }) => imports$1.map((i) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
-		return [
-			...importsContent,
-			"export const resolvers = [",
-			data,
-			"]",
-			""
-		].join("\n");
-	};
-}
-function virtualDirectives(app) {
-	const getDirectives = () => app.scanDirectives || [];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/server-directives"] = () => {
-		const imports = getDirectives();
-		const importsContent = imports.map(({ specifier, imports: imports$1, options }) => genImport(specifier, imports$1, options));
-		const data = imports.map(({ imports: imports$1 }) => imports$1.map((i) => `{ directive: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
-		return [
-			...importsContent,
-			"export const directives = [",
-			data,
-			"]",
-			""
-		].join("\n");
-	};
-}
-function getGraphQLConfig(app) {
-	const configPath = resolve(app.graphql.serverDir, "config.ts");
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/graphql-config"] = () => {
-		return `import config from '${configPath}'
-const importedConfig = config
-export { importedConfig }
-`;
-	};
-}
-function virtualModuleConfig(app) {
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/module-config"] = () => {
-		const moduleConfig = app.options.graphql || {};
-		return `export const moduleConfig = ${JSON.stringify(moduleConfig, null, 2)};`;
-	};
-}
-
-//#endregion
-export { rollupConfig };

package/dist/routes/apollo-server.d.ts

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

package/dist/routes/graphql-yoga.d.ts

@@ -1,6 +0,0 @@
-import * as h33 from "h3";
-
-//#region src/routes/graphql-yoga.d.ts
-declare const _default: h33.EventHandler<h33.EventHandlerRequest, unknown>;
-//#endregion
-export { _default as default };

package/dist/routes/health.d.ts

@@ -1,6 +0,0 @@
-import * as h31 from "h3";
-
-//#region src/routes/health.d.ts
-declare const _default: h31.EventHandler<h31.EventHandlerRequest, unknown>;
-//#endregion
-export { _default as default };

package/dist/types/index.d.ts

@@ -1,128 +0,0 @@
-import { StandardSchemaV1 } from "./standard-schema.js";
-import { ESMCodeGenOptions } from "knitwork";
-import { IResolvers } from "@graphql-tools/utils";
-import { TypeScriptPluginConfig } from "@graphql-codegen/typescript";
-import { plugin as plugin$1 } from "@graphql-codegen/typescript-generic-sdk";
-import { TypeScriptDocumentsPluginConfig } from "@graphql-codegen/typescript-operations";
-import { TypeScriptResolversPluginConfig } from "@graphql-codegen/typescript-resolvers";
-
-//#region src/types/index.d.ts
-type CodegenServerConfig = TypeScriptPluginConfig & TypeScriptResolversPluginConfig;
-type DocumentModeConfig = Pick<Parameters<typeof plugin$1>[2], 'documentMode'>;
-type DocumentModeEnum = NonNullable<DocumentModeConfig['documentMode']>;
-type DocumentModeType = `${DocumentModeEnum}`;
-type GenericSdkConfig = Omit<Parameters<typeof plugin$1>[2], 'documentMode'> & {
-  documentMode?: DocumentModeType;
-};
-type CodegenClientConfig = TypeScriptPluginConfig & TypeScriptDocumentsPluginConfig & {
-  endpoint?: string;
-};
-interface IESMImport {
-  name: string;
-  as?: string;
-  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription' | 'directive';
-}
-interface GenImport {
-  specifier: string;
-  imports: IESMImport[];
-  options?: ESMCodeGenOptions;
-}
-declare module 'nitro/types' {
-  interface Nitro {
-    scanSchemas: string[];
-    scanDocuments: string[];
-    scanResolvers: GenImport[];
-    scanDirectives: GenImport[];
-    graphql: {
-      buildDir: string;
-      watchDirs: string[];
-      clientDir: string;
-      serverDir: string;
-      dir: {
-        build: string;
-        client: string;
-        server: string;
-      };
-    };
-  }
-}
-declare module 'nitro/types' {
-  interface NitroOptions {
-    graphql?: NitroGraphQLOptions;
-  }
-  interface NitroRuntimeConfig {
-    graphql?: NitroGraphQLOptions;
-  }
-  interface NitroConfig {
-    graphql?: NitroGraphQLOptions;
-  }
-}
-interface ExternalGraphQLService {
-  /** Unique name for this service (used for file naming and type generation) */
-  name: string;
-  /** Schema source - can be URL(s) for remote schemas or file path(s) for local schemas */
-  schema: string | string[];
-  /** GraphQL endpoint for this service */
-  endpoint: string;
-  /** Optional headers for schema introspection and client requests */
-  headers?: Record<string, string> | (() => Record<string, string>);
-  /** Optional: specific document patterns for this service */
-  documents?: string[];
-  /**
-   * Optional: Download and cache schema locally for offline usage
-   * - true or 'once': Download if file doesn't exist, then use cached version (offline-friendly)
-   * - 'always': Check for updates on every build (current behavior)
-   * - 'manual': Never download automatically, user manages schema files manually
-   * - false: Disable schema downloading
-   */
-  downloadSchema?: boolean | 'once' | 'always' | 'manual';
-  /** Optional: Custom path to save downloaded schema (default: .nitro/graphql/schemas/[serviceName].graphql) */
-  downloadPath?: string;
-  /** Optional: service-specific codegen configuration */
-  codegen?: {
-    client?: CodegenClientConfig;
-    clientSDK?: GenericSdkConfig;
-  };
-}
-interface FederationConfig {
-  /** Enable Apollo Federation subgraph support */
-  enabled: boolean;
-  /** Service name for federation (used in subgraph config) */
-  serviceName?: string;
-  /** Service version for federation */
-  serviceVersion?: string;
-  /** Service URL for federation gateway */
-  serviceUrl?: string;
-}
-interface NitroGraphQLOptions {
-  framework: 'graphql-yoga' | 'apollo-server';
-  endpoint?: {
-    graphql?: string;
-    healthCheck?: string;
-  };
-  playground?: boolean;
-  typedefs?: string[];
-  resolvers?: Array<IResolvers<any, any>>;
-  loader?: {
-    include?: RegExp;
-    exclude?: RegExp;
-    validate?: boolean;
-  };
-  codegen?: {
-    server?: CodegenServerConfig;
-    client?: CodegenClientConfig;
-    clientSDK?: GenericSdkConfig;
-  };
-  /** External GraphQL services to generate types and SDKs for */
-  externalServices?: ExternalGraphQLService[];
-  /** Apollo Federation configuration */
-  federation?: FederationConfig;
-  /** Server GraphQL directory path */
-  serverDir?: string;
-  /** Layer directories (populated by Nuxt module) */
-  layerDirectories?: string[];
-  layerServerDirs?: string[];
-  layerAppDirs?: string[];
-}
-//#endregion
-export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions };

package/dist/utils/apollo.js

@@ -1,61 +0,0 @@
-import { HeaderMap } from "@apollo/server";
-import { eventHandler, getHeaders, isMethod, readBody, setHeaders } from "h3";
-
-//#region src/utils/apollo.ts
-function startServerAndCreateH3Handler(server, options) {
-	const defaultContext = () => Promise.resolve({});
-	const contextFunction = options?.context ?? defaultContext;
-	return eventHandler({
-		handler: async (event) => {
-			const apolloServer = typeof server === "function" ? server() : server;
-			if (!options?.serverAlreadyStarted) apolloServer.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
-			if (isMethod(event, "OPTIONS")) return null;
-			try {
-				const graphqlRequest = await toGraphqlRequest(event);
-				const { body, headers, status } = await apolloServer.executeHTTPGraphQLRequest({
-					httpGraphQLRequest: graphqlRequest,
-					context: () => contextFunction({ event })
-				});
-				if (body.kind === "chunked") throw new Error("Incremental delivery not implemented");
-				setHeaders(event, Object.fromEntries(headers));
-				event.res.statusCode = status || 200;
-				return body.string;
-			} catch (error) {
-				if (error instanceof SyntaxError) {
-					event.res.statusCode = 400;
-					return error.message;
-				} else throw error;
-			}
-		},
-		websocket: options?.websocket
-	});
-}
-async function toGraphqlRequest(event) {
-	return {
-		method: event.req.method || "POST",
-		headers: normalizeHeaders(getHeaders(event)),
-		search: normalizeQueryString(event.req.url),
-		body: await normalizeBody(event)
-	};
-}
-function normalizeHeaders(headers) {
-	const headerMap = new HeaderMap();
-	for (const [key, value] of Object.entries(headers)) if (Array.isArray(value)) headerMap.set(key, value.join(","));
-	else if (value) headerMap.set(key, value);
-	return headerMap;
-}
-function normalizeQueryString(url) {
-	if (!url) return "";
-	return url.split("?")[1] || "";
-}
-async function normalizeBody(event) {
-	if (isMethod(event, [
-		"PATCH",
-		"POST",
-		"PUT",
-		"DELETE"
-	])) return await readBody(event);
-}
-
-//#endregion
-export { startServerAndCreateH3Handler };

package/dist/utils/define.js

@@ -1,57 +0,0 @@
-//#region src/utils/define.ts
-function defineSchema(config) {
-	return config;
-}
-function defineResolver(resolvers) {
-	return resolvers;
-}
-function defineQuery(resolvers = {}) {
-	return { Query: { ...resolvers } };
-}
-function defineMutation(resolvers = {}) {
-	return { Mutation: { ...resolvers } };
-}
-function defineSubscription(resolvers = {}) {
-	return { Subscription: { ...resolvers } };
-}
-function defineType(resolvers) {
-	return resolvers;
-}
-function defineGraphQLConfig(config) {
-	return config;
-}
-/**
-* Helper function to create directive arguments with proper type inference
-* @example
-* args: {
-*   myArg: arg('String!', { defaultValue: 'hello' })
-* }
-*/
-function arg(type, options) {
-	return {
-		type,
-		...options
-	};
-}
-function defineDirective(config) {
-	const args = config.args ? Object.entries(config.args).map(([name, arg$1]) => {
-		const defaultValue = arg$1.defaultValue !== void 0 ? ` = ${JSON.stringify(arg$1.defaultValue)}` : "";
-		return `${name}: ${arg$1.type}${defaultValue}`;
-	}).join(", ") : "";
-	const argsString = args ? `(${args})` : "";
-	const locations = config.locations.join(" | ");
-	const schemaDefinition = `directive @${config.name}${argsString} on ${locations}`;
-	Object.defineProperty(config, "__schema", {
-		value: schemaDefinition,
-		enumerable: false,
-		configurable: false,
-		writable: false
-	});
-	return {
-		...config,
-		locations: [...config.locations]
-	};
-}
-
-//#endregion
-export { arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

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

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

package/dist/utils/type-generation.js

@@ -1,287 +0,0 @@
-import { downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes, loadExternalSchema, loadGraphQLDocuments } from "./client-codegen.js";
-import { generateTypes } from "./server-codegen.js";
-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 { buildSubgraphSchema } from "@apollo/subgraph";
-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
-function generateGraphQLIndexFile(clientDir, externalServices = []) {
-	const indexPath = resolve(clientDir, "index.ts");
-	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`;
-		writeFileSync(indexPath, indexContent, "utf-8");
-	}
-}
-function generateOfetchClient(clientDir, serviceName, endpoint, isDefault = false) {
-	const serviceDir = resolve(clientDir, serviceName);
-	const ofetchPath = resolve(serviceDir, "ofetch.ts");
-	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
-	if (existsSync(ofetchPath)) return;
-	const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
-	const functionName = isDefault ? "createGraphQLClient" : `create${capitalizedServiceName}GraphQLClient`;
-	const exportName = isDefault ? "$sdk" : `$${serviceName}Sdk`;
-	writeFileSync(ofetchPath, `// This file is auto-generated once by nitro-graphql for quick start
-// You can modify this file according to your needs
-import type { ${isDefault ? "Requester" : "Sdk, Requester"} } from './sdk'
-import { getSdk } from './sdk'
-
-export function ${functionName}(endpoint: string${isDefault ? "" : ` = '${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 ${exportName}${isDefault ? "" : ": Sdk"} = getSdk(${functionName}(${isDefault ? "'/api/graphql'" : ""}))`, "utf-8");
-}
-/**
-* 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) {
-	try {
-		const schemas = app.scanSchemas || [];
-		if (!schemas.length) {
-			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
-		});
-		const schema = federationEnabled ? buildSubgraphSchema([{ typeDefs: parse(mergedSchemas) }]) : 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 serverTypesPath = resolve(app.options.buildDir, "types", "nitro-graphql-server.d.ts");
-		mkdirSync(dirname(serverTypesPath), { recursive: true });
-		writeFileSync(serverTypesPath, data, "utf-8");
-	} catch (error) {
-		consola.error("Server schema generation error:", error);
-	}
-}
-async function clientTypeGeneration(nitro) {
-	try {
-		if (nitro.scanSchemas && nitro.scanSchemas.length > 0) await generateMainClientTypes(nitro);
-		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro);
-	} catch (error) {
-		consola.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) {
-	checkOldStructure(nitro.graphql.clientDir);
-	const docs = nitro.scanDocuments;
-	const loadDocs = await loadGraphQLDocuments(docs);
-	const schemaFilePath = join(nitro.graphql.buildDir, "schema.graphql");
-	if (!existsSync(schemaFilePath)) {
-		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 types = await generateClientTypes(nitro.options.graphql?.federation?.enabled === true ? buildSubgraphSchema([{ typeDefs: parse(graphqlString) }]) : buildSchema(graphqlString), loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {});
-	if (types === false) return;
-	const clientTypesPath = resolve(nitro.options.buildDir, "types", "nitro-graphql-client.d.ts");
-	const defaultServiceDir = resolve(nitro.graphql.clientDir, "default");
-	const sdkTypesPath = resolve(defaultServiceDir, "sdk.ts");
-	mkdirSync(dirname(clientTypesPath), { recursive: true });
-	writeFileSync(clientTypesPath, types.types, "utf-8");
-	mkdirSync(defaultServiceDir, { recursive: true });
-	let shouldWriteSdk = true;
-	if (existsSync(sdkTypesPath)) shouldWriteSdk = readFileSync(sdkTypesPath, "utf-8") !== types.sdk;
-	if (shouldWriteSdk) writeFileSync(sdkTypesPath, types.sdk, "utf-8");
-	if (nitro.options.framework?.name === "nuxt") {
-		generateOfetchClient(nitro.graphql.clientDir, "default", "/api/graphql", true);
-		const externalServices = nitro.options.graphql?.externalServices || [];
-		generateGraphQLIndexFile(nitro.graphql.clientDir, externalServices);
-	}
-}
-async function generateExternalServicesTypes(nitro) {
-	const externalServices = nitro.options.graphql?.externalServices || [];
-	for (const service of externalServices) try {
-		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 serviceTypesPath = resolve(nitro.options.buildDir, "types", `nitro-graphql-client-${service.name}.d.ts`);
-		const serviceDir = resolve(nitro.graphql.clientDir, service.name);
-		const serviceSdkPath = resolve(serviceDir, "sdk.ts");
-		mkdirSync(dirname(serviceTypesPath), { recursive: true });
-		writeFileSync(serviceTypesPath, types.types, "utf-8");
-		mkdirSync(serviceDir, { recursive: true });
-		let shouldWriteServiceSdk = true;
-		if (existsSync(serviceSdkPath)) shouldWriteServiceSdk = readFileSync(serviceSdkPath, "utf-8") !== types.sdk;
-		if (shouldWriteServiceSdk) writeFileSync(serviceSdkPath, types.sdk, "utf-8");
-		if (nitro.options.framework?.name === "nuxt") generateOfetchClient(nitro.graphql.clientDir, service.name, service.endpoint, false);
-		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 };