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

package/dist/setup.mjs

@@ -0,0 +1,392 @@
+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 defu from "defu";
+import { existsSync, mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { watch } from "chokidar";
+import consola from "consola";
+import { dirname, join, relative, resolve } from "pathe";
+
+//#region src/setup.ts
+const logger = consola.withTag("nitro-graphql");
+/**
+* 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) {
+	nitro.options.graphql ||= {};
+	nitro.options.graphql.types = defu(nitro.options.graphql.types, {
+		server: ".graphql/nitro-graphql-server.d.ts",
+		client: ".graphql/nitro-graphql-client.d.ts",
+		enabled: true
+	});
+	if (!nitro.options.graphql?.framework) logger.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) {
+			logger.error("External services configuration errors:");
+			for (const error of validationErrors) logger.error(`  - ${error}`);
+			throw new Error("Invalid external services configuration");
+		}
+		logger.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 allExternals = [...["oxc-parser", "@oxc-parser"]];
+		if (!nitro.options.graphql?.federation?.enabled) allExternals.push(...[
+			"@apollo/subgraph",
+			"@apollo/federation-internals",
+			"@apollo/cache-control-types"
+		]);
+		if (Array.isArray(rollupConfig$1.external)) rollupConfig$1.external.push(...allExternals);
+		else if (typeof rollupConfig$1.external === "function") {
+			const originalExternal = rollupConfig$1.external;
+			rollupConfig$1.external = (id, parent, isResolved) => {
+				if (allExternals.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) logger.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) => {
+		const isGraphQLFile = path.endsWith(".graphql") || path.endsWith(".gql");
+		const isResolverFile = path.endsWith(".resolver.ts") || path.endsWith(".resolver.js");
+		const isDirectiveFile = path.endsWith(".directive.ts") || path.endsWith(".directive.js");
+		if (isGraphQLFile || isResolverFile || isDirectiveFile) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql") || isResolverFile || isDirectiveFile) {
+			await scanResolvers(nitro).then((r) => nitro.scanResolvers = r);
+			await scanDirectives(nitro).then((d) => nitro.scanDirectives = d);
+			logger.success("Types regenerated");
+			await serverTypeGeneration(nitro, { silent: true });
+			await clientTypeGeneration(nitro, { silent: true });
+			await nitro.hooks.callHook("dev:reload");
+		} else {
+			logger.success("Types regenerated");
+			await clientTypeGeneration(nitro, { silent: true });
+		}
+	});
+	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);
+	let hasShownInitialLogs = false;
+	nitro.hooks.hook("dev:start", async () => {
+		nitro.scanSchemas = await scanSchemas(nitro);
+		const resolvers = await scanResolvers(nitro);
+		nitro.scanResolvers = resolvers;
+		const directives$1 = await scanDirectives(nitro);
+		nitro.scanDirectives = directives$1;
+		await generateDirectiveSchemas(nitro, directives$1);
+		nitro.scanDocuments = await scanDocs(nitro);
+		if (nitro.options.dev && !hasShownInitialLogs) {
+			hasShownInitialLogs = true;
+			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) logger.success(`${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+			} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
+		}
+	});
+	await rollupConfig(nitro);
+	await serverTypeGeneration(nitro);
+	await clientTypeGeneration(nitro, { isInitial: true });
+	nitro.hooks.hook("close", async () => {
+		await serverTypeGeneration(nitro, { silent: true });
+		await clientTypeGeneration(nitro, { silent: true });
+	});
+	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"
+	});
+	if (nitro.options.imports) {
+		nitro.options.imports.presets ??= [];
+		nitro.options.imports.presets.push({
+			from: fileURLToPath(new URL("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/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"))) {
+			logger.warn("Found context.ts file. Please rename it to context.d.ts for type-only definitions.");
+			logger.info("The context file should now be context.d.ts instead of context.ts");
+		}
+	} else logger.info("Scaffold file generation is disabled (library mode)");
+}
+
+//#endregion
+export { setupNitroGraphQL };

package/dist/{utils/define.d.ts → types/define.d.mts}

@@ -1,23 +1,12 @@
 import { GraphQLSchema } from "graphql";
 import { ApolloServerOptions } from "@apollo/server";
-import { H3Event } from "h3";
+import { H3Event } from "nitro/h3";
 import { YogaServerOptions } from "graphql-yoga";
-import { NPMConfig, Resolvers, ResolversTypes } from "#graphql/server";
-import { StandardSchemaV1 } from "nitro-graphql";
+import { NPMConfig } from "#graphql/server";
 
-//#region src/utils/define.d.ts
+//#region src/types/define.d.ts
 type Flatten<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
-declare function defineSchema<T extends Partial<Record<keyof ResolversTypes, StandardSchemaV1>>>(config: T): Flatten<T>;
-declare function defineResolver(resolvers: Resolvers): Resolvers;
-type ResolverQuery = Resolvers extends {
-  Query: infer Q;
-} ? Q : never;
-declare function defineQuery(resolvers?: Resolvers['Query']): Resolvers;
-declare function defineMutation(resolvers?: Resolvers['Mutation']): Resolvers;
-declare function defineSubscription(resolvers?: Resolvers['Subscription']): Resolvers;
-declare function defineType(resolvers: Resolvers): Resolvers;
 type DefineServerConfig<T extends NPMConfig = NPMConfig> = T['framework'] extends 'graphql-yoga' ? Partial<YogaServerOptions<H3Event, Partial<H3Event>>> : T['framework'] extends 'apollo-server' ? Partial<ApolloServerOptions<H3Event>> : Partial<YogaServerOptions<H3Event, Partial<H3Event>>> | Partial<ApolloServerOptions<H3Event>>;
-declare function defineGraphQLConfig<T extends NPMConfig = NPMConfig>(config: Partial<DefineServerConfig<T>>): Partial<DefineServerConfig<T>>;
 type DirectiveLocationName = 'QUERY' | 'MUTATION' | 'SUBSCRIPTION' | 'FIELD' | 'FRAGMENT_DEFINITION' | 'FRAGMENT_SPREAD' | 'INLINE_FRAGMENT' | 'VARIABLE_DEFINITION' | 'SCHEMA' | 'SCALAR' | 'OBJECT' | 'FIELD_DEFINITION' | 'ARGUMENT_DEFINITION' | 'INTERFACE' | 'UNION' | 'ENUM' | 'ENUM_VALUE' | 'INPUT_OBJECT' | 'INPUT_FIELD_DEFINITION';
 type GraphQLScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'JSON' | 'DateTime';
 type GraphQLBaseType = GraphQLScalarType | (string & {});
@@ -56,17 +45,5 @@ interface DefineDirectiveConfig {
   isRepeatable?: boolean;
   transformer?: (schema: GraphQLSchema) => GraphQLSchema;
 }
-/**
- * Helper function to create directive arguments with proper type inference
- * @example
- * args: {
- *   myArg: arg('String!', { defaultValue: 'hello' })
- * }
- */
-declare function arg<T extends GraphQLArgumentType>(type: T, options?: {
-  defaultValue?: any;
-  description?: string;
-}): DirectiveArgument<T>;
-declare function defineDirective(config: DefineDirectiveConfig): DirectiveDefinition;
 //#endregion
-export { DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, ResolverQuery, arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };
+export { DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType };

package/dist/types/define.mjs

@@ -0,0 +1 @@
+export {  };

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, StandardSchemaV1, TypesConfig };