nitro-graphql 1.3.0 → 1.3.1

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

@@ -54,6 +54,7 @@ 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 = [];

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 || {};
@@ -119,6 +120,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,30 @@
 import { startServerAndCreateH3Handler } from "../utils/apollo.js";
 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 +33,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
 		});
@@ -33,9 +64,9 @@ function createMergedSchema() {
 	}
 }
 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 +75,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,8 @@
 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 +11,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 +39,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 +48,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
 		});
@@ -51,7 +81,7 @@ function createMergedSchema() {
 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,8 @@ interface NitroGraphQLOptions {
   };
   /** External GraphQL services to generate types and SDKs for */
   externalServices?: ExternalGraphQLService[];
+  /** Apollo Federation configuration */
+  federation?: FederationConfig;
 }
 //#endregion
-export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, GenImport, GenericSdkConfig, NitroGraphQLOptions };
+export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions };

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.3.1",
   "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
     },
@@ -100,6 +104,7 @@
   },
   "devDependencies": {
     "@antfu/eslint-config": "^5.2.1",
+    "@apollo/subgraph": "^2.11.2",
     "@nuxt/kit": "^4.0.3",
     "@nuxt/schema": "^4.0.3",
     "@types/node": "^22.18.0",