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

package/dist/utils/directive-parser.mjs

@@ -181,9 +181,10 @@ function generateDirectiveSchema(directive) {
 }
 /**
 * Generate directive schemas file from scanned directives
+* @returns The path to the generated _directives.graphql file, or null if no directives
 */
 async function generateDirectiveSchemas(nitro, directives) {
-	if (directives.length === 0) return;
+	if (directives.length === 0) return null;
 	const { existsSync, readFileSync, writeFileSync, mkdirSync } = await import("node:fs");
 	const { readFile } = await import("node:fs/promises");
 	const { resolve, dirname } = await import("pathe");
@@ -212,8 +213,9 @@ ${directiveSchemas.join("\n\n")}`;
 		let shouldWrite = true;
 		if (existsSync(directivesPath)) shouldWrite = readFileSync(directivesPath, "utf-8") !== content;
 		if (shouldWrite) writeFileSync(directivesPath, content, "utf-8");
-		if (!nitro.scanSchemas.includes(directivesPath)) nitro.scanSchemas.push(directivesPath);
+		return directivesPath;
 	}
+	return null;
 }
 /**
 * Singleton instance for reuse

package/dist/utils/federation.d.mts

@@ -0,0 +1,29 @@
+import { DocumentNode, GraphQLSchema } from "graphql";
+
+//#region src/utils/federation.d.ts
+
+/**
+ * Type for buildSubgraphSchema function from @apollo/subgraph
+ */
+type BuildSubgraphSchemaFn = (options: {
+  typeDefs: DocumentNode;
+  resolvers: Record<string, unknown>;
+}) => GraphQLSchema;
+/**
+ * Dynamically load @apollo/subgraph for federation support.
+ * Returns the buildSubgraphSchema function if available, or false if the package is not installed.
+ * Result is cached for subsequent calls.
+ */
+declare function loadFederationSupport(): Promise<BuildSubgraphSchemaFn | false>;
+/**
+ * Log a warning when federation is enabled but @apollo/subgraph is not available.
+ * Uses consola logger instead of console.warn for consistent logging.
+ */
+declare function warnFederationUnavailable(): void;
+/**
+ * Reset the federation support cache.
+ * Useful for testing or when the module needs to be reloaded.
+ */
+declare function resetFederationCache(): void;
+//#endregion
+export { loadFederationSupport, resetFederationCache, warnFederationUnavailable };

package/dist/utils/federation.mjs

@@ -0,0 +1,40 @@
+import { LOG_TAG } from "../constants.mjs";
+import { consola as consola$1 } from "consola";
+
+//#region src/utils/federation.ts
+const logger = consola$1.withTag(LOG_TAG);
+/**
+* Cached result: function if available, false if not available, null if not checked yet
+*/
+let buildSubgraphSchemaCache = null;
+/**
+* Dynamically load @apollo/subgraph for federation support.
+* Returns the buildSubgraphSchema function if available, or false if the package is not installed.
+* Result is cached for subsequent calls.
+*/
+async function loadFederationSupport() {
+	if (buildSubgraphSchemaCache !== null) return buildSubgraphSchemaCache;
+	try {
+		buildSubgraphSchemaCache = (await import("@apollo/subgraph")).buildSubgraphSchema;
+	} catch {
+		buildSubgraphSchemaCache = false;
+	}
+	return buildSubgraphSchemaCache;
+}
+/**
+* Log a warning when federation is enabled but @apollo/subgraph is not available.
+* Uses consola logger instead of console.warn for consistent logging.
+*/
+function warnFederationUnavailable() {
+	logger.warn("Federation enabled but @apollo/subgraph not available, falling back to regular schema");
+}
+/**
+* Reset the federation support cache.
+* Useful for testing or when the module needs to be reloaded.
+*/
+function resetFederationCache() {
+	buildSubgraphSchemaCache = null;
+}
+
+//#endregion
+export { loadFederationSupport, resetFederationCache, warnFederationUnavailable };

package/dist/utils/file-generator.mjs

@@ -1,6 +1,6 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import consola from "consola";
 import { dirname } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 
 //#region src/utils/file-generator.ts
 /**

package/dist/utils/file-writer.d.mts

@@ -0,0 +1,35 @@
+import { PathPlaceholders } from "./path-resolver.mjs";
+
+//#region src/utils/file-writer.d.ts
+
+/**
+ * Options for writing generated files
+ */
+interface WriteGeneratedFileOptions {
+  /** Path configuration (string path, boolean, or undefined) */
+  pathConfig: string | boolean | undefined;
+  /** Whether the category is enabled */
+  categoryEnabled: boolean | undefined;
+  /** Default path template with placeholders */
+  defaultPath: string;
+  /** Content to write */
+  content: string;
+  /** Path placeholders for resolution */
+  placeholders: PathPlaceholders;
+  /** Description for logging (e.g., "client types", "SDK") */
+  description: string;
+  /** Whether to suppress success logs */
+  silent?: boolean;
+}
+/**
+ * Write a generated file with path resolution and directory creation
+ * Returns the resolved path if file was written, undefined otherwise
+ */
+declare function writeGeneratedFile(options: WriteGeneratedFileOptions): string | undefined;
+/**
+ * Write multiple generated files
+ * Returns array of resolved paths for files that were written
+ */
+declare function writeGeneratedFiles(files: WriteGeneratedFileOptions[]): (string | undefined)[];
+//#endregion
+export { WriteGeneratedFileOptions, writeGeneratedFile, writeGeneratedFiles };

package/dist/utils/file-writer.mjs

@@ -0,0 +1,32 @@
+import { LOG_TAG } from "../constants.mjs";
+import { resolveFilePath } from "./path-resolver.mjs";
+import consola from "consola";
+import { dirname } from "pathe";
+import { mkdirSync, writeFileSync } from "node:fs";
+
+//#region src/utils/file-writer.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Write a generated file with path resolution and directory creation
+* Returns the resolved path if file was written, undefined otherwise
+*/
+function writeGeneratedFile(options) {
+	const { pathConfig, categoryEnabled, defaultPath, content, placeholders, description, silent = false } = options;
+	const resolvedPath = resolveFilePath(pathConfig, categoryEnabled, true, defaultPath, placeholders);
+	if (resolvedPath) {
+		mkdirSync(dirname(resolvedPath), { recursive: true });
+		writeFileSync(resolvedPath, content, "utf-8");
+		if (!silent) logger.success(`Generated ${description} at: ${resolvedPath}`);
+		return resolvedPath;
+	}
+}
+/**
+* Write multiple generated files
+* Returns array of resolved paths for files that were written
+*/
+function writeGeneratedFiles(files) {
+	return files.map((file) => writeGeneratedFile(file));
+}
+
+//#endregion
+export { writeGeneratedFile, writeGeneratedFiles };

package/dist/utils/imports.d.mts

@@ -0,0 +1,15 @@
+//#region src/utils/imports.d.ts
+/**
+ * Import utilities
+ * Helpers for generating import IDs and relative paths
+ */
+/**
+ * Generate a unique import ID for a file path
+ */
+declare function getImportId(p: string, lazy?: boolean): string;
+/**
+ * Get relative path with a leading dot for module resolution
+ */
+declare function relativeWithDot(from: string, to: string): string;
+//#endregion
+export { getImportId, relativeWithDot };

package/dist/utils/imports.mjs

@@ -0,0 +1,25 @@
+import { relative } from "pathe";
+import { hash } from "ohash";
+
+//#region src/utils/imports.ts
+/**
+* Import utilities
+* Helpers for generating import IDs and relative paths
+*/
+/**
+* Generate a unique import ID for a file path
+*/
+function getImportId(p, lazy) {
+	return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
+}
+const RELATIVE_RE = /^\.{1,2}\//;
+/**
+* Get relative path with a leading dot for module resolution
+*/
+function relativeWithDot(from, to) {
+	const rel = relative(from, to);
+	return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
+}
+
+//#endregion
+export { getImportId, relativeWithDot };

package/dist/utils/index.d.mts

@@ -1,40 +1,13 @@
-import { GenImport } from "../types/index.mjs";
 import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
 import { createDefaultMaskError } from "./errors.mjs";
-import { Nitro } from "nitro/types";
-
-//#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(): string[];
-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<GenImport[]>;
-declare function scanSchemas(nitro: Nitro): Promise<string[]>;
-declare function scanDocs(nitro: Nitro): Promise<string[]>;
-/**
- * Scan documents for a specific external service
- */
-declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patterns: string[]): Promise<string[]>;
-/**
- * Validate external GraphQL service configuration
- */
-declare function validateExternalServices(services: unknown[]): string[];
-//#endregion
-export { GLOB_SCAN_PATTERN, createDefaultMaskError, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };
+import { loadFederationSupport, resetFederationCache, warnFederationUnavailable } from "./federation.mjs";
+import { getImportId, relativeWithDot } from "./imports.mjs";
+import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories } from "./layers.mjs";
+import { FileInfo, deduplicateFiles, scanDir } from "./scanning/common.mjs";
+import { scanDirectives } from "./scanning/directives.mjs";
+import { scanDocuments, scanExternalServiceDocs } from "./scanning/documents.mjs";
+import { scanResolvers } from "./scanning/resolvers.mjs";
+import { scanGraphql, scanSchemas } from "./scanning/schemas.mjs";
+import "./scanning/index.mjs";
+import { validateExternalServices } from "./validation.mjs";
+export { type FileInfo, createDefaultMaskError, deduplicateFiles, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, loadFederationSupport, relativeWithDot, resetFederationCache, scanDir, scanDirectives, scanDocuments, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices, warnFederationUnavailable };

package/dist/utils/index.mjs

@@ -1,290 +1,13 @@
+import { loadFederationSupport, resetFederationCache, warnFederationUnavailable } from "./federation.mjs";
 import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
 import { createDefaultMaskError } from "./errors.mjs";
-import { readFile } from "node:fs/promises";
-import { basename, join, relative } from "pathe";
-import { hash } from "ohash";
-import { parseSync } from "oxc-parser";
-import { glob } from "tinyglobby";
+import { getImportId, relativeWithDot } from "./imports.mjs";
+import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories } from "./layers.mjs";
+import { deduplicateFiles, scanDir } from "./scanning/common.mjs";
+import { scanDirectives } from "./scanning/directives.mjs";
+import { scanDocuments, scanExternalServiceDocs } from "./scanning/documents.mjs";
+import { scanResolvers } from "./scanning/resolvers.mjs";
+import { scanGraphql, scanSchemas } from "./scanning/schemas.mjs";
+import { validateExternalServices } from "./validation.mjs";
 
-//#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() {
-	return [];
-}
-function getImportId(p, lazy) {
-	return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
-}
-const RELATIVE_RE = /^\.{1,2}\//;
-function relativeWithDot(from, to) {
-	const rel = relative(from, to);
-	return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
-}
-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());
-	const allFiles = [...files, ...layerFiles];
-	const seenPaths = /* @__PURE__ */ new Set();
-	return allFiles.filter((file) => {
-		if (seenPaths.has(file.fullPath)) return false;
-		seenPaths.add(file.fullPath);
-		return true;
-	}).map((f) => f.fullPath);
-}
-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 allFiles = [...regularFiles, ...layerFiles];
-	const seenPaths = /* @__PURE__ */ new Set();
-	const files = allFiles.filter((file) => {
-		if (seenPaths.has(file.fullPath)) return false;
-		seenPaths.add(file.fullPath);
-		return true;
-	});
-	const exportName = [];
-	const VALID_DEFINE_FUNCTIONS = [
-		"defineResolver",
-		"defineQuery",
-		"defineMutation",
-		"defineField",
-		"defineSubscription",
-		"defineDirective"
-	];
-	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 = VALID_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;
-}
-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 allFiles = [...regularFiles, ...layerFiles];
-	const seenPaths = /* @__PURE__ */ new Set();
-	const files = allFiles.filter((file) => {
-		if (seenPaths.has(file.fullPath)) return false;
-		seenPaths.add(file.fullPath);
-		return true;
-	});
-	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;
-}
-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());
-	const allFiles = [...files, ...layerFiles];
-	const seenPaths = /* @__PURE__ */ new Set();
-	return allFiles.filter((file) => {
-		if (seenPaths.has(file.fullPath)) return false;
-		seenPaths.add(file.fullPath);
-		return true;
-	}).map((f) => f.fullPath);
-}
-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 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);
-}
-/**
-* Validate external GraphQL service configuration
-*/
-function validateExternalServices(services) {
-	const errors = [];
-	const serviceNames = /* @__PURE__ */ new Set();
-	for (const [index, service] of services.entries()) {
-		const prefix = `externalServices[${index}]`;
-		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 (!("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 ("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 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) => {
-		return {
-			fullPath,
-			path: relative(join(dir, name), fullPath)
-		};
-	}).sort((a, b) => a.path.localeCompare(b.path));
-}
-
-//#endregion
-export { GLOB_SCAN_PATTERN, createDefaultMaskError, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };
+export { createDefaultMaskError, deduplicateFiles, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, loadFederationSupport, relativeWithDot, resetFederationCache, scanDir, scanDirectives, scanDocuments, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices, warnFederationUnavailable };

package/dist/utils/layers.d.mts

@@ -0,0 +1,22 @@
+import { Nitro } from "nitro/types";
+
+//#region src/utils/layers.d.ts
+
+/**
+ * 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(): string[];
+//#endregion
+export { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories };

package/dist/utils/layers.mjs

@@ -0,0 +1,28 @@
+//#region src/utils/layers.ts
+/**
+* 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() {
+	return [];
+}
+
+//#endregion
+export { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories };

package/dist/utils/ofetch-templates.d.mts

@@ -0,0 +1,30 @@
+//#region src/utils/ofetch-templates.d.ts
+/**
+ * Shared ofetch template generation utilities
+ * Used by both main client and external service code generation
+ */
+interface OfetchTemplateOptions {
+  /** Service name (e.g., 'default', 'github') */
+  serviceName: string;
+  /** Whether to use Nuxt composables ($fetch, useRequestHeaders) */
+  isNuxt: boolean;
+  /** Endpoint URL for the GraphQL service */
+  endpoint: string;
+  /** Whether this is an external service (affects naming convention) */
+  isExternal?: boolean;
+}
+/**
+ * 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
+ */
+declare function generateOfetchTemplate(options: OfetchTemplateOptions): string;
+//#endregion
+export { OfetchTemplateOptions, generateOfetchTemplate };