nitro-graphql 1.2.3 → 1.3.1

package/dist/utils/define.js

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

package/dist/utils/directive-parser.d.ts

@@ -0,0 +1,80 @@
+//#region src/utils/directive-parser.d.ts
+interface ParsedDirective {
+  name: string;
+  locations: string[];
+  args?: Record<string, {
+    type: string;
+    defaultValue?: any;
+  }>;
+  description?: string;
+  isRepeatable?: boolean;
+}
+/**
+ * Clean AST-based directive parser using oxc-parser
+ */
+declare class DirectiveParser {
+  private oxc;
+  init(): Promise<void>;
+  /**
+   * Parse directives from a TypeScript/JavaScript file
+   */
+  parseDirectives(fileContent: string, filePath: string): Promise<ParsedDirective[]>;
+  /**
+   * Extract directive definitions from AST
+   */
+  private extractDirectiveDefinitions;
+  /**
+   * Traverse AST nodes recursively
+   */
+  private traverse;
+  /**
+   * Check if node is a defineDirective call
+   */
+  private isDefineDirectiveCall;
+  /**
+   * Extract directive configuration from defineDirective call
+   */
+  private extractDirectiveFromCall;
+  /**
+   * Extract directive properties from object expression
+   */
+  private extractDirectiveFromObject;
+  /**
+   * Extract string literal value
+   */
+  private extractStringLiteral;
+  /**
+   * Extract boolean literal value
+   */
+  private extractBooleanLiteral;
+  /**
+   * Extract array of strings
+   */
+  private extractStringArray;
+  /**
+   * Extract arguments object
+   */
+  private extractArgsObject;
+  /**
+   * Extract argument configuration
+   */
+  private extractArgConfig;
+  /**
+   * Extract literal value (string, number, boolean)
+   */
+  private extractLiteralValue;
+}
+/**
+ * Generate GraphQL directive schema from parsed directive
+ */
+declare function generateDirectiveSchema(directive: ParsedDirective): string;
+/**
+ * Generate directive schemas file from scanned directives
+ */
+declare function generateDirectiveSchemas(nitro: any, directives: any[]): Promise<void>;
+/**
+ * Singleton instance for reuse
+ */
+declare const directiveParser: DirectiveParser;
+//#endregion
+export { DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/utils/directive-parser.js

@@ -0,0 +1,235 @@
+//#region src/utils/directive-parser.ts
+/**
+* Clean AST-based directive parser using oxc-parser
+*/
+var DirectiveParser = class {
+	oxc;
+	async init() {
+		if (!this.oxc) this.oxc = await import("oxc-parser");
+	}
+	/**
+	* Parse directives from a TypeScript/JavaScript file
+	*/
+	async parseDirectives(fileContent, filePath) {
+		await this.init();
+		try {
+			const result = this.oxc.parseSync(filePath, fileContent, {
+				lang: filePath.endsWith(".ts") ? "ts" : "js",
+				sourceType: "module",
+				astType: "ts"
+			});
+			if (result.errors.length > 0) {
+				console.warn(`Parse errors in ${filePath}:`, result.errors.map((e) => e.message));
+				return [];
+			}
+			return this.extractDirectiveDefinitions(result.program);
+		} catch (error) {
+			console.warn(`Failed to parse ${filePath} with oxc:`, error);
+			return [];
+		}
+	}
+	/**
+	* Extract directive definitions from AST
+	*/
+	extractDirectiveDefinitions(program) {
+		const directives = [];
+		this.traverse(program, (node) => {
+			if (this.isDefineDirectiveCall(node)) {
+				const directive = this.extractDirectiveFromCall(node);
+				if (directive) directives.push(directive);
+			}
+		});
+		return directives;
+	}
+	/**
+	* Traverse AST nodes recursively
+	*/
+	traverse(node, visitor) {
+		if (!node || typeof node !== "object") return;
+		visitor(node);
+		for (const key in node) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((item) => this.traverse(item, visitor));
+			else if (child && typeof child === "object") this.traverse(child, visitor);
+		}
+	}
+	/**
+	* Check if node is a defineDirective call
+	*/
+	isDefineDirectiveCall(node) {
+		return node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "defineDirective" && node.arguments?.length > 0;
+	}
+	/**
+	* Extract directive configuration from defineDirective call
+	*/
+	extractDirectiveFromCall(node) {
+		const arg = node.arguments[0];
+		if (arg?.type !== "ObjectExpression") return null;
+		return this.extractDirectiveFromObject(arg);
+	}
+	/**
+	* Extract directive properties from object expression
+	*/
+	extractDirectiveFromObject(objNode) {
+		let name = "";
+		let locations = [];
+		let args = {};
+		let description;
+		let isRepeatable;
+		for (const prop of objNode.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			switch (prop.key.name) {
+				case "name":
+					name = this.extractStringLiteral(prop.value) || "";
+					break;
+				case "locations":
+					locations = this.extractStringArray(prop.value);
+					break;
+				case "args":
+					args = this.extractArgsObject(prop.value);
+					break;
+				case "description":
+					description = this.extractStringLiteral(prop.value);
+					break;
+				case "isRepeatable":
+					isRepeatable = this.extractBooleanLiteral(prop.value);
+					break;
+			}
+		}
+		return name && locations.length > 0 ? {
+			name,
+			locations,
+			args,
+			description,
+			isRepeatable
+		} : null;
+	}
+	/**
+	* Extract string literal value
+	*/
+	extractStringLiteral(node) {
+		if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+		return void 0;
+	}
+	/**
+	* Extract boolean literal value
+	*/
+	extractBooleanLiteral(node) {
+		if (node?.type === "Literal" && typeof node.value === "boolean") return node.value;
+		return void 0;
+	}
+	/**
+	* Extract array of strings
+	*/
+	extractStringArray(node) {
+		if (node?.type !== "ArrayExpression") return [];
+		return (node.elements || []).filter((el) => el?.type === "Literal" && typeof el.value === "string").map((el) => el.value);
+	}
+	/**
+	* Extract arguments object
+	*/
+	extractArgsObject(node) {
+		if (node?.type !== "ObjectExpression") return {};
+		const args = {};
+		for (const prop of node.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			const argName = prop.key.name;
+			const argConfig = this.extractArgConfig(prop.value);
+			if (argConfig) args[argName] = argConfig;
+		}
+		return args;
+	}
+	/**
+	* Extract argument configuration
+	*/
+	extractArgConfig(node) {
+		if (node?.type !== "ObjectExpression") return null;
+		let type = "String";
+		let defaultValue;
+		for (const prop of node.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			switch (prop.key.name) {
+				case "type": {
+					const typeValue = this.extractStringLiteral(prop.value);
+					if (typeValue) type = typeValue;
+					break;
+				}
+				case "defaultValue":
+					defaultValue = this.extractLiteralValue(prop.value);
+					break;
+			}
+		}
+		return {
+			type,
+			...defaultValue !== void 0 && { defaultValue }
+		};
+	}
+	/**
+	* Extract literal value (string, number, boolean)
+	*/
+	extractLiteralValue(node) {
+		if (node?.type === "Literal") return node.value;
+		return void 0;
+	}
+};
+/**
+* Generate GraphQL directive schema from parsed directive
+*/
+function generateDirectiveSchema(directive) {
+	let args = "";
+	if (directive.args && Object.keys(directive.args).length > 0) {
+		const argDefs = Object.entries(directive.args).map(([name, arg]) => {
+			let defaultValue = "";
+			if (arg.defaultValue !== void 0) if (typeof arg.defaultValue === "string") defaultValue = ` = "${arg.defaultValue}"`;
+			else defaultValue = ` = ${arg.defaultValue}`;
+			return `${name}: ${arg.type}${defaultValue}`;
+		});
+		args = `(${argDefs.join(", ")})`;
+	}
+	const locations = directive.locations.join(" | ");
+	return `directive @${directive.name}${args} on ${locations}`;
+}
+/**
+* Generate directive schemas file from scanned directives
+*/
+async function generateDirectiveSchemas(nitro, directives) {
+	if (directives.length === 0) return;
+	const { existsSync, readFileSync, writeFileSync } = await import("node:fs");
+	const { readFile } = await import("node:fs/promises");
+	const { resolve } = await import("pathe");
+	const directiveSchemas = [];
+	const seenDirectives = /* @__PURE__ */ new Set();
+	const parser = new DirectiveParser();
+	for (const dir of directives) for (const _imp of dir.imports) {
+		const fileContent = await readFile(dir.specifier, "utf-8");
+		const directiveDefs = await parser.parseDirectives(fileContent, dir.specifier);
+		for (const def of directiveDefs) {
+			if (seenDirectives.has(def.name)) continue;
+			seenDirectives.add(def.name);
+			const schema = generateDirectiveSchema(def);
+			directiveSchemas.push(schema);
+		}
+	}
+	if (directiveSchemas.length > 0) {
+		const directivesPath = resolve(nitro.graphql.serverDir, "_directives.graphql");
+		const content = `# WARNING: This file is auto-generated by nitro-graphql
+# Do not modify this file directly. It will be overwritten.
+# To define custom directives, create .directive.ts files using defineDirective()
+
+${directiveSchemas.join("\n\n")}`;
+		let shouldWrite = true;
+		if (existsSync(directivesPath)) {
+			const existingContent = readFileSync(directivesPath, "utf-8");
+			shouldWrite = existingContent !== content;
+		}
+		if (shouldWrite) writeFileSync(directivesPath, content, "utf-8");
+		if (!nitro.scanSchemas.includes(directivesPath)) nitro.scanSchemas.push(directivesPath);
+	}
+}
+/**
+* Singleton instance for reuse
+*/
+const directiveParser = new DirectiveParser();
+
+//#endregion
+export { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 import { GenImport } from "../types/index.js";
+import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { Nitro } from "nitropack";
 
 //#region src/utils/index.d.ts
@@ -7,7 +8,7 @@ declare function getImportId(p: string, lazy?: boolean): string;
 declare function relativeWithDot(from: string, to: string): string;
 declare function scanGraphql(nitro: Nitro): Promise<string[]>;
 declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
-declare function scanDirectives(nitro: Nitro): Promise<string[]>;
+declare function scanDirectives(nitro: Nitro): Promise<GenImport[]>;
 declare function scanTypeDefs(nitro: Nitro): Promise<string[]>;
 declare function scanSchemas(nitro: Nitro): Promise<string[]>;
 declare function scanDocs(nitro: Nitro): Promise<string[]>;
@@ -20,4 +21,4 @@ declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patt
  */
 declare function validateExternalServices(services: any[]): string[];
 //#endregion
-export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };

package/dist/utils/index.js

@@ -1,3 +1,4 @@
+import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { join, relative } from "pathe";
 import { readFile } from "node:fs/promises";
 import { hash } from "ohash";
@@ -56,6 +57,11 @@ async function scanResolvers(nitro) {
 						type: "subscription",
 						as: `_${hash(decl.id.name + file.path).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)}`
+					});
 				}
 			}
 		}
@@ -65,7 +71,28 @@ async function scanResolvers(nitro) {
 }
 async function scanDirectives(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.directive.{ts,js}");
-	return files.map((f) => f.fullPath);
+	const exportName = [];
+	for (const file of files) {
+		const fileContent = await readFile(file.fullPath, "utf-8");
+		const parsed = await parseAsync(file.fullPath, fileContent);
+		const exports = {
+			imports: [],
+			specifier: file.fullPath
+		};
+		for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+			for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.init && decl.id.type === "Identifier") {
+				if (decl.init && decl.init.type === "CallExpression") {
+					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)}`
+					});
+				}
+			}
+		}
+		if (exports.imports.length > 0) exportName.push(exports);
+	}
+	return exportName;
 }
 async function scanTypeDefs(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.typedef.{ts,js}");
@@ -77,7 +104,18 @@ async function scanSchemas(nitro) {
 }
 async function scanDocs(nitro) {
 	const files = await scanDir(nitro, nitro.options.rootDir, nitro.graphql.dir.client, "**/*.graphql");
-	return files.filter((f) => !f.path.startsWith("external/")).map((f) => f.fullPath);
+	const externalServices = nitro.options.graphql?.externalServices || [];
+	const externalPatterns = externalServices.flatMap((service) => service.documents || []);
+	return files.filter((f) => !f.path.startsWith("external/")).filter((f) => {
+		const relativePath = f.path;
+		for (const pattern of externalPatterns) {
+			const cleanPattern = pattern.replace(/^app\/graphql\//, "");
+			const patternDir = cleanPattern.split("/")[0];
+			const fileDir = relativePath.split("/")[0];
+			if (patternDir === fileDir) return false;
+		}
+		return true;
+	}).map((f) => f.fullPath);
 }
 /**
 * Scan documents for a specific external service
@@ -112,7 +150,7 @@ function validateExternalServices(services) {
 		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`);
 		else try {
-			const url = new URL(service.endpoint);
+			new URL(service.endpoint);
 		} catch {
 			errors.push(`${prefix}.endpoint "${service.endpoint}" must be a valid URL`);
 		}
@@ -146,4 +184,4 @@ async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, 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

@@ -2,8 +2,8 @@ import { downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes
 import { generateTypes } from "./server-codegen.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import consola from "consola";
-import { dirname, join, resolve } from "pathe";
-import { buildASTSchema, buildSchema } from "graphql";
+import { basename, dirname, join, resolve } from "pathe";
+import { buildSchema, parse } from "graphql";
 import { loadFilesSync } from "@graphql-tools/load-files";
 import { mergeTypeDefs } from "@graphql-tools/merge";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
@@ -89,6 +89,98 @@ export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedServiceName}Gra
 		writeFileSync(ofetchPath, ofetchContent, "utf-8");
 	}
 }
+/**
+* Check for duplicate type definitions using a simpler approach
+* Try to build each schema individually - if that succeeds but merging fails, we have duplicates
+* @returns true if validation passes, false if duplicates found
+*/
+function validateNoDuplicateTypes(schemas, schemaStrings) {
+	const individualSchemasByFile = /* @__PURE__ */ new Map();
+	schemaStrings.forEach((schemaContent, index) => {
+		const schemaPath = schemas[index];
+		const fileName = basename(schemaPath);
+		try {
+			parse(schemaContent);
+			individualSchemasByFile.set(fileName, schemaContent);
+		} catch (error) {
+			consola.warn(`Invalid GraphQL syntax in ${fileName}:`, error);
+			throw error;
+		}
+	});
+	try {
+		mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: false,
+			commentDescriptions: true,
+			sort: true
+		});
+		mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+	} catch (conflictError) {
+		if (conflictError?.message?.includes("already defined with a different type")) throw conflictError;
+	}
+	const typeNames = /* @__PURE__ */ new Set();
+	const duplicateTypes = [];
+	schemaStrings.forEach((schemaContent, index) => {
+		const fileName = basename(schemas[index]);
+		try {
+			const document = parse(schemaContent);
+			document.definitions.forEach((def) => {
+				if (def.kind === "ObjectTypeDefinition" || def.kind === "InterfaceTypeDefinition" || def.kind === "UnionTypeDefinition" || def.kind === "EnumTypeDefinition" || def.kind === "InputObjectTypeDefinition" || def.kind === "ScalarTypeDefinition") {
+					const typeName = def.name.value;
+					if ([
+						"String",
+						"Int",
+						"Float",
+						"Boolean",
+						"ID",
+						"DateTime",
+						"JSON"
+					].includes(typeName)) return;
+					if (typeNames.has(typeName)) {
+						const existing = duplicateTypes.find((d) => d.type === typeName);
+						if (existing) existing.files.push(fileName);
+						else {
+							const firstFile = schemas.find((_, i) => {
+								const content = schemaStrings[i];
+								if (!content) return false;
+								try {
+									const doc = parse(content);
+									return doc.definitions.some((d) => (d.kind === "ObjectTypeDefinition" || d.kind === "InterfaceTypeDefinition" || d.kind === "UnionTypeDefinition" || d.kind === "EnumTypeDefinition" || d.kind === "InputObjectTypeDefinition" || d.kind === "ScalarTypeDefinition") && d.name.value === typeName);
+								} catch {
+									return false;
+								}
+							});
+							duplicateTypes.push({
+								type: typeName,
+								files: [basename(firstFile || ""), fileName]
+							});
+						}
+					} else typeNames.add(typeName);
+				}
+			});
+		} catch {}
+	});
+	if (duplicateTypes.length > 0) {
+		let errorMessage = "⚠️  DUPLICATE TYPE DEFINITIONS DETECTED!\n\n";
+		duplicateTypes.forEach(({ type, files }) => {
+			errorMessage += `❌ Type "${type}" is defined in multiple files:\n`;
+			files.forEach((fileName) => {
+				const fullPath = schemas.find((path) => basename(path) === fileName) || fileName;
+				errorMessage += `   • ${fullPath}\n`;
+			});
+			errorMessage += "\n";
+		});
+		errorMessage += "💡 Each GraphQL type should only be defined once.\n";
+		errorMessage += "   Consider using \"extend type\" syntax instead of duplicate definitions.\n";
+		errorMessage += `\n🔍 Found ${duplicateTypes.length} duplicate type(s): ${duplicateTypes.map((d) => d.type).join(", ")}`;
+		consola.error(errorMessage);
+		return false;
+	}
+	return true;
+}
 async function serverTypeGeneration(app) {
 	try {
 		const schemas = app.scanSchemas || [];
@@ -97,12 +189,40 @@ async function serverTypeGeneration(app) {
 			return;
 		}
 		const loadSchemas = loadFilesSync(schemas);
-		const mergedSchemas = mergeTypeDefs(loadSchemas);
-		const schema = buildASTSchema(mergedSchemas, {
-			assumeValidSDL: true,
-			assumeValid: true
+		const schemaStrings = loadSchemas.map((schema$1) => typeof schema$1 === "string" ? schema$1 : schema$1.loc?.source?.body || "").filter(Boolean);
+		const isValid = validateNoDuplicateTypes(schemas, schemaStrings);
+		if (!isValid) return;
+		const mergedSchemasString = schemaStrings.join("\n\n");
+		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 data = await generateTypes(app.options.graphql?.framework || "graphql-yoga", schema, app.options.graphql?.codegen?.server ?? {});
+		const schema = buildSchema(mergedSchemas);
+		const data = await generateTypes(app.options.graphql?.framework || "graphql-yoga", schema, app.options.graphql ?? {});
 		const printSchema = printSchemaWithDirectives(schema);
 		const schemaPath = resolve(app.graphql.buildDir, "schema.graphql");
 		mkdirSync(dirname(schemaPath), { recursive: true });