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

package/dist/utils/{apollo.d.ts → apollo.d.mts}

@@ -1,9 +1,9 @@
 import { ApolloServer, BaseContext, ContextFunction } from "@apollo/server";
-import { EventHandler, H3Event } from "h3";
-import { WithRequired } from "@apollo/utils.withrequired";
+import { EventHandler, H3Event } from "nitro/h3";
 import { Hooks } from "crossws";
 
 //#region src/utils/apollo.d.ts
+type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
 interface H3ContextFunctionArgument {
   event: H3Event;
 }

package/dist/utils/apollo.mjs

@@ -0,0 +1,59 @@
+import { HeaderMap } from "@apollo/server";
+import { eventHandler, getRequestURL, readBody } from "nitro/h3";
+
+//#region src/utils/apollo.ts
+function startServerAndCreateH3Handler(server, options) {
+	const defaultContext = () => Promise.resolve({});
+	const contextFunction = options?.context ?? defaultContext;
+	return eventHandler(async (event) => {
+		const apolloServer = typeof server === "function" ? server() : server;
+		if (!options?.serverAlreadyStarted) apolloServer.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
+		if (event.req.method === "OPTIONS") {
+			event.res.status = 204;
+			return null;
+		}
+		try {
+			const graphqlRequest = await toGraphqlRequest(event);
+			const { body, headers, status } = await apolloServer.executeHTTPGraphQLRequest({
+				httpGraphQLRequest: graphqlRequest,
+				context: () => contextFunction({ event })
+			});
+			if (body.kind === "chunked") throw new Error("Incremental delivery not implemented");
+			for (const [key, value] of headers) event.res.headers.set(key, value);
+			event.res.status = status || 200;
+			return body.string;
+		} catch (error) {
+			if (error instanceof SyntaxError) {
+				event.res.status = 400;
+				return error.message;
+			} else throw error;
+		}
+	});
+}
+async function toGraphqlRequest(event) {
+	const url = getRequestURL(event);
+	return {
+		method: event.req.method || "POST",
+		headers: normalizeHeaders(Object.fromEntries(event.req.headers.entries())),
+		search: url.search.slice(1),
+		body: await normalizeBody(event)
+	};
+}
+function normalizeHeaders(headers) {
+	const headerMap = new HeaderMap();
+	for (const [key, value] of Object.entries(headers)) if (value !== void 0) headerMap.set(key, value);
+	return headerMap;
+}
+async function normalizeBody(event) {
+	const PayloadMethods = [
+		"PATCH",
+		"POST",
+		"PUT",
+		"DELETE"
+	];
+	const method = event.req.method;
+	if (method && PayloadMethods.includes(method)) return await readBody(event);
+}
+
+//#endregion
+export { startServerAndCreateH3Handler };

package/dist/utils/{client-codegen.d.ts → client-codegen.d.mts}

@@ -1,4 +1,4 @@
-import { CodegenClientConfig, ExternalGraphQLService, GenericSdkConfig } from "../types/index.js";
+import { CodegenClientConfig, ExternalGraphQLService, GenericSdkConfig } from "../types/index.mjs";
 import { GraphQLSchema } from "graphql";
 import { Source } from "@graphql-tools/utils";
 import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
@@ -23,14 +23,17 @@ declare function loadExternalSchema(service: ExternalGraphQLService, buildDir?:
  */
 declare function downloadAndSaveSchema(service: ExternalGraphQLService, buildDir: string): Promise<string | undefined>;
 declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
-declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string): Promise<false | {
+declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string, virtualTypesPath?: string, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<false | {
   types: string;
   sdk: string;
 }>;
 /**
  * Generate client types for external GraphQL service
  */
-declare function generateExternalClientTypes(service: ExternalGraphQLService, schema: GraphQLSchema, docs: Source[]): Promise<{
+declare function generateExternalClientTypes(service: ExternalGraphQLService, schema: GraphQLSchema, docs: Source[], virtualTypesPath?: string): Promise<{
   types: string;
   sdk: string;
 } | false>;

package/dist/utils/{client-codegen.js → client-codegen.mjs}

@@ -1,6 +1,6 @@
+import { defu as defu$1 } from "defu";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { consola as consola$1 } from "consola";
-import { defu as defu$1 } from "defu";
 import { dirname, resolve } from "pathe";
 import { parse } from "graphql";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
@@ -165,9 +165,9 @@ async function loadGraphQLDocuments(patterns) {
 		else throw e;
 	}
 }
-async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName) {
+async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath, options = {}) {
 	if (docs.length === 0 && !serviceName) {
-		consola$1.info("No client GraphQL files found. Skipping client type generation.");
+		if (!options.silent && options.isInitial) consola$1.info("No client GraphQL files found. Skipping client type generation.");
 		return false;
 	}
 	const serviceLabel = serviceName ? `:${serviceName}` : "";
@@ -252,7 +252,7 @@ export function getSdk(requester: Requester): Sdk {
 				typescriptOperations: { plugin: plugin$2 }
 			}
 		});
-		const typesPath = serviceName ? `#graphql/client/${serviceName}` : "#graphql/client";
+		const typesPath = virtualTypesPath || (serviceName ? `#graphql/client/${serviceName}` : "#graphql/client");
 		const sdkOutput = await preset.buildGeneratesSection({
 			baseOutputDir: outputPath || "client-types.generated.ts",
 			schema: parse(printSchemaWithDirectives(schema)),
@@ -282,8 +282,8 @@ export function getSdk(requester: Requester): Sdk {
 /**
 * Generate client types for external GraphQL service
 */
-async function generateExternalClientTypes(service, schema, docs) {
-	return generateClientTypes(schema, docs, service.codegen?.client || {}, service.codegen?.clientSDK || {}, void 0, service.name);
+async function generateExternalClientTypes(service, schema, docs, virtualTypesPath) {
+	return generateClientTypes(schema, docs, service.codegen?.client || {}, service.codegen?.clientSDK || {}, void 0, service.name, virtualTypesPath);
 }
 
 //#endregion

package/dist/utils/errors.d.mts

@@ -0,0 +1,73 @@
+//#region src/utils/errors.d.ts
+interface MaskErrorOptions {
+  /**
+   * Default HTTP status code for validation errors (ZodError)
+   * @default 400
+   */
+  validationStatusCode?: number;
+  /**
+   * Default HTTP status code for HTTP errors when status is not provided
+   * @default 500
+   */
+  defaultHttpStatusCode?: number;
+}
+/**
+ * Default error masking function for GraphQL Yoga
+ * Handles common error types like ZodError and HTTPError
+ *
+ * @param options - Configuration options for error handling
+ *
+ * @example Basic usage
+ * ```ts
+ * import { defineGraphQLConfig } from 'nitro-graphql/define'
+ * import { createDefaultMaskError } from 'nitro-graphql/utils'
+ *
+ * export default defineGraphQLConfig({
+ *   maskedErrors: {
+ *     maskError: createDefaultMaskError()
+ *   }
+ * })
+ * ```
+ *
+ * @example Custom status codes
+ * ```ts
+ * import { defineGraphQLConfig } from 'nitro-graphql/define'
+ * import { createDefaultMaskError } from 'nitro-graphql/utils'
+ *
+ * export default defineGraphQLConfig({
+ *   maskedErrors: {
+ *     maskError: createDefaultMaskError({
+ *       validationStatusCode: 422,  // Use 422 for validation errors
+ *       defaultHttpStatusCode: 500  // Use 500 for unknown HTTP errors
+ *     })
+ *   }
+ * })
+ * ```
+ *
+ * @example Custom error handling with fallback to default
+ * ```ts
+ * import { defineGraphQLConfig } from 'nitro-graphql/define'
+ * import { createDefaultMaskError } from 'nitro-graphql/utils'
+ *
+ * const defaultMaskError = createDefaultMaskError()
+ *
+ * export default defineGraphQLConfig({
+ *   maskedErrors: {
+ *     maskError: (error: unknown) => {
+ *       // Handle custom errors first
+ *       if (error instanceof MyCustomError) {
+ *         return new GraphQLError(error.message, {
+ *           extensions: { code: 'CUSTOM_ERROR' }
+ *         })
+ *       }
+ *
+ *       // Fall back to default handling
+ *       return defaultMaskError(error)
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function createDefaultMaskError(options?: MaskErrorOptions): (error: unknown) => Error;
+//#endregion
+export { MaskErrorOptions, createDefaultMaskError };

package/dist/utils/errors.mjs

@@ -0,0 +1,89 @@
+import { GraphQLError } from "graphql";
+
+//#region src/utils/errors.ts
+/**
+* Default error masking function for GraphQL Yoga
+* Handles common error types like ZodError and HTTPError
+*
+* @param options - Configuration options for error handling
+*
+* @example Basic usage
+* ```ts
+* import { defineGraphQLConfig } from 'nitro-graphql/define'
+* import { createDefaultMaskError } from 'nitro-graphql/utils'
+*
+* export default defineGraphQLConfig({
+*   maskedErrors: {
+*     maskError: createDefaultMaskError()
+*   }
+* })
+* ```
+*
+* @example Custom status codes
+* ```ts
+* import { defineGraphQLConfig } from 'nitro-graphql/define'
+* import { createDefaultMaskError } from 'nitro-graphql/utils'
+*
+* export default defineGraphQLConfig({
+*   maskedErrors: {
+*     maskError: createDefaultMaskError({
+*       validationStatusCode: 422,  // Use 422 for validation errors
+*       defaultHttpStatusCode: 500  // Use 500 for unknown HTTP errors
+*     })
+*   }
+* })
+* ```
+*
+* @example Custom error handling with fallback to default
+* ```ts
+* import { defineGraphQLConfig } from 'nitro-graphql/define'
+* import { createDefaultMaskError } from 'nitro-graphql/utils'
+*
+* const defaultMaskError = createDefaultMaskError()
+*
+* export default defineGraphQLConfig({
+*   maskedErrors: {
+*     maskError: (error: unknown) => {
+*       // Handle custom errors first
+*       if (error instanceof MyCustomError) {
+*         return new GraphQLError(error.message, {
+*           extensions: { code: 'CUSTOM_ERROR' }
+*         })
+*       }
+*
+*       // Fall back to default handling
+*       return defaultMaskError(error)
+*     }
+*   }
+* })
+* ```
+*/
+function createDefaultMaskError(options) {
+	const validationStatusCode = options?.validationStatusCode ?? 400;
+	const defaultHttpStatusCode = options?.defaultHttpStatusCode ?? 500;
+	return (error) => {
+		if (error && typeof error === "object" && "originalError" in error) {
+			const graphqlError = error;
+			if (graphqlError.originalError && typeof graphqlError.originalError === "object" && "issues" in graphqlError.originalError && Array.isArray(graphqlError.originalError.issues)) return new GraphQLError("Validation failed", { extensions: {
+				code: "BAD_USER_INPUT",
+				validationErrors: graphqlError.originalError.issues.map((issue) => ({
+					field: issue.path.join("."),
+					message: issue.message
+				})),
+				http: { status: validationStatusCode }
+			} });
+			if (graphqlError.originalError && typeof graphqlError.originalError === "object" && "statusCode" in graphqlError.originalError && "statusMessage" in graphqlError.originalError) {
+				const httpError = graphqlError.originalError;
+				const statusCode = httpError.statusCode ?? defaultHttpStatusCode;
+				return new GraphQLError(httpError.statusMessage || httpError.message || "Internal Server Error", { extensions: {
+					code: statusCode,
+					http: { status: statusCode }
+				} });
+			}
+		}
+		return error instanceof Error ? error : new Error(String(error));
+	};
+}
+
+//#endregion
+export { createDefaultMaskError };

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

@@ -0,0 +1,37 @@
+import { Nitro } from "nitro/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.mjs

@@ -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 → index.d.mts}

@@ -1,5 +1,6 @@
-import { GenImport } from "../types/index.js";
-import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
+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
@@ -36,4 +37,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, validateExternalServices };
+export { GLOB_SCAN_PATTERN, createDefaultMaskError, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };

package/dist/utils/{index.js → index.mjs}

@@ -1,8 +1,9 @@
-import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
-import { join, relative } from "pathe";
+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 { parseAsync } from "oxc-parser";
+import { parseSync } from "oxc-parser";
 import { glob } from "tinyglobby";
 
 //#region src/utils/index.ts
@@ -65,50 +66,89 @@ async function scanResolvers(nitro) {
 		return true;
 	});
 	const exportName = [];
-	for (const file of files) {
+	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 = await parseAsync(file.fullPath, fileContent);
+		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
 		};
-		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 === "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;
 }
@@ -127,7 +167,7 @@ async function scanDirectives(nitro) {
 	const exportName = [];
 	for (const file of files) {
 		const fileContent = await readFile(file.fullPath, "utf-8");
-		const parsed = await parseAsync(file.fullPath, fileContent);
+		const parsed = parseSync(file.fullPath, fileContent);
 		const exports = {
 			imports: [],
 			specifier: file.fullPath
@@ -247,4 +287,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, validateExternalServices };
+export { GLOB_SCAN_PATTERN, createDefaultMaskError, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };

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

@@ -0,0 +1,70 @@
+import { ClientUtilsConfig, FileGenerationConfig, ScaffoldConfig, SdkConfig, TypesConfig } from "../types/index.mjs";
+import { Nitro } from "nitro/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 };