nitro-graphql 2.0.0-beta.24 → 2.0.0-beta.26

package/dist/define.d.mts

@@ -43,19 +43,19 @@ declare function defineSchema<T extends Partial<Record<keyof ResolversTypes, Sta
  * ```typescript
  * export const userResolvers = defineResolver({
  *   Query: {
- *     user: async (_, { id }, context) => {
+ *     user: async (parent, { id }, context) => {
  *       return await context.storage.getItem(`user:${id}`)
  *     }
  *   },
  *   Mutation: {
- *     createUser: async (_, { input }, context) => {
+ *     createUser: async (parent, { input }, context) => {
  *       const user = { id: generateId(), ...input }
  *       await context.storage.setItem(`user:${user.id}`, user)
  *       return user
  *     }
  *   },
  *   User: {
- *     fullName: (parent) => `${parent.firstName} ${parent.lastName}`
+ *     fullName: (parent, args, context) => `${parent.firstName} ${parent.lastName}`
  *   }
  * })
  * ```
@@ -74,10 +74,10 @@ declare function defineResolver(resolvers: Resolvers): Resolvers;
  * @example
  * ```typescript
  * export const userQueries = defineQuery({
- *   user: async (_, { id }, context) => {
+ *   user: async (parent, { id }, context) => {
  *     return await fetchUser(id)
  *   },
- *   users: async (_, __, context) => {
+ *   users: async (parent, args, context) => {
  *     return await fetchAllUsers()
  *   }
  * })
@@ -100,14 +100,14 @@ declare function defineQuery(resolvers?: Resolvers['Query']): Resolvers;
  * @example
  * ```typescript
  * export const userMutations = defineMutation({
- *   createUser: async (_, { input }, context) => {
+ *   createUser: async (parent, { input }, context) => {
  *     const user = await context.db.users.create(input)
  *     return user
  *   },
- *   updateUser: async (_, { id, input }, context) => {
+ *   updateUser: async (parent, { id, input }, context) => {
  *     return await context.db.users.update(id, input)
  *   },
- *   deleteUser: async (_, { id }, context) => {
+ *   deleteUser: async (parent, { id }, context) => {
  *     return await context.db.users.delete(id)
  *   }
  * })
@@ -133,13 +133,13 @@ declare function defineMutation(resolvers?: Resolvers['Mutation']): Resolvers;
  *
  * export const messageSubscriptions = defineSubscription({
  *   messageAdded: {
- *     subscribe: async function* (_, { channelId }, context) {
+ *     subscribe: async function* (parent, { channelId }, context) {
  *       const pubsub = context.pubsub
  *       yield* pubsub.subscribe(`channel:${channelId}`)
  *     }
  *   },
  *   userStatusChanged: {
- *     subscribe: async (_, __, context) => {
+ *     subscribe: async (parent, args, context) => {
  *       return new Repeater(async (push, stop) => {
  *         // Real-time subscription logic
  *       })
@@ -197,6 +197,8 @@ declare function defineType(resolvers: Resolvers): Resolvers;
  *
  * @example
  * ```typescript
+ * import { createDefaultMaskError } from 'nitro-graphql/utils'
+ *
  * // GraphQL Yoga configuration
  * export default defineGraphQLConfig({
  *   schema: {
@@ -208,10 +210,10 @@ declare function defineType(resolvers: Resolvers): Resolvers;
  *       db: getDatabase()
  *     }
  *   },
- *   yoga: {
- *     graphiql: true,
- *     maskedErrors: false
- *   }
+ *   maskedErrors: {
+ *     maskError: createDefaultMaskError()
+ *   },
+ *   graphiql: true
  * })
  * ```
  *

package/dist/define.mjs

@@ -39,19 +39,19 @@ function defineSchema(config) {
 * ```typescript
 * export const userResolvers = defineResolver({
 *   Query: {
-*     user: async (_, { id }, context) => {
+*     user: async (parent, { id }, context) => {
 *       return await context.storage.getItem(`user:${id}`)
 *     }
 *   },
 *   Mutation: {
-*     createUser: async (_, { input }, context) => {
+*     createUser: async (parent, { input }, context) => {
 *       const user = { id: generateId(), ...input }
 *       await context.storage.setItem(`user:${user.id}`, user)
 *       return user
 *     }
 *   },
 *   User: {
-*     fullName: (parent) => `${parent.firstName} ${parent.lastName}`
+*     fullName: (parent, args, context) => `${parent.firstName} ${parent.lastName}`
 *   }
 * })
 * ```
@@ -72,10 +72,10 @@ function defineResolver(resolvers) {
 * @example
 * ```typescript
 * export const userQueries = defineQuery({
-*   user: async (_, { id }, context) => {
+*   user: async (parent, { id }, context) => {
 *     return await fetchUser(id)
 *   },
-*   users: async (_, __, context) => {
+*   users: async (parent, args, context) => {
 *     return await fetchAllUsers()
 *   }
 * })
@@ -100,14 +100,14 @@ function defineQuery(resolvers = {}) {
 * @example
 * ```typescript
 * export const userMutations = defineMutation({
-*   createUser: async (_, { input }, context) => {
+*   createUser: async (parent, { input }, context) => {
 *     const user = await context.db.users.create(input)
 *     return user
 *   },
-*   updateUser: async (_, { id, input }, context) => {
+*   updateUser: async (parent, { id, input }, context) => {
 *     return await context.db.users.update(id, input)
 *   },
-*   deleteUser: async (_, { id }, context) => {
+*   deleteUser: async (parent, { id }, context) => {
 *     return await context.db.users.delete(id)
 *   }
 * })
@@ -135,13 +135,13 @@ function defineMutation(resolvers = {}) {
 *
 * export const messageSubscriptions = defineSubscription({
 *   messageAdded: {
-*     subscribe: async function* (_, { channelId }, context) {
+*     subscribe: async function* (parent, { channelId }, context) {
 *       const pubsub = context.pubsub
 *       yield* pubsub.subscribe(`channel:${channelId}`)
 *     }
 *   },
 *   userStatusChanged: {
-*     subscribe: async (_, __, context) => {
+*     subscribe: async (parent, args, context) => {
 *       return new Repeater(async (push, stop) => {
 *         // Real-time subscription logic
 *       })
@@ -203,6 +203,8 @@ function defineType(resolvers) {
 *
 * @example
 * ```typescript
+* import { createDefaultMaskError } from 'nitro-graphql/utils'
+*
 * // GraphQL Yoga configuration
 * export default defineGraphQLConfig({
 *   schema: {
@@ -214,10 +216,10 @@ function defineType(resolvers) {
 *       db: getDatabase()
 *     }
 *   },
-*   yoga: {
-*     graphiql: true,
-*     maskedErrors: false
-*   }
+*   maskedErrors: {
+*     maskError: createDefaultMaskError()
+*   },
+*   graphiql: true
 * })
 * ```
 *

package/dist/rollup.mjs

@@ -94,8 +94,8 @@ async function rollupConfig(app) {
 		}
 	});
 	app.hooks.hook("dev:reload", async () => {
-		await serverTypeGeneration(app);
-		await clientTypeGeneration(app);
+		await serverTypeGeneration(app, { silent: true });
+		await clientTypeGeneration(app, { silent: true });
 	});
 }
 function virtualSchemas(app) {

package/dist/routes/apollo-server.d.mts

@@ -1,6 +1,6 @@
-import * as h33 from "h3";
+import * as h30 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h33.EventHandlerWithFetch<h33.EventHandlerRequest, Promise<any>>;
+declare const _default: h30.EventHandlerWithFetch<h30.EventHandlerRequest, Promise<any>>;
 //#endregion
 export { _default as default };

package/dist/routes/graphql-yoga.mjs

@@ -84,6 +84,10 @@ var graphql_yoga_default = defineEventHandler(async (event) => {
 		renderGraphiQL: () => apolloSandboxHtml
 	}, importedConfig));
 	const response = await yoga.handleRequest(event.req, event);
+	if (event.res.statusCode && event.res.statusCode !== 200) return new Response(response.body, {
+		...response,
+		status: event.res.statusCode
+	});
 	return new Response(response.body, response);
 });
 

package/dist/routes/health.d.mts

@@ -1,7 +1,7 @@
-import * as h30 from "h3";
+import * as h33 from "h3";
 
 //#region src/routes/health.d.ts
-declare const _default: h30.EventHandlerWithFetch<h30.EventHandlerRequest, Promise<{
+declare const _default: h33.EventHandlerWithFetch<h33.EventHandlerRequest, Promise<{
   status: string;
   message: string;
   timestamp: string;

package/dist/setup.mjs

@@ -12,20 +12,21 @@ import consola from "consola";
 import { dirname, join, relative, resolve } from "pathe";
 
 //#region src/setup.ts
+const logger = consola.withTag("nitro-graphql");
 /**
 * Shared setup logic for nitro-graphql module
 * Used by both the direct Nitro module export and the Vite plugin's nitro: hook
 */
 async function setupNitroGraphQL(nitro) {
-	if (!nitro.options.graphql?.framework) consola.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
+	if (!nitro.options.graphql?.framework) logger.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
 	if (nitro.options.graphql?.externalServices?.length) {
 		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
 		if (validationErrors.length > 0) {
-			consola.error("External services configuration errors:");
-			for (const error of validationErrors) consola.error(`  - ${error}`);
+			logger.error("External services configuration errors:");
+			for (const error of validationErrors) logger.error(`  - ${error}`);
 			throw new Error("Invalid external services configuration");
 		}
-		consola.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+		logger.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
 	}
 	const { getDefaultPaths } = await import("./utils/path-resolver.mjs");
 	const defaultPaths = getDefaultPaths(nitro);
@@ -59,7 +60,7 @@ async function setupNitroGraphQL(nitro) {
 		},
 		playground: true
 	});
-	if (nitro.options.graphql?.federation?.enabled) consola.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
+	if (nitro.options.graphql?.federation?.enabled) logger.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
 	const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
 	nitro.graphql.buildDir = graphqlBuildDir;
 	const watchDirs = [];
@@ -95,11 +96,20 @@ async function setupNitroGraphQL(nitro) {
 		ignoreInitial: true,
 		ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns()]
 	}).on("all", async (_, path) => {
-		if (path.endsWith(".graphql") || path.endsWith(".gql")) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql")) {
-			await serverTypeGeneration(nitro);
-			await clientTypeGeneration(nitro);
+		const isGraphQLFile = path.endsWith(".graphql") || path.endsWith(".gql");
+		const isResolverFile = path.endsWith(".resolver.ts") || path.endsWith(".resolver.js");
+		const isDirectiveFile = path.endsWith(".directive.ts") || path.endsWith(".directive.js");
+		if (isGraphQLFile || isResolverFile || isDirectiveFile) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql") || isResolverFile || isDirectiveFile) {
+			await scanResolvers(nitro).then((r) => nitro.scanResolvers = r);
+			await scanDirectives(nitro).then((d) => nitro.scanDirectives = d);
+			logger.success("Types regenerated");
+			await serverTypeGeneration(nitro, { silent: true });
+			await clientTypeGeneration(nitro, { silent: true });
 			await nitro.hooks.callHook("dev:reload");
-		} else await clientTypeGeneration(nitro);
+		} else {
+			logger.success("Types regenerated");
+			await clientTypeGeneration(nitro, { silent: true });
+		}
 	});
 	nitro.hooks.hook("close", () => {
 		watcher.close();
@@ -111,33 +121,17 @@ async function setupNitroGraphQL(nitro) {
 	const directives = await scanDirectives(nitro);
 	nitro.scanDirectives = directives;
 	await generateDirectiveSchemas(nitro, directives);
+	let hasShownInitialLogs = false;
 	nitro.hooks.hook("dev:start", async () => {
-		const schemas = await scanSchemas(nitro);
-		nitro.scanSchemas = schemas;
+		nitro.scanSchemas = await scanSchemas(nitro);
 		const resolvers = await scanResolvers(nitro);
 		nitro.scanResolvers = resolvers;
 		const directives$1 = await scanDirectives(nitro);
 		nitro.scanDirectives = directives$1;
 		await generateDirectiveSchemas(nitro, directives$1);
-		const docs = await scanDocs(nitro);
-		nitro.scanDocuments = docs;
-		if (nitro.options.dev) {
-			consola.box({
-				title: "Nitro GraphQL",
-				message: [
-					`Framework: ${nitro.options.graphql?.framework || "Not configured"}`,
-					`Schemas: ${schemas.length}`,
-					`Resolvers: ${resolvers.length}`,
-					`Directives: ${directives$1.length}`,
-					`Documents: ${docs.length}`,
-					"",
-					"Debug Dashboard: /_nitro/graphql/debug"
-				].join("\n"),
-				style: {
-					borderColor: "cyan",
-					borderStyle: "rounded"
-				}
-			});
+		nitro.scanDocuments = await scanDocs(nitro);
+		if (nitro.options.dev && !hasShownInitialLogs) {
+			hasShownInitialLogs = true;
 			if (resolvers.length > 0) {
 				const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
 				const typeCount = {
@@ -156,16 +150,16 @@ async function setupNitroGraphQL(nitro) {
 				if (typeCount.type > 0) breakdown.push(`${typeCount.type} type`);
 				if (typeCount.subscription > 0) breakdown.push(`${typeCount.subscription} subscription`);
 				if (typeCount.directive > 0) breakdown.push(`${typeCount.directive} directive`);
-				if (breakdown.length > 0) consola.success(`[nitro-graphql] ${totalExports} resolver export(s): ${breakdown.join(", ")}`);
-			} else consola.warn("[nitro-graphql] No resolvers found. Check /_nitro/graphql/debug for details.");
+				if (breakdown.length > 0) logger.success(`${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+			} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
 		}
 	});
 	await rollupConfig(nitro);
 	await serverTypeGeneration(nitro);
-	await clientTypeGeneration(nitro);
+	await clientTypeGeneration(nitro, { isInitial: true });
 	nitro.hooks.hook("close", async () => {
-		await serverTypeGeneration(nitro);
-		await clientTypeGeneration(nitro);
+		await serverTypeGeneration(nitro, { silent: true });
+		await clientTypeGeneration(nitro, { silent: true });
 	});
 	const runtime = fileURLToPath(new URL("routes", import.meta.url));
 	const methods = [
@@ -188,14 +182,11 @@ async function setupNitroGraphQL(nitro) {
 		handler: join(runtime, "health"),
 		method: "GET"
 	});
-	if (nitro.options.dev) {
-		nitro.options.handlers.push({
-			route: "/_nitro/graphql/debug",
-			handler: join(runtime, "debug"),
-			method: "GET"
-		});
-		consola.info("[nitro-graphql] Debug dashboard available at: /_nitro/graphql/debug");
-	}
+	if (nitro.options.dev) nitro.options.handlers.push({
+		route: "/_nitro/graphql/debug",
+		handler: join(runtime, "debug"),
+		method: "GET"
+	});
 	if (nitro.options.imports) {
 		nitro.options.imports.presets ??= [];
 		nitro.options.imports.presets.push({
@@ -380,10 +371,10 @@ declare module 'nitro/h3' {
 export {}
 `, "server context.d.ts");
 		if (existsSync(join(nitro.graphql.serverDir, "context.ts"))) {
-			consola.warn("nitro-graphql: Found context.ts file. Please rename it to context.d.ts for type-only definitions.");
-			consola.info("The context file should now be context.d.ts instead of context.ts");
+			logger.warn("Found context.ts file. Please rename it to context.d.ts for type-only definitions.");
+			logger.info("The context file should now be context.d.ts instead of context.ts");
 		}
-	} else consola.info("[nitro-graphql] Scaffold file generation is disabled (library mode)");
+	} else logger.info("Scaffold file generation is disabled (library mode)");
 }
 
 //#endregion

package/dist/types/define.d.mts

@@ -8,7 +8,18 @@ import { NPMConfig } from "#graphql/server";
 type Flatten<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
 type DefineServerConfig<T extends NPMConfig = NPMConfig> = T['framework'] extends 'graphql-yoga' ? Partial<YogaServerOptions<H3Event, Partial<H3Event>>> : T['framework'] extends 'apollo-server' ? Partial<ApolloServerOptions<H3Event>> : Partial<YogaServerOptions<H3Event, Partial<H3Event>>> | Partial<ApolloServerOptions<H3Event>>;
 type DirectiveLocationName = 'QUERY' | 'MUTATION' | 'SUBSCRIPTION' | 'FIELD' | 'FRAGMENT_DEFINITION' | 'FRAGMENT_SPREAD' | 'INLINE_FRAGMENT' | 'VARIABLE_DEFINITION' | 'SCHEMA' | 'SCALAR' | 'OBJECT' | 'FIELD_DEFINITION' | 'ARGUMENT_DEFINITION' | 'INTERFACE' | 'UNION' | 'ENUM' | 'ENUM_VALUE' | 'INPUT_OBJECT' | 'INPUT_FIELD_DEFINITION';
+type GraphQLScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'JSON' | 'DateTime';
+type GraphQLBaseType = GraphQLScalarType | (string & {});
 type GraphQLArgumentType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'JSON' | 'DateTime' | 'String!' | 'Int!' | 'Float!' | 'Boolean!' | 'ID!' | 'JSON!' | 'DateTime!' | '[String]' | '[String!]' | '[String]!' | '[String!]!' | '[Int]' | '[Int!]' | '[Int]!' | '[Int!]!' | '[Float]' | '[Float!]' | '[Float]!' | '[Float!]!' | '[Boolean]' | '[Boolean!]' | '[Boolean]!' | '[Boolean!]!' | '[ID]' | '[ID!]' | '[ID]!' | '[ID!]!' | '[JSON]' | '[JSON!]' | '[JSON]!' | '[JSON!]!' | '[DateTime]' | '[DateTime!]' | '[DateTime]!' | '[DateTime!]!' | (string & {});
+interface DirectiveArgument<T extends GraphQLArgumentType = GraphQLArgumentType> {
+  /**
+   * GraphQL type for the argument
+   * @example 'String', 'Int!', '[String!]!', 'DateTime', 'JSON'
+   */
+  type: T;
+  defaultValue?: any;
+  description?: string;
+}
 interface DirectiveArg {
   type: GraphQLArgumentType;
   defaultValue?: any;
@@ -35,4 +46,4 @@ interface DefineDirectiveConfig {
   transformer?: (schema: GraphQLSchema) => GraphQLSchema;
 }
 //#endregion
-export { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten };
+export { DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType };

package/dist/types/define.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/types/index.d.mts

@@ -243,4 +243,4 @@ interface NitroGraphQLOptions {
   paths?: PathsConfig;
 }
 //#endregion
-export { ClientUtilsConfig, CodegenClientConfig, ExternalGraphQLService, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, ScaffoldConfig, SdkConfig, TypesConfig };
+export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, StandardSchemaV1, TypesConfig };

package/dist/types/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/types/standard-schema.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/utils/client-codegen.d.mts

@@ -23,7 +23,10 @@ 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, virtualTypesPath?: 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;
 }>;

package/dist/utils/client-codegen.mjs

@@ -165,9 +165,9 @@ async function loadGraphQLDocuments(patterns) {
 		else throw e;
 	}
 }
-async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath) {
+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}` : "";

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/index.d.mts

@@ -1,5 +1,6 @@
 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 };