nitro-graphql 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/core/types/codegen.d.mts

@@ -0,0 +1,133 @@
+import { Source } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/types/codegen.d.ts
+
+/**
+ * Scalar type mapping (can be string or input/output object)
+ */
+type ScalarType = string | {
+  input: string;
+  output: string;
+};
+/**
+ * Server codegen configuration
+ */
+interface ServerCodegenConfig {
+  scalars?: Record<string, ScalarType>;
+  defaultScalarType?: string;
+  defaultMapper?: string;
+  contextType?: string;
+  maybeValue?: string;
+  inputMaybeValue?: string;
+  declarationKind?: string;
+  enumsAsTypes?: boolean;
+  federation?: boolean;
+  [key: string]: unknown;
+}
+/**
+ * Client codegen configuration
+ */
+interface ClientCodegenConfig {
+  emitLegacyCommonJSImports?: boolean;
+  useTypeImports?: boolean;
+  enumsAsTypes?: boolean;
+  strictScalars?: boolean;
+  maybeValue?: string;
+  inputMaybeValue?: string;
+  documentMode?: string;
+  pureMagicComment?: boolean;
+  dedupeOperationSuffix?: boolean;
+  rawRequest?: boolean;
+  scalars?: Record<string, ScalarType>;
+  typedDocumentNode?: boolean;
+  [key: string]: unknown;
+}
+/**
+ * SDK codegen configuration
+ */
+interface SdkCodegenConfig extends ClientCodegenConfig {
+  [key: string]: unknown;
+}
+/**
+ * Input for server type generation
+ */
+interface ServerCodegenInput {
+  /** GraphQL framework name */
+  framework: string;
+  /** Parsed GraphQL schema */
+  schema: GraphQLSchema;
+  /** Server codegen configuration */
+  config?: ServerCodegenConfig;
+  /** Whether federation is enabled */
+  federationEnabled?: boolean;
+  /** Output filename (optional) */
+  outputPath?: string;
+}
+/**
+ * Result of server type generation
+ */
+interface ServerCodegenResult {
+  /** Generated TypeScript types content */
+  types: string;
+  /** Printed GraphQL schema */
+  schemaString: string;
+}
+/**
+ * Input for client type generation
+ */
+interface ClientCodegenInput {
+  /** Parsed GraphQL schema */
+  schema: GraphQLSchema;
+  /** Loaded GraphQL documents */
+  documents: Source[];
+  /** Client codegen configuration */
+  config?: ClientCodegenConfig;
+  /** SDK codegen configuration */
+  sdkConfig?: SdkCodegenConfig;
+  /** Output filename (optional) */
+  outputPath?: string;
+  /** Service name for external services */
+  serviceName?: string;
+  /** Virtual types import path */
+  virtualTypesPath?: string;
+  /** Generation options */
+  options?: {
+    silent?: boolean;
+    isInitial?: boolean;
+  };
+}
+/**
+ * Result of client type generation
+ */
+interface ClientCodegenResult {
+  /** Generated TypeScript types content */
+  types: string;
+  /** Generated SDK content */
+  sdk: string;
+}
+/**
+ * External service configuration for codegen
+ */
+interface ExternalServiceCodegenConfig {
+  name: string;
+  schema: string | string[];
+  endpoint: string;
+  headers?: Record<string, string> | (() => Record<string, string>);
+  documents?: string[];
+  downloadSchema?: boolean | 'once' | 'always' | 'manual';
+  downloadPath?: string;
+  codegen?: {
+    client?: ClientCodegenConfig;
+    clientSDK?: SdkCodegenConfig;
+  };
+}
+/**
+ * Schema loading options
+ */
+interface SchemaLoadOptions {
+  headers?: Record<string, string>;
+  loaders?: unknown[];
+}
+//#endregion
+export { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, ExternalServiceCodegenConfig, ScalarType, SchemaLoadOptions, SdkCodegenConfig, ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult };

package/dist/core/types/config.d.mts

@@ -0,0 +1,212 @@
+import { GraphQLFramework } from "../constants.mjs";
+
+//#region src/core/types/config.d.ts
+
+/**
+ * Core logger interface
+ * Abstracts logging functionality for framework independence
+ */
+interface CoreLogger {
+  info: (message: string, ...args: unknown[]) => void;
+  warn: (message: string, ...args: unknown[]) => void;
+  error: (message: string, ...args: unknown[]) => void;
+  success: (message: string, ...args: unknown[]) => void;
+  debug: (message: string, ...args: unknown[]) => void;
+}
+/**
+ * GraphQL codegen configuration
+ */
+interface CoreCodegenConfig {
+  /** Server-side codegen options */
+  server?: Record<string, unknown>;
+  /** Client-side codegen options */
+  client?: Record<string, unknown>;
+  /** Client SDK codegen options */
+  clientSDK?: Record<string, unknown>;
+}
+/**
+ * Security configuration options
+ */
+interface CoreSecurityConfig {
+  /** Enable/disable GraphQL introspection */
+  introspection?: boolean;
+  /** Enable/disable GraphQL playground */
+  playground?: boolean;
+  /** Enable/disable error masking in responses */
+  maskErrors?: boolean;
+  /** Disable field suggestions in error messages */
+  disableSuggestions?: boolean;
+}
+/**
+ * External GraphQL service configuration
+ */
+interface CoreExternalService {
+  /** Unique service name */
+  name: string;
+  /** GraphQL schema URL or file path */
+  schema: string;
+  /** GraphQL endpoint URL */
+  endpoint: string;
+  /** Headers for schema introspection */
+  headers?: Record<string, string> | (() => Record<string, string>);
+  /** Document patterns for this service */
+  documents?: string[];
+  /** Service-specific path overrides */
+  paths?: {
+    sdk?: string;
+    types?: string;
+    ofetch?: string;
+  };
+}
+/**
+ * Apollo Federation configuration
+ */
+interface CoreFederationConfig {
+  /** Enable federation support */
+  enabled?: boolean;
+  /** Service name for federation */
+  serviceName?: string;
+}
+/**
+ * Path configuration with placeholders
+ */
+interface CorePathsConfig {
+  /** Server GraphQL directory (default: 'server/graphql') */
+  serverGraphql?: string;
+  /** Client GraphQL directory (default: 'app/graphql' or 'graphql') */
+  clientGraphql?: string;
+  /** Build directory (default: '.nitro' or '.nuxt') */
+  buildDir?: string;
+  /** Types output directory (default: '{buildDir}/types') */
+  typesDir?: string;
+}
+/**
+ * Scaffold file generation configuration
+ */
+interface CoreScaffoldConfig {
+  /** Master switch for all scaffold files */
+  enabled?: boolean;
+  /** Generate graphql.config.ts */
+  graphqlConfig?: boolean | string;
+  /** Generate server schema.ts */
+  serverSchema?: boolean | string;
+  /** Generate server config.ts */
+  serverConfig?: boolean | string;
+  /** Generate server context.d.ts */
+  serverContext?: boolean | string;
+}
+/**
+ * Type generation configuration
+ */
+interface CoreTypesConfig {
+  /** Master switch for type generation */
+  enabled?: boolean;
+  /** Server types output path */
+  server?: boolean | string;
+  /** Client types output path */
+  client?: boolean | string;
+  /** External service types output path */
+  external?: boolean | string;
+}
+/**
+ * SDK generation configuration
+ */
+interface CoreSdkConfig {
+  /** Master switch for SDK generation */
+  enabled?: boolean;
+  /** Main SDK output path */
+  main?: boolean | string;
+  /** External service SDK output path */
+  external?: boolean | string;
+}
+/**
+ * Client utilities configuration
+ */
+interface CoreClientUtilsConfig {
+  /** Master switch for client utilities */
+  enabled?: boolean;
+  /** Index file output path */
+  index?: boolean | string;
+  /** Ofetch client output path */
+  ofetch?: boolean | string;
+}
+/**
+ * Core GraphQL options
+ * Framework-agnostic GraphQL configuration
+ */
+interface CoreGraphQLOptions {
+  /** GraphQL framework to use */
+  framework?: GraphQLFramework;
+  /** GraphQL endpoint path */
+  endpoint?: string;
+  /** Codegen configuration */
+  codegen?: CoreCodegenConfig;
+  /** Security configuration */
+  security?: CoreSecurityConfig;
+  /** External GraphQL services */
+  externalServices?: CoreExternalService[];
+  /** Apollo Federation configuration */
+  federation?: CoreFederationConfig;
+  /** Path configuration */
+  paths?: CorePathsConfig;
+  /** Scaffold file configuration */
+  scaffold?: false | CoreScaffoldConfig;
+  /** Type generation configuration */
+  types?: false | CoreTypesConfig;
+  /** SDK generation configuration */
+  sdk?: false | CoreSdkConfig;
+  /** Client utilities configuration */
+  clientUtils?: false | CoreClientUtilsConfig;
+}
+/**
+ * Core configuration
+ * Main configuration interface that replaces Nitro-specific options
+ */
+interface CoreConfig {
+  /** Root directory of the project */
+  rootDir: string;
+  /** Build output directory */
+  buildDir: string;
+  /** Server GraphQL directory */
+  serverDir: string;
+  /** Client GraphQL directory */
+  clientDir: string;
+  /** Types output directory */
+  typesDir: string;
+  /** GraphQL framework to use */
+  framework: GraphQLFramework;
+  /** Whether running in Nuxt context */
+  isNuxt: boolean;
+  /** Whether running in development mode */
+  isDev: boolean;
+  /** GraphQL options */
+  graphqlOptions: CoreGraphQLOptions;
+  /** Logger instance */
+  logger: CoreLogger;
+  /** Patterns to ignore during scanning */
+  ignorePatterns: string[];
+  /** Layer server directories (Nuxt) */
+  layerServerDirs?: string[];
+  /** Layer app directories (Nuxt) */
+  layerAppDirs?: string[];
+}
+/**
+ * Core context for runtime operations
+ * Holds resolved configuration and state
+ */
+interface CoreContext {
+  /** Resolved configuration */
+  config: CoreConfig;
+  /** GraphQL build directory */
+  graphqlBuildDir: string;
+  /** Watch directories for file watching */
+  watchDirs: string[];
+  /** Relative directory paths */
+  dir: {
+    build: string;
+    client: string;
+    server: string;
+  };
+}
+//#endregion
+export { CoreClientUtilsConfig, CoreCodegenConfig, CoreConfig, CoreContext, CoreExternalService, CoreFederationConfig, CoreGraphQLOptions, CoreLogger, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig };

package/dist/core/types/config.mjs

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

package/dist/{utils/define.d.ts → core/types/define.d.mts}

@@ -1,23 +1,8 @@
 import { GraphQLSchema } from "graphql";
-import { ApolloServerOptions } from "@apollo/server";
-import { H3Event } from "h3";
-import { YogaServerOptions } from "graphql-yoga";
-import { NPMConfig, Resolvers, ResolversTypes } from "#graphql/server";
-import { StandardSchemaV1 } from "nitro-graphql";
 
-//#region src/utils/define.d.ts
+//#region src/core/types/define.d.ts
+
 type Flatten<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
-declare function defineSchema<T extends Partial<Record<keyof ResolversTypes, StandardSchemaV1>>>(config: T): Flatten<T>;
-declare function defineResolver(resolvers: Resolvers): Resolvers;
-type ResolverQuery = Resolvers extends {
-  Query: infer Q;
-} ? Q : never;
-declare function defineQuery(resolvers?: Resolvers['Query']): Resolvers;
-declare function defineMutation(resolvers?: Resolvers['Mutation']): Resolvers;
-declare function defineSubscription(resolvers?: Resolvers['Subscription']): Resolvers;
-declare function defineType(resolvers: Resolvers): Resolvers;
-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>>;
-declare function defineGraphQLConfig<T extends NPMConfig = NPMConfig>(config: Partial<DefineServerConfig<T>>): Partial<DefineServerConfig<T>>;
 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 & {});
@@ -56,17 +41,5 @@ interface DefineDirectiveConfig {
   isRepeatable?: boolean;
   transformer?: (schema: GraphQLSchema) => GraphQLSchema;
 }
-/**
- * Helper function to create directive arguments with proper type inference
- * @example
- * args: {
- *   myArg: arg('String!', { defaultValue: 'hello' })
- * }
- */
-declare function arg<T extends GraphQLArgumentType>(type: T, options?: {
-  defaultValue?: any;
-  description?: string;
-}): DirectiveArgument<T>;
-declare function defineDirective(config: DefineDirectiveConfig): DirectiveDefinition;
 //#endregion
-export { DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, ResolverQuery, arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };
+export { DefineDirectiveConfig, DirectiveArgument, DirectiveDefinition, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType };

package/dist/core/types/define.mjs

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

package/dist/core/types/index.d.mts

@@ -0,0 +1,5 @@
+import { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, ExternalServiceCodegenConfig, ScalarType, SchemaLoadOptions, SdkCodegenConfig, ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult } from "./codegen.mjs";
+import { CoreClientUtilsConfig, CoreCodegenConfig, CoreConfig, CoreContext, CoreExternalService, CoreFederationConfig, CoreGraphQLOptions, CoreLogger, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig } from "./config.mjs";
+import { DefineDirectiveConfig, DirectiveArgument, DirectiveDefinition, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType } from "./define.mjs";
+import { ResolverImport, ScanContext, ScanResult, ScannedFile, ScannedResolver } from "./scanning.mjs";
+export { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, CoreClientUtilsConfig, CoreCodegenConfig, CoreConfig, CoreContext, CoreExternalService, CoreFederationConfig, CoreGraphQLOptions, CoreLogger, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig, DefineDirectiveConfig, DirectiveArgument, DirectiveDefinition, ExternalServiceCodegenConfig, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, ResolverImport, ScalarType, ScanContext, ScanResult, ScannedFile, ScannedResolver, SchemaLoadOptions, SdkCodegenConfig, ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult };

package/dist/core/types/index.mjs

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

package/dist/core/types/scanning.d.mts

@@ -0,0 +1,69 @@
+import { CoreLogger } from "./config.mjs";
+
+//#region src/core/types/scanning.d.ts
+
+/**
+ * Scan context for file scanning operations
+ * Provides all necessary information for scanning without framework dependencies
+ */
+interface ScanContext {
+  /** Root directory of the project */
+  rootDir: string;
+  /** Server GraphQL directory */
+  serverDir: string;
+  /** Client GraphQL directory */
+  clientDir: string;
+  /** Patterns to ignore during scanning */
+  ignorePatterns: string[];
+  /** Whether running in development mode */
+  isDev: boolean;
+  /** Logger instance */
+  logger: CoreLogger;
+  /** Layer server directories (Nuxt layers) */
+  layerServerDirs?: string[];
+  /** Layer app directories (Nuxt layers) */
+  layerAppDirs?: string[];
+}
+/**
+ * Generic scan result wrapper
+ * Provides consistent result structure with warnings and errors
+ */
+interface ScanResult<T> {
+  /** Scanned items */
+  items: T[];
+  /** Non-fatal warnings encountered during scanning */
+  warnings: string[];
+  /** Errors encountered during scanning */
+  errors: string[];
+}
+/**
+ * File information from scanning
+ */
+interface ScannedFile {
+  /** Relative path from scan directory */
+  path: string;
+  /** Absolute file path */
+  fullPath: string;
+}
+/**
+ * Resolver import information
+ */
+interface ResolverImport {
+  /** Export name */
+  name: string;
+  /** Resolver type (query, mutation, resolver, type, subscription, directive) */
+  type: 'query' | 'mutation' | 'resolver' | 'type' | 'subscription' | 'directive';
+  /** Aliased import name */
+  as: string;
+}
+/**
+ * Scanned resolver information
+ */
+interface ScannedResolver {
+  /** File specifier (path) */
+  specifier: string;
+  /** Exports from this file */
+  imports: ResolverImport[];
+}
+//#endregion
+export { ResolverImport, ScanContext, ScanResult, ScannedFile, ScannedResolver };

package/dist/core/types/scanning.mjs

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

package/dist/{utils/directive-parser.d.ts → core/utils/directive-parser.d.mts}

@@ -1,4 +1,8 @@
-//#region src/utils/directive-parser.d.ts
+//#region src/core/utils/directive-parser.d.ts
+/**
+ * Directive parser utilities
+ * AST-based parsing for GraphQL directive definitions
+ */
 interface ParsedDirective {
   name: string;
   locations: string[];
@@ -69,12 +73,25 @@ declare class DirectiveParser {
  */
 declare function generateDirectiveSchema(directive: ParsedDirective): string;
 /**
- * Generate directive schemas file from scanned directives
+ * Directive file reference
+ * Can be either { fullPath } or { specifier } (for GenImport compatibility)
  */
-declare function generateDirectiveSchemas(nitro: any, directives: any[]): Promise<void>;
+type DirectiveFileRef = {
+  fullPath: string;
+} | {
+  specifier: string;
+};
 /**
  * Singleton instance for reuse
  */
 declare const directiveParser: DirectiveParser;
+/**
+ * Generate GraphQL schemas from an array of parsed directives
+ */
+declare function generateDirectiveSchemas(nitro: {
+  graphql: {
+    buildDir: string;
+  };
+}, directives: DirectiveFileRef[]): Promise<string | null>;
 //#endregion
-export { DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };
+export { DirectiveFileRef, DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/{utils/directive-parser.js → core/utils/directive-parser.mjs}

@@ -1,4 +1,4 @@
-//#region src/utils/directive-parser.ts
+//#region src/core/utils/directive-parser.ts
 /**
 * Clean AST-based directive parser using oxc-parser
 */
@@ -180,45 +180,36 @@ function generateDirectiveSchema(directive) {
 	return `directive @${directive.name}${args} on ${locations}`;
 }
 /**
-* Generate directive schemas file from scanned directives
+* Get the file path from a directive reference
 */
-async function generateDirectiveSchemas(nitro, directives) {
-	if (directives.length === 0) return;
-	const { existsSync, readFileSync, writeFileSync, mkdirSync } = await import("node:fs");
-	const { readFile } = await import("node:fs/promises");
-	const { resolve, dirname } = await import("pathe");
-	const directiveSchemas = [];
-	const seenDirectives = /* @__PURE__ */ new Set();
-	const parser = new DirectiveParser();
-	for (const dir of directives) for (const _imp of dir.imports) {
-		const fileContent = await readFile(dir.specifier, "utf-8");
-		const directiveDefs = await parser.parseDirectives(fileContent, dir.specifier);
-		for (const def of directiveDefs) {
-			if (seenDirectives.has(def.name)) continue;
-			seenDirectives.add(def.name);
-			const schema = generateDirectiveSchema(def);
-			directiveSchemas.push(schema);
-		}
-	}
-	if (directiveSchemas.length > 0) {
-		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()
-
-${directiveSchemas.join("\n\n")}`;
-		const targetDir = dirname(directivesPath);
-		if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
-		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);
-	}
+function getFilePath(ref) {
+	return "fullPath" in ref ? ref.fullPath : ref.specifier;
 }
 /**
 * Singleton instance for reuse
 */
 const directiveParser = new DirectiveParser();
+/**
+* Generate GraphQL schemas from an array of parsed directives
+*/
+async function generateDirectiveSchemas(nitro, directives) {
+	if (directives.length === 0) return null;
+	const fs = await import("node:fs");
+	const path = await import("pathe");
+	const allParsedDirectives = [];
+	for (const directive of directives) try {
+		const filePath = getFilePath(directive);
+		const content = fs.readFileSync(filePath, "utf-8");
+		const parsed = await directiveParser.parseDirectives(content, filePath);
+		allParsedDirectives.push(...parsed);
+	} catch {}
+	if (allParsedDirectives.length === 0) return null;
+	const schemaContent = allParsedDirectives.map((d) => generateDirectiveSchema(d)).join("\n\n");
+	const directivesPath = path.join(nitro.graphql.buildDir, "_directives.graphql");
+	fs.mkdirSync(path.dirname(directivesPath), { recursive: true });
+	fs.writeFileSync(directivesPath, schemaContent, "utf-8");
+	return directivesPath;
+}
 
 //#endregion
 export { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/core/utils/errors.d.mts

@@ -0,0 +1,77 @@
+//#region src/core/utils/errors.d.ts
+/**
+ * Error handling utilities for GraphQL
+ * Framework-agnostic error masking and handling
+ */
+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/core'
+ *
+ * export default defineGraphQLConfig({
+ *   maskedErrors: {
+ *     maskError: createDefaultMaskError()
+ *   }
+ * })
+ * ```
+ *
+ * @example Custom status codes
+ * ```ts
+ * import { defineGraphQLConfig } from 'nitro-graphql/define'
+ * import { createDefaultMaskError } from 'nitro-graphql/core'
+ *
+ * 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/core'
+ *
+ * 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 };