nitro-graphql 1.3.0 → 1.4.0

package/README.md

@@ -461,10 +461,11 @@ export default defineGraphQLConfig({
 
 Try out the examples:
 
-- **Standalone Nitro**: [`playground/`](playground/)
-- **Nuxt.js Integration**: [`playground-nuxt/`](playground-nuxt/)
+- **Standalone Nitro**: [`playgrounds/nitro/`](playgrounds/nitro/)
+- **Nuxt.js Integration**: [`playgrounds/nuxt/`](playgrounds/nuxt/)
+- **Apollo Federation**: [`playgrounds/federation/`](playgrounds/federation/)
 
-Both examples include working GraphQL schemas, resolvers, and demonstrate the module's capabilities.
+All examples include working GraphQL schemas, resolvers, and demonstrate the module's capabilities.
 
 ## 🔧 API Reference
 
@@ -1203,7 +1204,9 @@ const client = createGraphQLClient({
 - `pnpm build` - Build the module
 - `pnpm dev` - Watch mode with automatic rebuilding
 - `pnpm lint` - ESLint with auto-fix
-- `pnpm playground` - Run the Nitro playground example
+- `pnpm playground:nitro` - Run the Nitro playground example
+- `pnpm playground:nuxt` - Run the Nuxt playground example
+- `pnpm playground:federation` - Run the Apollo Federation playground
 - `pnpm release` - Build, version bump, and publish
 
 ### Requirements

package/dist/ecosystem/nuxt.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "pathe";
-import { defineNuxtModule } from "@nuxt/kit";
+import { defineNuxtModule, getLayerDirectories } from "@nuxt/kit";
 
 //#region src/ecosystem/nuxt.ts
 var nuxt_default = defineNuxtModule({
@@ -30,10 +30,19 @@ var nuxt_default = defineNuxtModule({
 		const externalServices = nuxt.options.nitro?.graphql?.externalServices || [];
 		for (const service of externalServices) nuxt.options.alias[`#graphql/client/${service.name}`] = join(nuxt.options.buildDir, `types/nitro-graphql-client-${service.name}.d.ts`);
 		nuxt.hook("imports:dirs", (dirs) => {
-			dirs.push(resolve(nuxt.options.srcDir, "graphql"));
+			const graphqlServerPath = nuxt.options.nitro?.graphql?.serverDir || resolve(nuxt.options.srcDir, "graphql");
+			dirs.push(graphqlServerPath);
 		});
-		nuxt.hook("nitro:config", () => {
+		nuxt.hook("nitro:config", async (nitroConfig) => {
 			const clientDir = join(nuxt.options.buildDir, "graphql");
+			const layerDirs = await getLayerDirectories(nuxt);
+			const layerDirectories = layerDirs.map((layer) => layer.root.replace(/\/$/, "")).filter((root) => root !== nuxt.options.rootDir);
+			const layerServerDirs = layerDirs.filter((layer) => layer.root !== `${nuxt.options.rootDir}/`).map((layer) => layer.server?.replace(/\/$/, "")).filter(Boolean);
+			const layerAppDirs = layerDirs.filter((layer) => layer.root !== `${nuxt.options.rootDir}/`).map((layer) => layer.app?.replace(/\/$/, "")).filter(Boolean);
+			if (!nitroConfig.graphql) nitroConfig.graphql = {};
+			nitroConfig.graphql.layerDirectories = layerDirectories;
+			nitroConfig.graphql.layerServerDirs = layerServerDirs;
+			nitroConfig.graphql.layerAppDirs = layerAppDirs;
 			const appGraphqlDir = resolve(nuxt.options.rootDir, "app/graphql");
 			const hasAppGraphqlDir = existsSync(appGraphqlDir);
 			if (!hasAppGraphqlDir) {

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { StandardSchemaV1 } from "./types/standard-schema.js";
-import { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, GenImport, GenericSdkConfig, NitroGraphQLOptions } from "./types/index.js";
+import { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions } from "./types/index.js";
 import * as nitropack0 from "nitropack";
 
 //#region src/index.d.ts
 declare const _default: nitropack0.NitroModule;
 //#endregion
-export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, GenImport, GenericSdkConfig, NitroGraphQLOptions, StandardSchemaV1, _default as default };
+export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, StandardSchemaV1, _default as default };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { generateDirectiveSchemas } from "./utils/directive-parser.js";
-import { relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.js";
+import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.js";
 import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
 import { rollupConfig } from "./rollup.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
@@ -35,7 +35,7 @@ var src_default = defineNitroModule({
 				server: "server"
 			}
 		};
-		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig$1) => {
+		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);
@@ -54,15 +54,21 @@ var src_default = defineNitroModule({
 			},
 			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":
+			case "nuxt": {
 				watchDirs.push(join(nitro.options.rootDir, "app", "graphql"));
 				nitro.graphql.clientDir = resolve(nitro.options.rootDir, "app", "graphql");
 				nitro.graphql.dir.client = "app/graphql";
+				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.clientDir = resolve(nitro.options.rootDir, "graphql");
 				nitro.graphql.dir.client = "graphql";
@@ -80,8 +86,8 @@ var src_default = defineNitroModule({
 		const watcher = watch(watchDirs, {
 			persistent: true,
 			ignoreInitial: true,
-			ignored: [...nitro.options.ignore, "**/server/graphql/_directives.graphql"]
-		}).on("all", async (event, path) => {
+			ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns(nitro)]
+		}).on("all", async (_, path) => {
 			if (path.endsWith(".graphql") || path.endsWith(".gql")) await clientTypeGeneration(nitro);
 		});
 		nitro.hooks.hook("close", () => {
@@ -154,7 +160,7 @@ var src_default = defineNitroModule({
 				]
 			});
 		}
-		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig$1) => {
+		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) => {

package/dist/rollup.js

@@ -11,6 +11,7 @@ async function rollupConfig(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 || {};
@@ -25,8 +26,9 @@ async function rollupConfig(app) {
 						if (validate) parse(content);
 						return `export default ${JSON.stringify(content)}`;
 					} catch (error) {
-						if (error.code === "ENOENT") return null;
-						this.error(`Failed to read GraphQL file ${id}: ${error.message}`);
+						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}`);
 					}
 				}
 			});
@@ -35,7 +37,7 @@ async function rollupConfig(app) {
 				async buildStart() {
 					const graphqlFiles = await scanGraphql(nitro);
 					for (const file of graphqlFiles) this.addWatchFile(file);
-					this.addWatchFile("server/graphql/");
+					this.addWatchFile(app.graphql.serverDir);
 				}
 			});
 		}
@@ -119,6 +121,13 @@ 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 +1,6 @@
 import * as h30 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h30.EventHandler<h30.EventHandlerRequest, any>;
+declare const _default: h30.EventHandler<h30.EventHandlerRequest, Promise<any>>;
 //#endregion
 export { _default as default };

package/dist/routes/apollo-server.js

@@ -1,16 +1,31 @@
 import { startServerAndCreateH3Handler } from "../utils/apollo.js";
+import { consola as consola$1 } from "consola";
 import defu from "defu";
+import { parse } from "graphql";
 import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
 import { importedConfig } from "#nitro-internal-virtual/graphql-config";
+import { moduleConfig } from "#nitro-internal-virtual/module-config";
 import { directives } from "#nitro-internal-virtual/server-directives";
 import { resolvers } from "#nitro-internal-virtual/server-resolvers";
 import { schemas } from "#nitro-internal-virtual/server-schemas";
 import { ApolloServer } from "@apollo/server";
 import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
 import { makeExecutableSchema } from "@graphql-tools/schema";
+import { defineEventHandler } from "h3";
 
 //#region src/routes/apollo-server.ts
-function createMergedSchema() {
+let buildSubgraphSchema = null;
+async function loadFederationSupport() {
+	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
+	try {
+		const apolloSubgraph = await import("@apollo/subgraph");
+		buildSubgraphSchema = apolloSubgraph.buildSubgraphSchema;
+	} catch {
+		buildSubgraphSchema = false;
+	}
+	return buildSubgraphSchema;
+}
+async function createMergedSchema() {
 	try {
 		const mergedSchemas = schemas.map((schema$1) => schema$1.def).join("\n\n");
 		const typeDefs = mergeTypeDefs([mergedSchemas], {
@@ -19,7 +34,24 @@ function createMergedSchema() {
 			sort: true
 		});
 		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		let schema = makeExecutableSchema({
+		const federationEnabled = moduleConfig.federation?.enabled;
+		let schema;
+		if (federationEnabled) {
+			const buildSubgraph = await loadFederationSupport();
+			if (buildSubgraph) {
+				const typeDefsDoc = typeof typeDefs === "string" ? parse(typeDefs) : typeDefs;
+				schema = buildSubgraph({
+					typeDefs: typeDefsDoc,
+					resolvers: mergedResolvers
+				});
+			} else {
+				console.warn("Federation enabled but @apollo/subgraph not available, falling back to regular schema");
+				schema = makeExecutableSchema({
+					typeDefs,
+					resolvers: mergedResolvers
+				});
+			}
+		} else schema = makeExecutableSchema({
 			typeDefs,
 			resolvers: mergedResolvers
 		});
@@ -28,14 +60,14 @@ function createMergedSchema() {
 		}
 		return schema;
 	} catch (error) {
-		console.error("Schema merge error:", error);
+		consola$1.error("Schema merge error:", error);
 		throw error;
 	}
 }
 let apolloServer = null;
-function createApolloServer() {
+async function createApolloServer() {
 	if (!apolloServer) {
-		const schema = createMergedSchema();
+		const schema = await createMergedSchema();
 		apolloServer = new ApolloServer(defu({
 			schema,
 			introspection: true,
@@ -44,7 +76,13 @@ function createApolloServer() {
 	}
 	return apolloServer;
 }
-var apollo_server_default = startServerAndCreateH3Handler(apolloServer || createApolloServer, { context: async (event) => ({ event }) });
+let serverPromise = null;
+var apollo_server_default = defineEventHandler(async (event) => {
+	if (!serverPromise) serverPromise = createApolloServer();
+	const server = await serverPromise;
+	const h3Handler = startServerAndCreateH3Handler(server, { context: async () => ({ event }) });
+	return h3Handler(event);
+});
 
 //#endregion
 export { apollo_server_default as default };

package/dist/routes/graphql-yoga.js

@@ -1,6 +1,9 @@
+import { consola as consola$1 } from "consola";
 import defu from "defu";
+import { parse } from "graphql";
 import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
 import { importedConfig } from "#nitro-internal-virtual/graphql-config";
+import { moduleConfig } from "#nitro-internal-virtual/module-config";
 import { directives } from "#nitro-internal-virtual/server-directives";
 import { resolvers } from "#nitro-internal-virtual/server-resolvers";
 import { schemas } from "#nitro-internal-virtual/server-schemas";
@@ -9,6 +12,17 @@ import { defineEventHandler, toWebRequest } from "h3";
 import { createYoga } from "graphql-yoga";
 
 //#region src/routes/graphql-yoga.ts
+let buildSubgraphSchema = null;
+async function loadFederationSupport() {
+	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
+	try {
+		const apolloSubgraph = await import("@apollo/subgraph");
+		buildSubgraphSchema = apolloSubgraph.buildSubgraphSchema;
+	} catch {
+		buildSubgraphSchema = false;
+	}
+	return buildSubgraphSchema;
+}
 const apolloSandboxHtml = `<!DOCTYPE html>
 <html lang="en">
 <body style="margin: 0; overflow-x: hidden; overflow-y: hidden">
@@ -26,7 +40,7 @@ new window.EmbeddedSandbox({
 <\/script>
 </body>
 </html>`;
-function createMergedSchema() {
+async function createMergedSchema() {
 	try {
 		const mergedSchemas = schemas.map((schema$1) => schema$1.def).join("\n\n");
 		const typeDefs = mergeTypeDefs([mergedSchemas], {
@@ -35,7 +49,24 @@ function createMergedSchema() {
 			sort: true
 		});
 		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		let schema = makeExecutableSchema({
+		const federationEnabled = moduleConfig.federation?.enabled;
+		let schema;
+		if (federationEnabled) {
+			const buildSubgraph = await loadFederationSupport();
+			if (buildSubgraph) {
+				const typeDefsDoc = typeof typeDefs === "string" ? parse(typeDefs) : typeDefs;
+				schema = buildSubgraph({
+					typeDefs: typeDefsDoc,
+					resolvers: mergedResolvers
+				});
+			} else {
+				console.warn("Federation enabled but @apollo/subgraph not available, falling back to regular schema");
+				schema = makeExecutableSchema({
+					typeDefs,
+					resolvers: mergedResolvers
+				});
+			}
+		} else schema = makeExecutableSchema({
 			typeDefs,
 			resolvers: mergedResolvers
 		});
@@ -44,14 +75,14 @@ function createMergedSchema() {
 		}
 		return schema;
 	} catch (error) {
-		console.error("Schema merge error:", error);
+		consola$1.error("Schema merge error:", error);
 		throw error;
 	}
 }
 let yoga;
 var graphql_yoga_default = defineEventHandler(async (event) => {
 	if (!yoga) {
-		const schema = createMergedSchema();
+		const schema = await createMergedSchema();
 		yoga = createYoga(defu({
 			schema,
 			graphqlEndpoint: "/api/graphql",

package/dist/types/index.d.ts

@@ -84,6 +84,16 @@ interface ExternalGraphQLService {
     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?: {
@@ -105,6 +115,14 @@ interface NitroGraphQLOptions {
   };
   /** 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, GenImport, GenericSdkConfig, NitroGraphQLOptions };
+export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions };

package/dist/utils/index.d.ts

@@ -4,6 +4,22 @@ import { Nitro } from "nitropack";
 
 //#region src/utils/index.d.ts
 declare const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+/**
+ * Get all Nuxt layer directories from Nitro config
+ */
+declare function getLayerDirectories(nitro: Nitro): string[];
+/**
+ * Get all Nuxt layer server directories from Nitro config
+ */
+declare function getLayerServerDirectories(nitro: Nitro): string[];
+/**
+ * Get all Nuxt layer app directories from Nitro config
+ */
+declare function getLayerAppDirectories(nitro: Nitro): string[];
+/**
+ * Generate layer-aware ignore patterns for auto-generated files
+ */
+declare function generateLayerIgnorePatterns(nitro: Nitro): string[];
 declare function getImportId(p: string, lazy?: boolean): string;
 declare function relativeWithDot(from: string, to: string): string;
 declare function scanGraphql(nitro: Nitro): Promise<string[]>;
@@ -19,6 +35,6 @@ declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patt
 /**
  * Validate external GraphQL service configuration
  */
-declare function validateExternalServices(services: any[]): string[];
+declare function validateExternalServices(services: unknown[]): string[];
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };

package/dist/utils/index.js

@@ -7,6 +7,34 @@ import { glob } from "tinyglobby";
 
 //#region src/utils/index.ts
 const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+/**
+* Get all Nuxt layer directories from Nitro config
+*/
+function getLayerDirectories(nitro) {
+	return nitro.options.graphql?.layerDirectories || [];
+}
+/**
+* Get all Nuxt layer server directories from Nitro config
+*/
+function getLayerServerDirectories(nitro) {
+	return nitro.options.graphql?.layerServerDirs || [];
+}
+/**
+* Get all Nuxt layer app directories from Nitro config
+*/
+function getLayerAppDirectories(nitro) {
+	return nitro.options.graphql?.layerAppDirs || [];
+}
+/**
+* Generate layer-aware ignore patterns for auto-generated files
+*/
+function generateLayerIgnorePatterns(nitro) {
+	const patterns = [];
+	patterns.push(`${nitro.graphql.serverDir}/_directives.graphql`);
+	const layerServerDirs = nitro.options.graphql?.layerServerDirs || [];
+	for (const layerServerDir of layerServerDirs) patterns.push(`${layerServerDir}/graphql/_directives.graphql`);
+	return patterns;
+}
 function getImportId(p, lazy) {
 	return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
 }
@@ -35,32 +63,32 @@ async function scanResolvers(nitro) {
 					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineResolver") exports.imports.push({
 						name: decl.id.name,
 						type: "resolver",
-						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
 					});
 					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineQuery") exports.imports.push({
 						name: decl.id.name,
 						type: "query",
-						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
 					});
 					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineMutation") exports.imports.push({
 						name: decl.id.name,
 						type: "mutation",
-						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
 					});
 					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineType") exports.imports.push({
 						name: decl.id.name,
 						type: "type",
-						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
 					});
 					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineSubscription") exports.imports.push({
 						name: decl.id.name,
 						type: "subscription",
-						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
 					});
 					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineDirective") exports.imports.push({
 						name: decl.id.name,
 						type: "directive",
-						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
 					});
 				}
 			}
@@ -85,7 +113,7 @@ async function scanDirectives(nitro) {
 					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineDirective") exports.imports.push({
 						name: decl.id.name,
 						type: "directive",
-						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
 					});
 				}
 			}
@@ -104,12 +132,22 @@ async function scanSchemas(nitro) {
 }
 async function scanDocs(nitro) {
 	const files = await scanDir(nitro, nitro.options.rootDir, nitro.graphql.dir.client, "**/*.graphql");
+	const layerAppDirs = getLayerAppDirectories(nitro);
+	const layerFiles = await Promise.all(layerAppDirs.map((layerAppDir) => scanDir(nitro, layerAppDir, "graphql", "**/*.graphql"))).then((r) => r.flat());
+	const combinedFiles = [...files, ...layerFiles];
+	const seenPaths = /* @__PURE__ */ new Set();
+	const allFiles = combinedFiles.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	});
 	const externalServices = nitro.options.graphql?.externalServices || [];
 	const externalPatterns = externalServices.flatMap((service) => service.documents || []);
-	return files.filter((f) => !f.path.startsWith("external/")).filter((f) => {
+	return allFiles.filter((f) => !f.path.startsWith("external/")).filter((f) => {
 		const relativePath = f.path;
 		for (const pattern of externalPatterns) {
-			const cleanPattern = pattern.replace(/^app\/graphql\//, "");
+			const clientDirPattern = `${nitro.graphql.dir.client}/`;
+			const cleanPattern = pattern.replace(/* @__PURE__ */ new RegExp(`^${clientDirPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), "");
 			const patternDir = cleanPattern.split("/")[0];
 			const fileDir = relativePath.split("/")[0];
 			if (patternDir === fileDir) return false;
@@ -144,23 +182,35 @@ function validateExternalServices(services) {
 	const serviceNames = /* @__PURE__ */ new Set();
 	for (const [index, service] of services.entries()) {
 		const prefix = `externalServices[${index}]`;
-		if (!service.name || typeof service.name !== "string") errors.push(`${prefix}.name is required and must be a string`);
+		if (!service || typeof service !== "object") {
+			errors.push(`${prefix} must be an object`);
+			continue;
+		}
+		if (!("name" in service) || typeof service.name !== "string") errors.push(`${prefix}.name is required and must be a string`);
 		else if (serviceNames.has(service.name)) errors.push(`${prefix}.name "${service.name}" must be unique`);
 		else serviceNames.add(service.name);
-		if (!service.schema) errors.push(`${prefix}.schema is required`);
-		if (!service.endpoint || typeof service.endpoint !== "string") errors.push(`${prefix}.endpoint is required and must be a string`);
+		if (!("schema" in service) || !service.schema) errors.push(`${prefix}.schema is required`);
+		if (!("endpoint" in service) || typeof service.endpoint !== "string") errors.push(`${prefix}.endpoint is required and must be a string`);
 		else try {
 			new URL(service.endpoint);
 		} catch {
 			errors.push(`${prefix}.endpoint "${service.endpoint}" must be a valid URL`);
 		}
-		if (service.name && !/^[a-z]\w*$/i.test(service.name)) errors.push(`${prefix}.name "${service.name}" must be a valid identifier (letters, numbers, underscore, starting with letter)`);
+		if ("name" in service && service.name && typeof service.name === "string" && !/^[a-z]\w*$/i.test(service.name)) errors.push(`${prefix}.name "${service.name}" must be a valid identifier (letters, numbers, underscore, starting with letter)`);
 	}
 	return errors;
 }
 async function scanFiles(nitro, name, globPattern = GLOB_SCAN_PATTERN) {
-	const files = await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name, globPattern))).then((r) => r.flat());
-	return files;
+	const regularFiles = await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name, globPattern))).then((r) => r.flat());
+	const layerDirectories = getLayerDirectories(nitro);
+	const layerFiles = await Promise.all(layerDirectories.map((layerDir) => scanDir(nitro, layerDir, `server/${name}`, globPattern))).then((r) => r.flat());
+	const allFiles = [...regularFiles, ...layerFiles];
+	const seenPaths = /* @__PURE__ */ new Set();
+	return allFiles.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	});
 }
 async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 	const fileNames = await glob(join(name, globPattern), {
@@ -184,4 +234,4 @@ async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };

package/dist/utils/server-codegen.d.ts

@@ -1,7 +1,7 @@
-import { CodegenServerConfig } from "../types/index.js";
+import { NitroGraphQLOptions } from "../types/index.js";
 import { GraphQLSchema } from "graphql";
 
 //#region src/utils/server-codegen.d.ts
-declare function generateTypes(selectFremework: string, schema: GraphQLSchema, config?: CodegenServerConfig, outputPath?: string): Promise<string>;
+declare function generateTypes(selectFremework: string, schema: GraphQLSchema, config?: Partial<NitroGraphQLOptions>, outputPath?: string): Promise<string>;
 //#endregion
 export { generateTypes };

package/dist/utils/server-codegen.js

@@ -41,9 +41,10 @@ async function generateTypes(selectFremework, schema, config = {}, outputPath) {
 		maybeValue: "T | null | undefined",
 		inputMaybeValue: "T | undefined",
 		declarationKind: "interface",
-		enumsAsTypes: true
+		enumsAsTypes: true,
+		...config.federation?.enabled && { federation: true }
 	};
-	const mergedConfig = defu$1(defaultConfig, config);
+	const mergedConfig = defu$1(defaultConfig, config.codegen?.server);
 	const output = await codegen({
 		filename: outputPath || "types.generated.ts",
 		schema: parse(printSchemaWithDirectives(schema)),

package/dist/utils/type-generation.js

@@ -193,13 +193,36 @@ async function serverTypeGeneration(app) {
 		const isValid = validateNoDuplicateTypes(schemas, schemaStrings);
 		if (!isValid) return;
 		const mergedSchemasString = schemaStrings.join("\n\n");
-		const mergedSchemas = mergeTypeDefs([mergedSchemasString], {
+		const federationEnabled = app.options.graphql?.federation?.enabled === true;
+		let schemaWithDirectives = mergedSchemasString;
+		if (federationEnabled) {
+			const federationDirectives = `
+        directive @key(fields: String!) on OBJECT | INTERFACE
+        directive @requires(fields: String!) on FIELD_DEFINITION
+        directive @provides(fields: String!) on FIELD_DEFINITION
+        directive @external on FIELD_DEFINITION | OBJECT
+        directive @tag(name: String!) on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        directive @extends on OBJECT | INTERFACE
+        directive @shareable on FIELD_DEFINITION | OBJECT
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @composeDirective(name: String!) on SCHEMA
+        directive @link(url: String!, as: String, for: Purpose, import: [String!]) on SCHEMA
+        
+        enum Purpose {
+          SECURITY
+          EXECUTION
+        }
+      `;
+			schemaWithDirectives = `${federationDirectives}\n\n${mergedSchemasString}`;
+		}
+		const mergedSchemas = mergeTypeDefs([schemaWithDirectives], {
 			throwOnConflict: true,
 			commentDescriptions: true,
 			sort: true
 		});
 		const schema = buildSchema(mergedSchemas);
-		const data = await generateTypes(app.options.graphql?.framework || "graphql-yoga", schema, app.options.graphql?.codegen?.server ?? {});
+		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 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,
@@ -56,6 +56,7 @@
   ],
   "peerDependencies": {
     "@apollo/server": "^5.0.0",
+    "@apollo/subgraph": "^2.0.0",
     "@apollo/utils.withrequired": "^3.0.0",
     "@as-integrations/h3": "^2.0.0",
     "graphql": "^16.11.0",
@@ -66,6 +67,9 @@
     "@apollo/server": {
       "optional": true
     },
+    "@apollo/subgraph": {
+      "optional": true
+    },
     "@apollo/utils.withrequired": {
       "optional": true
     },
@@ -79,7 +83,7 @@
     "@graphql-codegen/typescript": "^4.1.6",
     "@graphql-codegen/typescript-generic-sdk": "^4.0.2",
     "@graphql-codegen/typescript-operations": "^4.6.1",
-    "@graphql-codegen/typescript-resolvers": "^4.5.1",
+    "@graphql-codegen/typescript-resolvers": "^4.5.2",
     "@graphql-tools/graphql-file-loader": "^8.1.0",
     "@graphql-tools/load": "^8.1.2",
     "@graphql-tools/load-files": "^7.0.1",
@@ -94,15 +98,16 @@
     "graphql-scalars": "^1.24.2",
     "knitwork": "^1.2.0",
     "ohash": "^2.0.11",
-    "oxc-parser": "^0.82.3",
+    "oxc-parser": "^0.86.0",
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.14"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^5.2.1",
-    "@nuxt/kit": "^4.0.3",
-    "@nuxt/schema": "^4.0.3",
-    "@types/node": "^22.18.0",
+    "@antfu/eslint-config": "^5.2.2",
+    "@apollo/subgraph": "^2.11.2",
+    "@nuxt/kit": "^4.1.0",
+    "@nuxt/schema": "^4.1.0",
+    "@types/node": "^22.18.1",
     "bumpp": "^10.2.3",
     "changelogen": "^0.6.2",
     "crossws": "0.3.5",
@@ -110,7 +115,7 @@
     "graphql": "^16.11.0",
     "graphql-yoga": "^5.15.1",
     "h3": "1.15.3",
-    "nitropack": "^2.12.4",
+    "nitropack": "^2.12.5",
     "tsdown": "^0.14.2",
     "typescript": "^5.9.2"
   },
@@ -122,7 +127,9 @@
     "dev": "tsdown --watch",
     "bumpp": "bumpp package.json",
     "release": "pnpm build && pnpm bumpp && pnpm publish --no-git-checks --access public",
-    "playground": "cd playground && pnpm install && pnpm dev",
+    "playground:nitro": "cd playgrounds/nitro && pnpm install && pnpm dev",
+    "playground:nuxt": "cd playgrounds/nuxt && pnpm install && pnpm dev",
+    "playground:federation": "cd playgrounds/federation && pnpm install && pnpm dev",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   }