nitro-graphql 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/types/index.d.ts

@@ -57,6 +57,18 @@ declare module 'nitro/types' {
     graphql?: NitroGraphQLOptions;
   }
 }
+/**
+ * Service-specific path overrides for external GraphQL services
+ * These paths override global config for this specific service
+ */
+interface ExternalServicePaths {
+  /** SDK file path (overrides global sdk.external config) */
+  sdk?: FileGenerationConfig;
+  /** Type definitions file path (overrides global types.external config) */
+  types?: FileGenerationConfig;
+  /** ofetch client wrapper path (overrides global clientUtils.ofetch config) */
+  ofetch?: FileGenerationConfig;
+}
 interface ExternalGraphQLService {
   /** Unique name for this service (used for file naming and type generation) */
   name: string;
@@ -83,6 +95,12 @@ interface ExternalGraphQLService {
     client?: CodegenClientConfig;
     clientSDK?: GenericSdkConfig;
   };
+  /**
+   * Optional: Service-specific path overrides
+   * These paths take precedence over global config (sdk, types, clientUtils)
+   * Supports placeholders: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {clientGraphql}
+   */
+  paths?: ExternalServicePaths;
 }
 interface FederationConfig {
   /** Enable Apollo Federation subgraph support */
@@ -94,6 +112,81 @@ interface FederationConfig {
   /** Service URL for federation gateway */
   serviceUrl?: string;
 }
+/**
+ * File generation control:
+ * - false: Do not generate this file
+ * - true: Generate at default location
+ * - string: Generate at custom path (supports placeholders: {serviceName}, {buildDir}, {rootDir}, {framework})
+ */
+type FileGenerationConfig = boolean | string;
+/**
+ * Scaffold files configuration
+ * Control auto-generation of scaffold/boilerplate files
+ */
+interface ScaffoldConfig {
+  /** Enable/disable all scaffold files */
+  enabled?: boolean;
+  /** graphql.config.ts - GraphQL Config file for IDE tooling */
+  graphqlConfig?: FileGenerationConfig;
+  /** server/graphql/schema.ts - Schema definition file */
+  serverSchema?: FileGenerationConfig;
+  /** server/graphql/config.ts - GraphQL server configuration */
+  serverConfig?: FileGenerationConfig;
+  /** server/graphql/context.ts - H3 context augmentation */
+  serverContext?: FileGenerationConfig;
+}
+/**
+ * Client utilities configuration
+ * Control auto-generation of client-side utility files (Nuxt only)
+ */
+interface ClientUtilsConfig {
+  /** Enable/disable all client utilities */
+  enabled?: boolean;
+  /** app/graphql/index.ts - Main exports file */
+  index?: FileGenerationConfig;
+  /** app/graphql/{serviceName}/ofetch.ts - ofetch client wrapper */
+  ofetch?: FileGenerationConfig;
+}
+/**
+ * SDK files configuration
+ * Control auto-generation of GraphQL SDK files
+ */
+interface SdkConfig {
+  /** Enable/disable all SDK files */
+  enabled?: boolean;
+  /** app/graphql/default/sdk.ts - Main service SDK */
+  main?: FileGenerationConfig;
+  /** app/graphql/{serviceName}/sdk.ts - External service SDKs */
+  external?: FileGenerationConfig;
+}
+/**
+ * Type files configuration
+ * Control auto-generation of TypeScript type definition files
+ */
+interface TypesConfig {
+  /** Enable/disable all type files */
+  enabled?: boolean;
+  /** .nitro/types/nitro-graphql-server.d.ts - Server-side types */
+  server?: FileGenerationConfig;
+  /** .nitro/types/nitro-graphql-client.d.ts - Client-side types */
+  client?: FileGenerationConfig;
+  /** .nitro/types/nitro-graphql-client-{serviceName}.d.ts - External service types */
+  external?: FileGenerationConfig;
+}
+/**
+ * Global path overrides
+ * Set base directories for file generation
+ */
+interface PathsConfig {
+  /** Server GraphQL directory (default: 'server/graphql') */
+  serverGraphql?: string;
+  /** Client GraphQL directory (default: 'app/graphql' for Nuxt, 'graphql' for Nitro) */
+  clientGraphql?: string;
+  /** Build directory (default: '.nitro' or '.nuxt') */
+  buildDir?: string;
+  /** Types directory (default: '{buildDir}/types') */
+  typesDir?: string;
+}
 interface NitroGraphQLOptions {
   framework: 'graphql-yoga' | 'apollo-server';
   endpoint?: {
@@ -123,6 +216,31 @@ interface NitroGraphQLOptions {
   layerDirectories?: string[];
   layerServerDirs?: string[];
   layerAppDirs?: string[];
+  /**
+   * Scaffold files configuration
+   * Set to false to disable all scaffold file generation (library mode)
+   */
+  scaffold?: false | ScaffoldConfig;
+  /**
+   * Client utilities configuration
+   * Set to false to disable all client utility generation
+   */
+  clientUtils?: false | ClientUtilsConfig;
+  /**
+   * SDK files configuration
+   * Set to false to disable all SDK generation
+   */
+  sdk?: false | SdkConfig;
+  /**
+   * Type files configuration
+   * Set to false to disable all type generation
+   */
+  types?: false | TypesConfig;
+  /**
+   * Global path overrides
+   * Customize base directories for file generation
+   */
+  paths?: PathsConfig;
 }
 //#endregion
-export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions };
+export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, TypesConfig };

package/dist/utils/directive-parser.js

@@ -18,13 +18,9 @@ var DirectiveParser = class {
 				sourceType: "module",
 				astType: "ts"
 			});
-			if (result.errors.length > 0) {
-				console.warn(`Parse errors in ${filePath}:`, result.errors.map((e) => e.message));
-				return [];
-			}
+			if (result.errors.length > 0) return [];
 			return this.extractDirectiveDefinitions(result.program);
-		} catch (error) {
-			console.warn(`Failed to parse ${filePath} with oxc:`, error);
+		} catch {
 			return [];
 		}
 	}
@@ -205,7 +201,7 @@ async function generateDirectiveSchemas(nitro, directives) {
 		}
 	}
 	if (directiveSchemas.length > 0) {
-		const directivesPath = resolve(nitro.graphql.serverDir, "_directives.graphql");
+		const directivesPath = resolve(nitro.graphql.buildDir, "_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()

package/dist/utils/file-generator.d.ts

@@ -0,0 +1,37 @@
+import { Nitro } from "nitropack/types";
+
+//#region src/utils/file-generator.d.ts
+
+/**
+ * Safely write a file to disk, creating parent directories if needed
+ */
+declare function writeFile(filePath: string, content: string, description?: string): void;
+/**
+ * Write a file only if it doesn't already exist
+ * Returns true if file was created, false if it already existed
+ */
+declare function writeFileIfNotExists(filePath: string, content: string, description?: string): boolean;
+/**
+ * Write a file and always overwrite (used for generated files like SDK)
+ * This is for files that are auto-generated and should be updated on every build
+ */
+declare function writeGeneratedFile(filePath: string, content: string, description?: string): void;
+/**
+ * Check if a path is configured and should be generated
+ * Returns the resolved path if should generate, null otherwise
+ */
+declare function getGenerationPath(resolvedPath: string | null, description?: string): string | null;
+/**
+ * Log skipped file generation (helpful for debugging library mode)
+ */
+declare function logSkipped(fileName: string, reason?: string): void;
+/**
+ * Log generated file path
+ */
+declare function logGenerated(fileName: string, path: string): void;
+/**
+ * Validate that a Nitro instance has the required GraphQL configuration
+ */
+declare function validateGraphQLConfig(nitro: Nitro): boolean;
+//#endregion
+export { getGenerationPath, logGenerated, logSkipped, validateGraphQLConfig, writeFile, writeFileIfNotExists, writeGeneratedFile };

package/dist/utils/file-generator.js

@@ -0,0 +1,72 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import consola from "consola";
+import { dirname } from "pathe";
+
+//#region src/utils/file-generator.ts
+/**
+* Safely write a file to disk, creating parent directories if needed
+*/
+function writeFile(filePath, content, description) {
+	try {
+		const dir = dirname(filePath);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileSync(filePath, content, "utf-8");
+		if (description) consola.success(`[nitro-graphql] Generated: ${description}`);
+	} catch (error) {
+		consola.error(`[nitro-graphql] Failed to write file: ${filePath}`, error);
+		throw error;
+	}
+}
+/**
+* Write a file only if it doesn't already exist
+* Returns true if file was created, false if it already existed
+*/
+function writeFileIfNotExists(filePath, content, description) {
+	if (existsSync(filePath)) return false;
+	writeFile(filePath, content, description);
+	return true;
+}
+/**
+* Write a file and always overwrite (used for generated files like SDK)
+* This is for files that are auto-generated and should be updated on every build
+*/
+function writeGeneratedFile(filePath, content, description) {
+	writeFile(filePath, content, description);
+}
+/**
+* Check if a path is configured and should be generated
+* Returns the resolved path if should generate, null otherwise
+*/
+function getGenerationPath(resolvedPath, description) {
+	if (!resolvedPath) {
+		if (description) consola.debug(`[nitro-graphql] Skipping generation: ${description} (disabled in config)`);
+		return null;
+	}
+	return resolvedPath;
+}
+/**
+* Log skipped file generation (helpful for debugging library mode)
+*/
+function logSkipped(fileName, reason) {
+	const message = reason ? `Skipped ${fileName}: ${reason}` : `Skipped ${fileName}`;
+	consola.debug(`[nitro-graphql] ${message}`);
+}
+/**
+* Log generated file path
+*/
+function logGenerated(fileName, path) {
+	consola.info(`[nitro-graphql] Generated ${fileName} at: ${path}`);
+}
+/**
+* Validate that a Nitro instance has the required GraphQL configuration
+*/
+function validateGraphQLConfig(nitro) {
+	if (!nitro.options.graphql?.framework) {
+		consola.warn("[nitro-graphql] No GraphQL framework specified. Some features may not work correctly.");
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+export { getGenerationPath, logGenerated, logSkipped, validateGraphQLConfig, writeFile, writeFileIfNotExists, writeGeneratedFile };

package/dist/utils/index.d.ts

@@ -19,13 +19,12 @@ declare function getLayerAppDirectories(nitro: Nitro): string[];
 /**
  * Generate layer-aware ignore patterns for auto-generated files
  */
-declare function generateLayerIgnorePatterns(nitro: Nitro): string[];
+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 scanTypeDefs(nitro: Nitro): Promise<string[]>;
 declare function scanSchemas(nitro: Nitro): Promise<string[]>;
 declare function scanDocs(nitro: Nitro): Promise<string[]>;
 /**
@@ -37,4 +36,4 @@ declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patt
  */
 declare function validateExternalServices(services: unknown[]): string[];
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };

package/dist/utils/index.js

@@ -28,12 +28,8 @@ function getLayerAppDirectories(nitro) {
 /**
 * Generate layer-aware ignore patterns for auto-generated files
 */
-function generateLayerIgnorePatterns(nitro) {
-	const patterns = [];
-	patterns.push(`${nitro.graphql.serverDir}/_directives.graphql`);
-	const layerServerDirs = nitro.options.graphql?.layerServerDirs || [];
-	for (const layerServerDir of layerServerDirs) patterns.push(`${layerServerDir}/graphql/_directives.graphql`);
-	return patterns;
+function generateLayerIgnorePatterns() {
+	return [];
 }
 function getImportId(p, lazy) {
 	return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
@@ -44,60 +40,118 @@ function relativeWithDot(from, to) {
 	return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
 }
 async function scanGraphql(nitro) {
-	return (await scanFiles(nitro, "graphql")).map((f) => f.fullPath);
+	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 files = await scanFiles(nitro, "graphql", "**/*.resolver.{ts,js}");
+	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 = [];
-	for (const file of files) {
+	const VALID_DEFINE_FUNCTIONS = [
+		"defineResolver",
+		"defineQuery",
+		"defineMutation",
+		"defineType",
+		"defineSubscription",
+		"defineDirective"
+	];
+	for (const file of files) try {
 		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 === "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 === "defineType") 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)}`
-					});
+		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 === "defineType") 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 files = await scanFiles(nitro, "graphql", "**/*.directive.{ts,js}");
+	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");
@@ -121,11 +175,18 @@ async function scanDirectives(nitro) {
 	}
 	return exportName;
 }
-async function scanTypeDefs(nitro) {
-	return (await scanFiles(nitro, "graphql", "**/*.typedef.{ts,js}")).map((f) => f.fullPath);
-}
 async function scanSchemas(nitro) {
-	return (await scanFiles(nitro, "graphql", "**/*.graphql")).map((f) => f.fullPath);
+	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");
@@ -193,18 +254,6 @@ function validateExternalServices(services) {
 	}
 	return errors;
 }
-async function scanFiles(nitro, name, globPattern = GLOB_SCAN_PATTERN) {
-	const regularFiles = await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name, globPattern))).then((r) => r.flat());
-	const layerDirectories = getLayerDirectories(nitro);
-	const layerFiles = await Promise.all(layerDirectories.map((layerDir) => scanDir(nitro, layerDir, `server/${name}`, globPattern))).then((r) => r.flat());
-	const allFiles = [...regularFiles, ...layerFiles];
-	const seenPaths = /* @__PURE__ */ new Set();
-	return allFiles.filter((file) => {
-		if (seenPaths.has(file.fullPath)) return false;
-		seenPaths.add(file.fullPath);
-		return true;
-	});
-}
 async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 	return (await glob(join(name, globPattern), {
 		cwd: dir,
@@ -226,4 +275,4 @@ async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };

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

@@ -0,0 +1,70 @@
+import { ClientUtilsConfig, FileGenerationConfig, ScaffoldConfig, SdkConfig, TypesConfig } from "../types/index.js";
+import { Nitro } from "nitropack/types";
+
+//#region src/utils/path-resolver.d.ts
+
+/**
+ * Placeholder values for path resolution
+ */
+interface PathPlaceholders {
+  serviceName?: string;
+  buildDir: string;
+  rootDir: string;
+  framework: 'nuxt' | 'nitro';
+  typesDir: string;
+  serverGraphql: string;
+  clientGraphql: string;
+}
+/**
+ * Replace placeholders in a path string
+ * Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverGraphql}, {clientGraphql}
+ */
+declare function replacePlaceholders(path: string, placeholders: PathPlaceholders): string;
+/**
+ * Get default paths based on framework and user configuration
+ */
+declare function getDefaultPaths(nitro: Nitro): Required<PathPlaceholders>;
+/**
+ * Check if a file should be generated based on config
+ * Returns: true if should generate, false if should skip
+ */
+declare function shouldGenerateFile(config: FileGenerationConfig | undefined, categoryEnabled: boolean | undefined, topLevelEnabled: boolean): boolean;
+/**
+ * Resolve the file path based on configuration
+ * Returns: resolved absolute path or null if file should not be generated
+ */
+declare function resolveFilePath(config: FileGenerationConfig | undefined, categoryEnabled: boolean | undefined, topLevelEnabled: boolean, defaultPath: string, placeholders: PathPlaceholders): string | null;
+/**
+ * Check if scaffold files should be generated (category-level check)
+ */
+declare function shouldGenerateScaffold(nitro: Nitro): boolean;
+/**
+ * Get scaffold configuration (handles false case)
+ */
+declare function getScaffoldConfig(nitro: Nitro): ScaffoldConfig;
+/**
+ * Check if client utilities should be generated (category-level check)
+ */
+declare function shouldGenerateClientUtils(nitro: Nitro): boolean;
+/**
+ * Get client utilities configuration (handles false case)
+ */
+declare function getClientUtilsConfig(nitro: Nitro): ClientUtilsConfig;
+/**
+ * Check if SDK files should be generated (category-level check)
+ */
+declare function shouldGenerateSDK(nitro: Nitro): boolean;
+/**
+ * Get SDK configuration (handles false case)
+ */
+declare function getSdkConfig(nitro: Nitro): SdkConfig;
+/**
+ * Check if type files should be generated (category-level check)
+ */
+declare function shouldGenerateTypes(nitro: Nitro): boolean;
+/**
+ * Get types configuration (handles false case)
+ */
+declare function getTypesConfig(nitro: Nitro): TypesConfig;
+//#endregion
+export { PathPlaceholders, getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateSDK, shouldGenerateScaffold, shouldGenerateTypes };