nitro-graphql 2.0.0-beta.31 → 2.0.0-beta.33

package/dist/utils/ofetch-templates.mjs

@@ -0,0 +1,135 @@
+//#region src/utils/ofetch-templates.ts
+/**
+* Capitalize first letter of a string
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+* Generate ofetch client template content
+*
+* For main (default) service:
+* - SDK exported as `$sdk`
+* - Client function is `createGraphQLClient`
+*
+* For external services:
+* - SDK exported as `$${serviceName}Sdk`
+* - Client function is `create${ServiceName}GraphQLClient`
+* - Endpoint has default value
+*/
+function generateOfetchTemplate(options) {
+	const { serviceName, isNuxt, endpoint, isExternal = false } = options;
+	if (isExternal) return generateExternalOfetchTemplate({
+		serviceName,
+		isNuxt,
+		endpoint
+	});
+	return generateMainOfetchTemplate({
+		isNuxt,
+		endpoint
+	});
+}
+/**
+* Generate ofetch template for main (default) GraphQL service
+*/
+function generateMainOfetchTemplate(options) {
+	const { isNuxt, endpoint } = options;
+	if (isNuxt) return `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Requester } from './sdk'
+import { getSdk } from './sdk'
+
+export function createGraphQLClient(endpoint: string): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const headers = import.meta.server ? useRequestHeaders() : undefined
+
+    const result = await $fetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $sdk = getSdk(createGraphQLClient('${endpoint}'))`;
+	return `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Requester } from './sdk'
+import { ofetch } from 'ofetch'
+import { getSdk } from './sdk'
+
+export function createGraphQLClient(endpoint: string): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const result = await ofetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $sdk = getSdk(createGraphQLClient('${endpoint}'))`;
+}
+/**
+* Generate ofetch template for external GraphQL service
+*/
+function generateExternalOfetchTemplate(options) {
+	const { serviceName, isNuxt, endpoint } = options;
+	const capitalizedName = capitalize(serviceName);
+	if (isNuxt) return `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Sdk, Requester } from './sdk'
+import { getSdk } from './sdk'
+
+export function create${capitalizedName}GraphQLClient(endpoint: string = '${endpoint}'): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const headers = import.meta.server ? useRequestHeaders() : undefined
+
+    const result = await $fetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedName}GraphQLClient())`;
+	return `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Sdk, Requester } from './sdk'
+import { ofetch } from 'ofetch'
+import { getSdk } from './sdk'
+
+export function create${capitalizedName}GraphQLClient(endpoint: string = '${endpoint}'): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const result = await ofetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedName}GraphQLClient())`;
+}
+
+//#endregion
+export { generateOfetchTemplate };

package/dist/utils/path-resolver.d.mts

@@ -53,7 +53,7 @@ declare function getClientUtilsConfig(nitro: Nitro): ClientUtilsConfig;
 /**
  * Check if SDK files should be generated (category-level check)
  */
-declare function shouldGenerateSDK(nitro: Nitro): boolean;
+declare function shouldGenerateSdk(nitro: Nitro): boolean;
 /**
  * Get SDK configuration (handles false case)
  */
@@ -67,4 +67,4 @@ declare function shouldGenerateTypes(nitro: Nitro): boolean;
  */
 declare function getTypesConfig(nitro: Nitro): TypesConfig;
 //#endregion
-export { PathPlaceholders, getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateSDK, shouldGenerateScaffold, shouldGenerateTypes };
+export { PathPlaceholders, getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateScaffold, shouldGenerateSdk, shouldGenerateTypes };

package/dist/utils/path-resolver.mjs

@@ -91,7 +91,7 @@ function getClientUtilsConfig(nitro) {
 /**
 * Check if SDK files should be generated (category-level check)
 */
-function shouldGenerateSDK(nitro) {
+function shouldGenerateSdk(nitro) {
 	const sdkConfig = nitro.options.graphql?.sdk;
 	if (sdkConfig === false) return false;
 	if (sdkConfig && sdkConfig.enabled === false) return false;
@@ -124,4 +124,4 @@ function getTypesConfig(nitro) {
 }
 
 //#endregion
-export { getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateSDK, shouldGenerateScaffold, shouldGenerateTypes };
+export { getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateScaffold, shouldGenerateSdk, shouldGenerateTypes };

package/dist/utils/scanning/common.d.mts

@@ -0,0 +1,23 @@
+import { Nitro } from "nitro/types";
+
+//#region src/utils/scanning/common.d.ts
+
+/**
+ * File information returned from scanning operations
+ */
+interface FileInfo {
+  path: string;
+  fullPath: string;
+}
+/**
+ * Scan a directory for files matching a glob pattern
+ */
+declare function scanDir(nitro: Nitro, dir: string, name: string, globPattern?: string): Promise<FileInfo[]>;
+/**
+ * Deduplicate files by fullPath
+ */
+declare function deduplicateFiles<T extends {
+  fullPath: string;
+}>(files: T[]): T[];
+//#endregion
+export { FileInfo, deduplicateFiles, scanDir };

package/dist/utils/scanning/common.mjs

@@ -0,0 +1,39 @@
+import { GLOB_SCAN_PATTERN } from "../../constants.mjs";
+import { join, relative } from "pathe";
+import { glob } from "tinyglobby";
+
+//#region src/utils/scanning/common.ts
+/**
+* Scan a directory for files matching a glob pattern
+*/
+async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
+	return (await glob(join(name, globPattern), {
+		cwd: dir,
+		dot: true,
+		ignore: nitro.options.ignore,
+		absolute: true
+	}).catch((error) => {
+		if (error?.code === "ENOTDIR") {
+			nitro.logger.warn(`Ignoring \`${join(dir, name)}\`. It must be a directory.`);
+			return [];
+		}
+		throw error;
+	})).map((fullPath) => ({
+		fullPath,
+		path: relative(join(dir, name), fullPath)
+	})).sort((a, b) => a.path.localeCompare(b.path));
+}
+/**
+* Deduplicate files by fullPath
+*/
+function deduplicateFiles(files) {
+	const seenPaths = /* @__PURE__ */ new Set();
+	return files.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	});
+}
+
+//#endregion
+export { deduplicateFiles, scanDir };

package/dist/utils/scanning/directives.d.mts

@@ -0,0 +1,11 @@
+import { GenImport } from "../../types/index.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/utils/scanning/directives.d.ts
+
+/**
+ * Scan for directive files and parse their exports
+ */
+declare function scanDirectives(nitro: Nitro): Promise<GenImport[]>;
+//#endregion
+export { scanDirectives };

package/dist/utils/scanning/directives.mjs

@@ -0,0 +1,43 @@
+import { getLayerServerDirectories } from "../layers.mjs";
+import { deduplicateFiles, scanDir } from "./common.mjs";
+import { readFile } from "node:fs/promises";
+import { relative } from "pathe";
+import { hash } from "ohash";
+import { parseSync } from "oxc-parser";
+
+//#region src/utils/scanning/directives.ts
+/**
+* Scan for directive files and parse their exports
+*/
+async function scanDirectives(nitro) {
+	const serverDirRelative = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+	const regularFiles = await scanDir(nitro, nitro.options.rootDir, serverDirRelative, "**/*.directive.{ts,js}");
+	const layerServerDirs = getLayerServerDirectories(nitro);
+	const layerFiles = await Promise.all(layerServerDirs.map((layerServerDir) => scanDir(nitro, layerServerDir, "graphql", "**/*.directive.{ts,js}"))).then((r) => r.flat());
+	const files = deduplicateFiles([...regularFiles, ...layerFiles]);
+	const exportName = [];
+	for (const file of files) {
+		const fileContent = await readFile(file.fullPath, "utf-8");
+		const parsed = parseSync(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.fullPath).replace(/-/g, "").slice(0, 6)}`
+					});
+				}
+			}
+		}
+		if (exports.imports.length > 0) exportName.push(exports);
+	}
+	return exportName;
+}
+
+//#endregion
+export { scanDirectives };

package/dist/utils/scanning/documents.d.mts

@@ -0,0 +1,15 @@
+import { Nitro } from "nitro/types";
+
+//#region src/utils/scanning/documents.d.ts
+
+/**
+ * Scan for GraphQL client documents (.graphql) in client directory
+ * Excludes files from external service directories
+ */
+declare function scanDocuments(nitro: Nitro): Promise<string[]>;
+/**
+ * Scan documents for a specific external service
+ */
+declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patterns: string[]): Promise<string[]>;
+//#endregion
+export { scanDocuments, scanExternalServiceDocs };

package/dist/utils/scanning/documents.mjs

@@ -0,0 +1,46 @@
+import { getLayerAppDirectories } from "../layers.mjs";
+import { deduplicateFiles, scanDir } from "./common.mjs";
+import { glob } from "tinyglobby";
+
+//#region src/utils/scanning/documents.ts
+/**
+* Scan for GraphQL client documents (.graphql) in client directory
+* Excludes files from external service directories
+*/
+async function scanDocuments(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 allFiles = deduplicateFiles([...files, ...layerFiles]);
+	const externalPatterns = (nitro.options.graphql?.externalServices || []).flatMap((service) => service.documents || []);
+	return allFiles.filter((f) => !f.path.startsWith("external/")).filter((f) => {
+		const relativePath = f.path;
+		for (const pattern of externalPatterns) {
+			const clientDirPattern = `${nitro.graphql.dir.client}/`;
+			if (pattern.replace(/* @__PURE__ */ new RegExp(`^${clientDirPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), "").split("/")[0] === relativePath.split("/")[0]) return false;
+		}
+		return true;
+	}).map((f) => f.fullPath);
+}
+/**
+* Scan documents for a specific external service
+*/
+async function scanExternalServiceDocs(nitro, serviceName, patterns) {
+	if (!patterns.length) return [];
+	const files = [];
+	for (const pattern of patterns) try {
+		const serviceFiles = await glob(pattern, {
+			cwd: nitro.options.rootDir,
+			dot: true,
+			ignore: nitro.options.ignore,
+			absolute: true
+		});
+		files.push(...serviceFiles);
+	} catch (error) {
+		nitro.logger.warn(`[graphql:${serviceName}] Error scanning documents with pattern "${pattern}":`, error);
+	}
+	return files.filter((file, index, self) => self.indexOf(file) === index);
+}
+
+//#endregion
+export { scanDocuments, scanExternalServiceDocs };

package/dist/utils/scanning/index.d.mts

@@ -0,0 +1,6 @@
+import { FileInfo, deduplicateFiles, scanDir } from "./common.mjs";
+import { scanDirectives } from "./directives.mjs";
+import { scanDocuments, scanExternalServiceDocs } from "./documents.mjs";
+import { scanResolvers } from "./resolvers.mjs";
+import { scanGraphql, scanSchemas } from "./schemas.mjs";
+export { type FileInfo, deduplicateFiles, scanDir, scanDirectives, scanDocuments, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas };

package/dist/utils/scanning/index.mjs

@@ -0,0 +1,7 @@
+import { deduplicateFiles, scanDir } from "./common.mjs";
+import { scanDirectives } from "./directives.mjs";
+import { scanDocuments, scanExternalServiceDocs } from "./documents.mjs";
+import { scanResolvers } from "./resolvers.mjs";
+import { scanGraphql, scanSchemas } from "./schemas.mjs";
+
+export { deduplicateFiles, scanDir, scanDirectives, scanDocuments, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas };

package/dist/utils/scanning/resolvers.d.mts

@@ -0,0 +1,11 @@
+import { GenImport } from "../../types/index.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/utils/scanning/resolvers.d.ts
+
+/**
+ * Scan for resolver files and parse their exports
+ */
+declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
+//#endregion
+export { scanResolvers };

package/dist/utils/scanning/resolvers.mjs

@@ -0,0 +1,100 @@
+import { DEFINE_FUNCTIONS } from "../../constants.mjs";
+import { getLayerServerDirectories } from "../layers.mjs";
+import { deduplicateFiles, scanDir } from "./common.mjs";
+import { readFile } from "node:fs/promises";
+import { basename, relative } from "pathe";
+import { hash } from "ohash";
+import { parseSync } from "oxc-parser";
+
+//#region src/utils/scanning/resolvers.ts
+/**
+* Scan for resolver files and parse their exports
+*/
+async function scanResolvers(nitro) {
+	const serverDirRelative = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+	const regularFiles = await scanDir(nitro, nitro.options.rootDir, serverDirRelative, "**/*.resolver.{ts,js}");
+	const layerServerDirs = getLayerServerDirectories(nitro);
+	const layerFiles = await Promise.all(layerServerDirs.map((layerServerDir) => scanDir(nitro, layerServerDir, "graphql", "**/*.resolver.{ts,js}"))).then((r) => r.flat());
+	const files = deduplicateFiles([...regularFiles, ...layerFiles]);
+	const exportName = [];
+	for (const file of files) try {
+		const fileContent = await readFile(file.fullPath, "utf-8");
+		const parsed = parseSync(file.fullPath, fileContent);
+		if (parsed.errors && parsed.errors.length > 0) {
+			if (nitro.options.dev) {
+				const fileName = basename(file.fullPath);
+				const firstError = parsed.errors[0];
+				const location = firstError?.labels?.[0];
+				const lineInfo = location ? `:${location.start}` : "";
+				const message = firstError?.message.split(",")[0] || "Syntax error";
+				console.error(`✖ ${fileName}${lineInfo} - ${message}`);
+			}
+			continue;
+		}
+		const exports = {
+			imports: [],
+			specifier: file.fullPath
+		};
+		let hasDefaultExport = false;
+		let hasNamedExport = false;
+		const namedExports = [];
+		for (const node of parsed.program.body) {
+			if (node.type === "ExportDefaultDeclaration") hasDefaultExport = true;
+			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") {
+					hasNamedExport = true;
+					namedExports.push(decl.id.name);
+					if (decl.init && decl.init.type === "CallExpression") {
+						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.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.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.fullPath).replace(/-/g, "").slice(0, 6)}`
+						});
+						if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineField") exports.imports.push({
+							name: decl.id.name,
+							type: "type",
+							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.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.fullPath).replace(/-/g, "").slice(0, 6)}`
+						});
+					}
+				}
+			}
+		}
+		if (nitro.options.dev) {
+			const relPath = relative(nitro.options.rootDir, file.fullPath);
+			if (hasDefaultExport && !hasNamedExport) nitro.logger.warn(`[nitro-graphql] ${relPath}: Using default export instead of named export. Resolvers must use named exports like "export const myResolver = defineQuery(...)". Default exports are not detected.`);
+			if (exports.imports.length === 0 && hasNamedExport) {
+				const validFunctions = DEFINE_FUNCTIONS.join(", ");
+				nitro.logger.warn(`[nitro-graphql] ${relPath}: File has named exports [${namedExports.join(", ")}] but none use the required define functions (${validFunctions}). Exports will not be registered.`);
+			}
+			if (!hasDefaultExport && !hasNamedExport) nitro.logger.warn(`[nitro-graphql] ${relPath}: No exports found. Resolver files must export resolvers using defineResolver, defineQuery, defineMutation, etc.`);
+		}
+		if (exports.imports.length > 0) exportName.push(exports);
+	} catch (error) {
+		const relPath = relative(nitro.options.rootDir, file.fullPath);
+		nitro.logger.error(`[nitro-graphql] Failed to parse resolver file ${relPath}:`, error);
+	}
+	return exportName;
+}
+
+//#endregion
+export { scanResolvers };

package/dist/utils/scanning/schemas.d.mts

@@ -0,0 +1,15 @@
+import { Nitro } from "nitro/types";
+
+//#region src/utils/scanning/schemas.d.ts
+
+/**
+ * Scan for GraphQL schema files (.graphql) in server directory
+ */
+declare function scanSchemas(nitro: Nitro): Promise<string[]>;
+/**
+ * Scan for GraphQL files (.graphql, .gql) in server directory
+ * Similar to scanSchemas but includes .gql extension
+ */
+declare function scanGraphql(nitro: Nitro): Promise<string[]>;
+//#endregion
+export { scanGraphql, scanSchemas };

package/dist/utils/scanning/schemas.mjs

@@ -0,0 +1,29 @@
+import { getLayerServerDirectories } from "../layers.mjs";
+import { deduplicateFiles, scanDir } from "./common.mjs";
+import { relative } from "pathe";
+
+//#region src/utils/scanning/schemas.ts
+/**
+* Scan for GraphQL schema files (.graphql) in server directory
+*/
+async function scanSchemas(nitro) {
+	const serverDirRelative = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+	const files = await scanDir(nitro, nitro.options.rootDir, serverDirRelative, "**/*.graphql");
+	const layerServerDirs = getLayerServerDirectories(nitro);
+	const layerFiles = await Promise.all(layerServerDirs.map((layerServerDir) => scanDir(nitro, layerServerDir, "graphql", "**/*.graphql"))).then((r) => r.flat());
+	return deduplicateFiles([...files, ...layerFiles]).map((f) => f.fullPath);
+}
+/**
+* Scan for GraphQL files (.graphql, .gql) in server directory
+* Similar to scanSchemas but includes .gql extension
+*/
+async function scanGraphql(nitro) {
+	const serverDirRelative = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+	const files = await scanDir(nitro, nitro.options.rootDir, serverDirRelative, "**/*.{graphql,gql}");
+	const layerServerDirs = getLayerServerDirectories(nitro);
+	const layerFiles = await Promise.all(layerServerDirs.map((layerServerDir) => scanDir(nitro, layerServerDir, "graphql", "**/*.{graphql,gql}"))).then((r) => r.flat());
+	return deduplicateFiles([...files, ...layerFiles]).map((f) => f.fullPath);
+}
+
+//#endregion
+export { scanGraphql, scanSchemas };

package/dist/utils/schema-builder.d.mts

@@ -0,0 +1,48 @@
+import { DirectiveDefinition } from "../types/define.mjs";
+import { GraphQLSchema } from "graphql";
+
+//#region src/utils/schema-builder.d.ts
+
+/**
+ * Schema definition from virtual module
+ */
+interface SchemaDefinition {
+  def: string;
+}
+/**
+ * Resolver definition from virtual module
+ */
+interface ResolverDefinition {
+  resolver: Record<string, unknown>;
+}
+/**
+ * Directive wrapper from virtual module
+ */
+interface DirectiveWrapper {
+  directive: DirectiveDefinition;
+}
+/**
+ * Module configuration for federation
+ */
+interface ModuleConfig {
+  federation?: {
+    enabled?: boolean;
+    serviceName?: string;
+  };
+}
+/**
+ * Options for creating a merged schema
+ */
+interface CreateMergedSchemaOptions {
+  schemas: SchemaDefinition[];
+  resolvers: ResolverDefinition[];
+  directives?: DirectiveWrapper[];
+  moduleConfig: ModuleConfig;
+}
+/**
+ * Create a merged GraphQL schema from schemas, resolvers, and directives
+ * Supports Apollo Federation when enabled
+ */
+declare function createMergedSchema(options: CreateMergedSchemaOptions): Promise<GraphQLSchema>;
+//#endregion
+export { CreateMergedSchemaOptions, DirectiveWrapper, ModuleConfig, ResolverDefinition, SchemaDefinition, createMergedSchema };

package/dist/utils/schema-builder.mjs

@@ -0,0 +1,51 @@
+import { loadFederationSupport, warnFederationUnavailable } from "./federation.mjs";
+import { consola as consola$1 } from "consola";
+import { parse } from "graphql";
+import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+
+//#region src/utils/schema-builder.ts
+/**
+* Create a merged GraphQL schema from schemas, resolvers, and directives
+* Supports Apollo Federation when enabled
+*/
+async function createMergedSchema(options) {
+	const { schemas, resolvers, directives, moduleConfig } = options;
+	try {
+		const typeDefs = mergeTypeDefs([schemas.map((schema$1) => schema$1.def).join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
+		const federationEnabled = moduleConfig.federation?.enabled;
+		let schema;
+		if (federationEnabled) {
+			const buildSubgraph = await loadFederationSupport();
+			if (buildSubgraph) schema = buildSubgraph({
+				typeDefs: typeof typeDefs === "string" ? parse(typeDefs) : typeDefs,
+				resolvers: mergedResolvers
+			});
+			else {
+				warnFederationUnavailable();
+				schema = makeExecutableSchema({
+					typeDefs,
+					resolvers: mergedResolvers
+				});
+			}
+		} else schema = makeExecutableSchema({
+			typeDefs,
+			resolvers: mergedResolvers
+		});
+		if (directives && directives.length > 0) {
+			for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
+		}
+		return schema;
+	} catch (error) {
+		consola$1.error("Schema merge error:", error);
+		throw error;
+	}
+}
+
+//#endregion
+export { createMergedSchema };

package/dist/utils/server-codegen.mjs

@@ -1,40 +1,17 @@
+import { DEFAULT_GRAPHQL_SCALARS } from "../constants/scalars.mjs";
+import { pluginContent } from "./codegen-plugin.mjs";
 import { defu as defu$1 } from "defu";
 import consola from "consola";
 import { parse } from "graphql";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
 import { codegen } from "@graphql-codegen/core";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
-import { CurrencyResolver, DateTimeISOResolver, DateTimeResolver, JSONObjectResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
 import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
 
 //#region src/utils/server-codegen.ts
-function pluginContent(_schema, _documents, _config, _info) {
-	return {
-		prepend: [
-			"// THIS FILE IS GENERATED, DO NOT EDIT!",
-			"/* eslint-disable eslint-comments/no-unlimited-disable */",
-			"/* tslint:disable */",
-			"/* eslint-disable */",
-			"/* prettier-ignore */"
-		],
-		content: ""
-	};
-}
 async function generateTypes(selectFremework, schema, config = {}, outputPath) {
 	const mergedConfig = defu$1({
-		scalars: {
-			DateTime: DateTimeResolver.extensions.codegenScalarType,
-			DateTimeISO: DateTimeISOResolver.extensions.codegenScalarType,
-			UUID: UUIDResolver.extensions.codegenScalarType,
-			JSON: JSONResolver.extensions.codegenScalarType,
-			JSONObject: JSONObjectResolver.extensions.codegenScalarType,
-			NonEmptyString: NonEmptyStringResolver.extensions.codegenScalarType,
-			Currency: CurrencyResolver.extensions.codegenScalarType,
-			File: {
-				input: "File",
-				output: "File"
-			}
-		},
+		scalars: DEFAULT_GRAPHQL_SCALARS,
 		defaultScalarType: "unknown",
 		defaultMapper: `ResolverReturnType<{T}>`,
 		contextType: "nitro/h3#H3Event",