nitro-graphql 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/setup.mjs

@@ -0,0 +1,390 @@
+import { generateDirectiveSchemas } from "./utils/directive-parser.mjs";
+import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.mjs";
+import { writeFileIfNotExists } from "./utils/file-generator.mjs";
+import { getScaffoldConfig, getTypesConfig, resolveFilePath, shouldGenerateScaffold } from "./utils/path-resolver.mjs";
+import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.mjs";
+import { rollupConfig } from "./rollup.mjs";
+import { existsSync, mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { watch } from "chokidar";
+import consola from "consola";
+import defu from "defu";
+import { dirname, join, relative, resolve } from "pathe";
+
+//#region src/setup.ts
+/**
+* Shared setup logic for nitro-graphql module
+* Used by both the direct Nitro module export and the Vite plugin's nitro: hook
+*/
+async function setupNitroGraphQL(nitro) {
+	if (!nitro.options.graphql?.framework) consola.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
+	if (nitro.options.graphql?.externalServices?.length) {
+		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
+		if (validationErrors.length > 0) {
+			consola.error("External services configuration errors:");
+			for (const error of validationErrors) consola.error(`  - ${error}`);
+			throw new Error("Invalid external services configuration");
+		}
+		consola.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+	}
+	const { getDefaultPaths } = await import("./utils/path-resolver.mjs");
+	const defaultPaths = getDefaultPaths(nitro);
+	nitro.graphql ||= {
+		buildDir: "",
+		watchDirs: [],
+		clientDir: defaultPaths.clientGraphql,
+		serverDir: defaultPaths.serverGraphql,
+		dir: {
+			build: relative(nitro.options.rootDir, nitro.options.buildDir),
+			client: "graphql",
+			server: "server"
+		}
+	};
+	nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
+		rollupConfig$1.external = rollupConfig$1.external || [];
+		const codegenExternals = ["oxc-parser", "@oxc-parser"];
+		if (Array.isArray(rollupConfig$1.external)) rollupConfig$1.external.push(...codegenExternals);
+		else if (typeof rollupConfig$1.external === "function") {
+			const originalExternal = rollupConfig$1.external;
+			rollupConfig$1.external = (id, parent, isResolved) => {
+				if (codegenExternals.some((external) => id.includes(external))) return true;
+				return originalExternal(id, parent, isResolved);
+			};
+		}
+	});
+	nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
+		endpoint: {
+			graphql: "/api/graphql",
+			healthCheck: "/api/graphql/health"
+		},
+		playground: true
+	});
+	if (nitro.options.graphql?.federation?.enabled) consola.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
+	const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
+	nitro.graphql.buildDir = graphqlBuildDir;
+	const watchDirs = [];
+	switch (nitro.options.framework.name) {
+		case "nuxt": {
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			watchDirs.push(nitro.graphql.clientDir);
+			const layerServerDirs = getLayerServerDirectories(nitro);
+			const layerAppDirs = getLayerAppDirectories(nitro);
+			for (const layerServerDir of layerServerDirs) watchDirs.push(join(layerServerDir, "graphql"));
+			for (const layerAppDir of layerAppDirs) watchDirs.push(join(layerAppDir, "graphql"));
+			break;
+		}
+		case "nitro":
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			watchDirs.push(nitro.graphql.clientDir);
+			watchDirs.push(nitro.graphql.serverDir);
+			break;
+		default:
+	}
+	if (nitro.options.graphql?.externalServices?.length) {
+		for (const service of nitro.options.graphql.externalServices) if (service.documents?.length) for (const pattern of service.documents) {
+			if (!pattern) continue;
+			const baseDir = pattern.split("**")[0]?.replace(/\/$/, "") || ".";
+			const resolvedDir = resolve(nitro.options.rootDir, baseDir);
+			if (!watchDirs.includes(resolvedDir)) watchDirs.push(resolvedDir);
+		}
+	}
+	const watcher = watch(watchDirs, {
+		persistent: true,
+		ignoreInitial: true,
+		ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns()]
+	}).on("all", async (_, path) => {
+		if (path.endsWith(".graphql") || path.endsWith(".gql")) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql")) {
+			await serverTypeGeneration(nitro);
+			await clientTypeGeneration(nitro);
+			await nitro.hooks.callHook("dev:reload");
+		} else await clientTypeGeneration(nitro);
+	});
+	nitro.hooks.hook("close", () => {
+		watcher.close();
+	});
+	const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
+	nitro.scanSchemas = await scanSchemas(nitro);
+	nitro.scanDocuments = await scanDocs(nitro);
+	nitro.scanResolvers = await scanResolvers(nitro);
+	const directives = await scanDirectives(nitro);
+	nitro.scanDirectives = directives;
+	await generateDirectiveSchemas(nitro, directives);
+	nitro.hooks.hook("dev:start", async () => {
+		const schemas = await scanSchemas(nitro);
+		nitro.scanSchemas = schemas;
+		const resolvers = await scanResolvers(nitro);
+		nitro.scanResolvers = resolvers;
+		const directives$1 = await scanDirectives(nitro);
+		nitro.scanDirectives = directives$1;
+		await generateDirectiveSchemas(nitro, directives$1);
+		const docs = await scanDocs(nitro);
+		nitro.scanDocuments = docs;
+		if (nitro.options.dev) {
+			consola.box({
+				title: "Nitro GraphQL",
+				message: [
+					`Framework: ${nitro.options.graphql?.framework || "Not configured"}`,
+					`Schemas: ${schemas.length}`,
+					`Resolvers: ${resolvers.length}`,
+					`Directives: ${directives$1.length}`,
+					`Documents: ${docs.length}`,
+					"",
+					"Debug Dashboard: /_nitro/graphql/debug"
+				].join("\n"),
+				style: {
+					borderColor: "cyan",
+					borderStyle: "rounded"
+				}
+			});
+			if (resolvers.length > 0) {
+				const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
+				const typeCount = {
+					query: 0,
+					mutation: 0,
+					resolver: 0,
+					type: 0,
+					subscription: 0,
+					directive: 0
+				};
+				for (const resolver of resolvers) for (const imp of resolver.imports) if (imp.type in typeCount) typeCount[imp.type]++;
+				const breakdown = [];
+				if (typeCount.query > 0) breakdown.push(`${typeCount.query} query`);
+				if (typeCount.mutation > 0) breakdown.push(`${typeCount.mutation} mutation`);
+				if (typeCount.resolver > 0) breakdown.push(`${typeCount.resolver} resolver`);
+				if (typeCount.type > 0) breakdown.push(`${typeCount.type} type`);
+				if (typeCount.subscription > 0) breakdown.push(`${typeCount.subscription} subscription`);
+				if (typeCount.directive > 0) breakdown.push(`${typeCount.directive} directive`);
+				if (breakdown.length > 0) consola.success(`[nitro-graphql] ${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+			} else consola.warn("[nitro-graphql] No resolvers found. Check /_nitro/graphql/debug for details.");
+		}
+	});
+	await rollupConfig(nitro);
+	await serverTypeGeneration(nitro);
+	await clientTypeGeneration(nitro);
+	nitro.hooks.hook("close", async () => {
+		await serverTypeGeneration(nitro);
+		await clientTypeGeneration(nitro);
+	});
+	const runtime = fileURLToPath(new URL("routes", import.meta.url));
+	const methods = [
+		"GET",
+		"POST",
+		"OPTIONS"
+	];
+	if (nitro.options.graphql?.framework === "graphql-yoga") for (const method of methods) nitro.options.handlers.push({
+		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+		handler: join(runtime, "graphql-yoga"),
+		method
+	});
+	if (nitro.options.graphql?.framework === "apollo-server") for (const method of methods) nitro.options.handlers.push({
+		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+		handler: join(runtime, "apollo-server"),
+		method
+	});
+	nitro.options.handlers.push({
+		route: nitro.options.runtimeConfig.graphql?.endpoint?.healthCheck || "/api/graphql/health",
+		handler: join(runtime, "health"),
+		method: "GET"
+	});
+	if (nitro.options.dev) {
+		nitro.options.handlers.push({
+			route: "/_nitro/graphql/debug",
+			handler: join(runtime, "debug"),
+			method: "GET"
+		});
+		consola.info("[nitro-graphql] Debug dashboard available at: /_nitro/graphql/debug");
+	}
+	if (nitro.options.imports) {
+		nitro.options.imports.presets ??= [];
+		nitro.options.imports.presets.push({
+			from: fileURLToPath(new URL("utils/define", import.meta.url)),
+			imports: [
+				"defineResolver",
+				"defineMutation",
+				"defineQuery",
+				"defineSubscription",
+				"defineType",
+				"defineGraphQLConfig",
+				"defineSchema",
+				"defineDirective"
+			]
+		});
+	}
+	nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
+		const manualChunks = rollupConfig$1.output?.manualChunks;
+		const chunkFiles = rollupConfig$1.output?.chunkFileNames;
+		if (!rollupConfig$1.output.inlineDynamicImports) {
+			rollupConfig$1.output.manualChunks = (id, meta) => {
+				if (id.endsWith(".graphql") || id.endsWith(".gql")) {
+					let graphqlIndex = id.indexOf("server/graphql/");
+					let baseLength = 15;
+					if (graphqlIndex === -1) {
+						graphqlIndex = id.indexOf("routes/graphql/");
+						baseLength = 15;
+					}
+					if (graphqlIndex !== -1) return id.slice(graphqlIndex + baseLength).replace(/\.(?:graphql|gql)$/, "-schema");
+					return "schemas";
+				}
+				if (id.endsWith(".resolver.ts")) {
+					let graphqlIndex = id.indexOf("server/graphql/");
+					let baseLength = 15;
+					if (graphqlIndex === -1) {
+						graphqlIndex = id.indexOf("routes/graphql/");
+						baseLength = 15;
+					}
+					if (graphqlIndex !== -1) return id.slice(graphqlIndex + baseLength).replace(/\.resolver\.ts$/, "");
+					return "resolvers";
+				}
+				if (typeof manualChunks === "function") return manualChunks(id, meta);
+			};
+			rollupConfig$1.output.advancedChunks = {
+				groups: [{
+					name: (moduleId) => {
+						if (!moduleId.endsWith(".graphql") && !moduleId.endsWith(".gql")) return;
+						let graphqlIndex = moduleId.indexOf("server/graphql/");
+						let baseLength = 15;
+						if (graphqlIndex === -1) {
+							graphqlIndex = moduleId.indexOf("routes/graphql/");
+							baseLength = 15;
+						}
+						if (graphqlIndex !== -1) return moduleId.slice(graphqlIndex + baseLength).replace(/\.(?:graphql|gql)$/, "-schema");
+						return "schemas";
+					},
+					test: /\.(?:graphql|gql)$/
+				}, {
+					name: (moduleId) => {
+						if (!moduleId.endsWith(".resolver.ts")) return;
+						let graphqlIndex = moduleId.indexOf("server/graphql/");
+						let baseLength = 15;
+						if (graphqlIndex === -1) {
+							graphqlIndex = moduleId.indexOf("routes/graphql/");
+							baseLength = 15;
+						}
+						if (graphqlIndex !== -1) return moduleId.slice(graphqlIndex + baseLength).replace(/\.resolver\.ts$/, "");
+						return "resolvers";
+					},
+					test: /\.resolver\.(?:ts|js)$/
+				}],
+				minSize: 0,
+				minShareCount: 1
+			};
+		}
+		rollupConfig$1.output.chunkFileNames = (chunkInfo) => {
+			if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => id.endsWith(".graphql") || id.endsWith(".resolver.ts") || id.endsWith(".gql"))) return `chunks/graphql/[name].mjs`;
+			if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
+			return `chunks/_/[name].mjs`;
+		};
+	});
+	nitro.options.typescript.strict = true;
+	nitro.hooks.hook("types:extend", (types) => {
+		types.tsConfig ||= {};
+		types.tsConfig.compilerOptions ??= {};
+		types.tsConfig.compilerOptions.paths ??= {};
+		const placeholders = getDefaultPaths(nitro);
+		const typesConfig = getTypesConfig(nitro);
+		const serverTypesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+		if (serverTypesPath) types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, serverTypesPath)];
+		const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+		if (clientTypesPath) types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, clientTypesPath)];
+		types.tsConfig.compilerOptions.paths["#graphql/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
+		if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) {
+			const servicePlaceholders = {
+				...placeholders,
+				serviceName: service.name
+			};
+			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+			if (externalTypesPath) types.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativeWithDot(tsconfigDir, externalTypesPath)];
+		}
+		types.tsConfig.include = types.tsConfig.include || [];
+		if (serverTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, serverTypesPath));
+		if (clientTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, clientTypesPath));
+		types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(placeholders.typesDir, "graphql.d.ts")));
+		if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) {
+			const servicePlaceholders = {
+				...placeholders,
+				serviceName: service.name
+			};
+			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+			if (externalTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, externalTypesPath));
+		}
+	});
+	if (nitro.options.framework?.name === "nuxt" && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
+		const nuxtOptions = nitro._nuxt?.options;
+		if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
+	});
+	if (shouldGenerateScaffold(nitro)) {
+		const placeholders = getDefaultPaths(nitro);
+		const scaffoldConfig = getScaffoldConfig(nitro);
+		const graphqlConfigPath = resolveFilePath(scaffoldConfig.graphqlConfig, scaffoldConfig.enabled, true, "graphql.config.ts", placeholders);
+		if (graphqlConfigPath) writeFileIfNotExists(graphqlConfigPath, `
+import type { IGraphQLConfig } from 'graphql-config'
+
+export default <IGraphQLConfig> {
+    projects: {
+      default: {
+        schema: [
+          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"))}',
+        ],
+        documents: [
+          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"))}',
+        ],
+      },
+    },
+}`, "graphql.config.ts");
+		const serverSchemaPath = resolveFilePath(scaffoldConfig.serverSchema, scaffoldConfig.enabled, true, "{serverGraphql}/schema.ts", placeholders);
+		const serverConfigPath = resolveFilePath(scaffoldConfig.serverConfig, scaffoldConfig.enabled, true, "{serverGraphql}/config.ts", placeholders);
+		const serverContextPath = resolveFilePath(scaffoldConfig.serverContext, scaffoldConfig.enabled, true, "{serverGraphql}/context.d.ts", placeholders);
+		if (serverSchemaPath || serverConfigPath || serverContextPath) {
+			if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
+		}
+		if (serverSchemaPath) writeFileIfNotExists(serverSchemaPath, `export default defineSchema({
+
+})
+`, "server schema.ts");
+		if (serverConfigPath) writeFileIfNotExists(serverConfigPath, `// Example GraphQL config file please change it to your needs
+// import * as tables from '../drizzle/schema/index'
+// import { useDatabase } from '../utils/useDb'
+import { defineGraphQLConfig } from 'nitro-graphql/utils/define'
+
+export default defineGraphQLConfig({
+// graphql-yoga example config
+// context: () => {
+//   return {
+//     context: {
+//       useDatabase,
+//       tables,
+//     },
+//   }
+// },
+})
+`, "server config.ts");
+		if (serverContextPath) writeFileIfNotExists(serverContextPath, `// Example context definition - please change it to your needs
+// import type { Database } from '../utils/useDb'
+
+declare module 'nitro/h3' {
+  interface H3EventContext {
+    // Add your custom context properties here
+    // useDatabase: () => Database
+    // tables: typeof import('../drizzle/schema')
+    // auth?: {
+    //   user?: {
+    //     id: string
+    //     role: 'admin' | 'user'
+    //   }
+    // }
+  }
+}
+
+export {}
+`, "server context.d.ts");
+		if (existsSync(join(nitro.graphql.serverDir, "context.ts"))) {
+			consola.warn("nitro-graphql: Found context.ts file. Please rename it to context.d.ts for type-only definitions.");
+			consola.info("The context file should now be context.d.ts instead of context.ts");
+		}
+	} else consola.info("[nitro-graphql] Scaffold file generation is disabled (library mode)");
+}
+
+//#endregion
+export { setupNitroGraphQL };

package/dist/types/index.d.mts

@@ -0,0 +1,246 @@
+import { StandardSchemaV1 } from "./standard-schema.mjs";
+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;
+  }
+}
+/**
+ * Service-specific path overrides for external GraphQL services
+ * These paths override global config for this specific service
+ */
+interface ExternalServicePaths {
+  /** SDK file path (overrides global sdk.external config) */
+  sdk?: FileGenerationConfig;
+  /** Type definitions file path (overrides global types.external config) */
+  types?: FileGenerationConfig;
+  /** ofetch client wrapper path (overrides global clientUtils.ofetch config) */
+  ofetch?: FileGenerationConfig;
+}
+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;
+  };
+  /**
+   * Optional: Service-specific path overrides
+   * These paths take precedence over global config (sdk, types, clientUtils)
+   * Supports placeholders: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {clientGraphql}
+   */
+  paths?: ExternalServicePaths;
+}
+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;
+}
+/**
+ * File generation control:
+ * - false: Do not generate this file
+ * - true: Generate at default location
+ * - string: Generate at custom path (supports placeholders: {serviceName}, {buildDir}, {rootDir}, {framework})
+ */
+type FileGenerationConfig = boolean | string;
+/**
+ * Scaffold files configuration
+ * Control auto-generation of scaffold/boilerplate files
+ */
+interface ScaffoldConfig {
+  /** Enable/disable all scaffold files */
+  enabled?: boolean;
+  /** graphql.config.ts - GraphQL Config file for IDE tooling */
+  graphqlConfig?: FileGenerationConfig;
+  /** server/graphql/schema.ts - Schema definition file */
+  serverSchema?: FileGenerationConfig;
+  /** server/graphql/config.ts - GraphQL server configuration */
+  serverConfig?: FileGenerationConfig;
+  /** server/graphql/context.ts - H3 context augmentation */
+  serverContext?: FileGenerationConfig;
+}
+/**
+ * Client utilities configuration
+ * Control auto-generation of client-side utility files (Nuxt only)
+ */
+interface ClientUtilsConfig {
+  /** Enable/disable all client utilities */
+  enabled?: boolean;
+  /** app/graphql/index.ts - Main exports file */
+  index?: FileGenerationConfig;
+  /** app/graphql/{serviceName}/ofetch.ts - ofetch client wrapper */
+  ofetch?: FileGenerationConfig;
+}
+/**
+ * SDK files configuration
+ * Control auto-generation of GraphQL SDK files
+ */
+interface SdkConfig {
+  /** Enable/disable all SDK files */
+  enabled?: boolean;
+  /** app/graphql/default/sdk.ts - Main service SDK */
+  main?: FileGenerationConfig;
+  /** app/graphql/{serviceName}/sdk.ts - External service SDKs */
+  external?: FileGenerationConfig;
+}
+/**
+ * Type files configuration
+ * Control auto-generation of TypeScript type definition files
+ */
+interface TypesConfig {
+  /** Enable/disable all type files */
+  enabled?: boolean;
+  /** .nitro/types/nitro-graphql-server.d.ts - Server-side types */
+  server?: FileGenerationConfig;
+  /** .nitro/types/nitro-graphql-client.d.ts - Client-side types */
+  client?: FileGenerationConfig;
+  /** .nitro/types/nitro-graphql-client-{serviceName}.d.ts - External service types */
+  external?: FileGenerationConfig;
+}
+/**
+ * Global path overrides
+ * Set base directories for file generation
+ */
+interface PathsConfig {
+  /** Server GraphQL directory (default: 'server/graphql') */
+  serverGraphql?: string;
+  /** Client GraphQL directory (default: 'app/graphql' for Nuxt, 'graphql' for Nitro) */
+  clientGraphql?: string;
+  /** Build directory (default: '.nitro' or '.nuxt') */
+  buildDir?: string;
+  /** Types directory (default: '{buildDir}/types') */
+  typesDir?: 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[];
+  /**
+   * Scaffold files configuration
+   * Set to false to disable all scaffold file generation (library mode)
+   */
+  scaffold?: false | ScaffoldConfig;
+  /**
+   * Client utilities configuration
+   * Set to false to disable all client utility generation
+   */
+  clientUtils?: false | ClientUtilsConfig;
+  /**
+   * SDK files configuration
+   * Set to false to disable all SDK generation
+   */
+  sdk?: false | SdkConfig;
+  /**
+   * Type files configuration
+   * Set to false to disable all type generation
+   */
+  types?: false | TypesConfig;
+  /**
+   * Global path overrides
+   * Customize base directories for file generation
+   */
+  paths?: PathsConfig;
+}
+//#endregion
+export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, TypesConfig };

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

@@ -18,11 +18,11 @@ function startServerAndCreateH3Handler(server, options) {
 				});
 				if (body.kind === "chunked") throw new Error("Incremental delivery not implemented");
 				setHeaders(event, Object.fromEntries(headers));
-				event.res.statusCode = status || 200;
+				event.res.status = status || 200;
 				return body.string;
 			} catch (error) {
 				if (error instanceof SyntaxError) {
-					event.res.statusCode = 400;
+					event.res.status = 400;
 					return error.message;
 				} else throw error;
 			}

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

@@ -1,4 +1,4 @@
-import { CodegenClientConfig, ExternalGraphQLService, GenericSdkConfig } from "../types/index.js";
+import { CodegenClientConfig, ExternalGraphQLService, GenericSdkConfig } from "../types/index.mjs";
 import { GraphQLSchema } from "graphql";
 import { Source } from "@graphql-tools/utils";
 import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
@@ -23,14 +23,14 @@ declare function loadExternalSchema(service: ExternalGraphQLService, buildDir?:
  */
 declare function downloadAndSaveSchema(service: ExternalGraphQLService, buildDir: string): Promise<string | undefined>;
 declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
-declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string): Promise<false | {
+declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string, virtualTypesPath?: string): Promise<false | {
   types: string;
   sdk: string;
 }>;
 /**
  * Generate client types for external GraphQL service
  */
-declare function generateExternalClientTypes(service: ExternalGraphQLService, schema: GraphQLSchema, docs: Source[]): Promise<{
+declare function generateExternalClientTypes(service: ExternalGraphQLService, schema: GraphQLSchema, docs: Source[], virtualTypesPath?: string): Promise<{
   types: string;
   sdk: string;
 } | false>;