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

package/dist/nitro/setup.d.mts

@@ -0,0 +1,12 @@
+import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup.d.ts
+
+/**
+ * Main setup function for nitro-graphql
+ * Coordinates all initialization steps for the module
+ */
+declare function setupNitroGraphQL(nitro: Nitro): Promise<void>;
+//#endregion
+export { resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/setup.mjs

@@ -0,0 +1,231 @@
+import { FRAMEWORK_NITRO, FRAMEWORK_NUXT, LOG_TAG } from "../core/constants.mjs";
+import { generateDirectiveSchemas } from "../core/utils/directive-parser.mjs";
+import { validateExternalServices } from "../core/validation/external-services.mjs";
+import { NitroAdapter } from "./adapter.mjs";
+import { getDefaultPaths } from "./paths.mjs";
+import { generateClientTypes, generateServerTypes } from "./codegen.mjs";
+import { DEFAULT_RUNTIME_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG } from "./config.mjs";
+import { rollupConfig } from "./rollup.mjs";
+import { getWatchDirectories, setupFileWatcher } from "./setup/file-watcher.mjs";
+import { logStartupInfo, resolveSecurityConfig } from "./setup/logging.mjs";
+import { setupRollupChunking, setupRollupExternals } from "./setup/rollup-integration.mjs";
+import { registerRouteHandlers } from "./setup/routes.mjs";
+import { setupTypeScriptPaths } from "./setup/ts-config.mjs";
+import defu from "defu";
+import consola from "consola";
+import { relative, resolve } from "pathe";
+
+//#region src/nitro/setup.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Scan all GraphQL files and update Nitro state
+*/
+async function scanAllGraphQLFiles(nitro) {
+	const directivesResult = await NitroAdapter.scanDirectives(nitro);
+	nitro.scanDirectives = directivesResult.items;
+	if (!nitro.scanSchemas) nitro.scanSchemas = [];
+	const directivesPath = await generateDirectiveSchemas(nitro, directivesResult.items);
+	const schemas = (await NitroAdapter.scanSchemas(nitro)).items;
+	if (directivesPath && !schemas.includes(directivesPath)) schemas.push(directivesPath);
+	nitro.scanSchemas = schemas;
+	nitro.scanDocuments = (await NitroAdapter.scanDocuments(nitro)).items;
+	nitro.scanResolvers = (await NitroAdapter.scanResolvers(nitro)).items;
+}
+/**
+* Main setup function for nitro-graphql
+* Coordinates all initialization steps for the module
+*/
+async function setupNitroGraphQL(nitro) {
+	const serverEnabled = nitro.options.graphql?.server !== false;
+	initializeConfiguration(nitro, serverEnabled);
+	validateConfiguration(nitro);
+	setupBuildDirectories(nitro);
+	if (serverEnabled) {
+		setupRollupExternals(nitro);
+		setupRollupChunking(nitro);
+	}
+	initializeRuntimeConfig(nitro);
+	setupFileWatching(nitro, serverEnabled);
+	await scanGraphQLFiles(nitro, serverEnabled);
+	if (serverEnabled) setupDevHooks(nitro);
+	if (serverEnabled) await rollupConfig(nitro);
+	await generateTypes(nitro, serverEnabled);
+	setupCloseHooks(nitro, serverEnabled);
+	if (serverEnabled) registerRouteHandlers(nitro);
+	setupTypeScriptConfiguration(nitro);
+	setupNuxtIntegration(nitro);
+	logStartupInfo(nitro, serverEnabled);
+}
+/**
+* Initialize default configuration values
+*/
+function initializeConfiguration(nitro, serverEnabled) {
+	nitro.options.graphql ||= {};
+	nitro.options.graphql.types = defu(nitro.options.graphql.types, DEFAULT_TYPES_CONFIG);
+	if (serverEnabled && !nitro.options.graphql?.framework) logger.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
+	const defaultPaths = getDefaultPaths(nitro);
+	nitro.graphql ||= {
+		buildDir: "",
+		watchDirs: [],
+		clientDir: defaultPaths.clientGraphql,
+		serverDir: defaultPaths.serverGraphql,
+		dir: {
+			build: relative(nitro.options.rootDir, nitro.options.buildDir),
+			client: "graphql",
+			server: "server"
+		}
+	};
+	nitro.scanSchemas ||= [];
+	nitro.scanResolvers ||= [];
+	nitro.scanDirectives ||= [];
+	nitro.scanDocuments ||= [];
+}
+/**
+* Validate external services configuration
+*/
+function validateConfiguration(nitro) {
+	if (nitro.options.graphql?.externalServices?.length) {
+		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
+		if (validationErrors.length > 0) {
+			logger.error("External services configuration errors:");
+			for (const error of validationErrors) logger.error(`  - ${error}`);
+			throw new Error("Invalid external services configuration");
+		}
+		logger.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+	}
+	if (nitro.options.graphql?.federation?.enabled) logger.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
+}
+/**
+* Setup build directories
+*/
+function setupBuildDirectories(nitro) {
+	const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
+	nitro.graphql.buildDir = graphqlBuildDir;
+	switch (nitro.options.framework.name) {
+		case FRAMEWORK_NUXT:
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			break;
+		case FRAMEWORK_NITRO:
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			break;
+		default: break;
+	}
+}
+/**
+* Initialize runtime configuration
+*/
+function initializeRuntimeConfig(nitro) {
+	const securityConfig = resolveSecurityConfig(nitro.options.graphql?.security);
+	nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
+		...DEFAULT_RUNTIME_CONFIG,
+		security: securityConfig
+	});
+}
+/**
+* Setup file watching for development mode
+*/
+function setupFileWatching(nitro, serverEnabled) {
+	const watchDirs = serverEnabled ? getWatchDirectories(nitro) : [nitro.graphql.clientDir].filter(Boolean);
+	nitro.graphql.watchDirs = watchDirs;
+	const watcher = setupFileWatcher(nitro, watchDirs);
+	nitro.hooks.hook("close", () => {
+		watcher.close();
+	});
+}
+/**
+* Scan all GraphQL files (schemas, resolvers, directives, documents)
+*/
+async function scanGraphQLFiles(nitro, serverEnabled) {
+	const skipLocalScan = nitro.options.graphql?.skipLocalScan === true;
+	const extendSources = nitro.options.graphql?.extend;
+	if (skipLocalScan && extendSources?.length) {
+		logger.info(`Using ${extendSources.length} extend source(s), skipping local scanning`);
+		nitro.scanSchemas = [];
+		nitro.scanResolvers = [];
+		nitro.scanDirectives = [];
+		nitro.scanDocuments = (await NitroAdapter.scanDocuments(nitro)).items;
+		return;
+	}
+	if (serverEnabled) await scanAllGraphQLFiles(nitro);
+	else nitro.scanDocuments = (await NitroAdapter.scanDocuments(nitro)).items;
+}
+/**
+* Setup dev mode hooks for rescanning files
+*/
+function setupDevHooks(nitro) {
+	let hasShownInitialLogs = false;
+	nitro.hooks.hook("dev:start", async () => {
+		await scanAllGraphQLFiles(nitro);
+		if (nitro.options.dev && !hasShownInitialLogs) {
+			hasShownInitialLogs = true;
+			logResolverDiagnostics(nitro);
+		}
+	});
+}
+/**
+* Log resolver diagnostics for development
+*/
+function logResolverDiagnostics(nitro) {
+	const resolvers = nitro.scanResolvers || [];
+	if (resolvers.length > 0) {
+		const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
+		const typeCount = {
+			query: 0,
+			mutation: 0,
+			resolver: 0,
+			type: 0,
+			subscription: 0,
+			directive: 0
+		};
+		for (const resolver of resolvers) for (const imp of resolver.imports) if (imp.type in typeCount) typeCount[imp.type]++;
+		const breakdown = [];
+		if (typeCount.query > 0) breakdown.push(`${typeCount.query} query`);
+		if (typeCount.mutation > 0) breakdown.push(`${typeCount.mutation} mutation`);
+		if (typeCount.resolver > 0) breakdown.push(`${typeCount.resolver} resolver`);
+		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) logger.success(`${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+	} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
+}
+/**
+* Generate server and client types
+*/
+async function generateTypes(nitro, serverEnabled) {
+	if (serverEnabled) {
+		await generateServerTypes(nitro);
+		await generateClientTypes(nitro, { isInitial: true });
+	} else await generateClientTypes(nitro, { isInitial: true });
+}
+/**
+* Setup close hooks for final type generation
+*/
+function setupCloseHooks(nitro, serverEnabled) {
+	nitro.hooks.hook("close", async () => {
+		if (serverEnabled) await generateServerTypes(nitro, { silent: true });
+		await generateClientTypes(nitro, { silent: true });
+	});
+}
+/**
+* Setup TypeScript configuration and path aliases
+*/
+function setupTypeScriptConfiguration(nitro) {
+	nitro.options.typescript.strict = DEFAULT_TYPESCRIPT_STRICT;
+	nitro.hooks.hook("types:extend", (types) => {
+		setupTypeScriptPaths(nitro, types);
+	});
+}
+/**
+* Setup Nuxt-specific integration
+*/
+function setupNuxtIntegration(nitro) {
+	if (nitro.options.framework?.name === FRAMEWORK_NUXT && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
+		const nuxtOptions = nitro._nuxt?.options;
+		if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
+	});
+}
+
+//#endregion
+export { resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/types.d.mts

@@ -0,0 +1,378 @@
+import { TypeScriptPluginConfig } from "@graphql-codegen/typescript";
+import { plugin as plugin$1 } from "@graphql-codegen/typescript-generic-sdk";
+import { TypeScriptDocumentsPluginConfig } from "@graphql-codegen/typescript-operations";
+import { IResolvers } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
+import { TypeScriptResolversPluginConfig } from "@graphql-codegen/typescript-resolvers";
+import { ESMCodeGenOptions } from "knitwork";
+import { ApolloServerOptions } from "@apollo/server";
+import { H3Event } from "nitro/h3";
+import { YogaServerOptions } from "graphql-yoga";
+import { NPMConfig } from "#graphql/server";
+
+//#region src/nitro/types.d.ts
+
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+  export {};
+}
+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;
+  description?: string;
+}
+interface DirectiveDefinition {
+  name: string;
+  locations: DirectiveLocationName[];
+  args?: Record<string, DirectiveArg>;
+  description?: string;
+  isRepeatable?: boolean;
+  transformer?: (schema: GraphQLSchema) => GraphQLSchema;
+}
+interface DefineDirectiveConfig {
+  name: string;
+  locations: ReadonlyArray<DirectiveLocationName>;
+  args?: Record<string, {
+    type: GraphQLArgumentType;
+    defaultValue?: any;
+    description?: string;
+  }>;
+  description?: string;
+  isRepeatable?: boolean;
+  transformer?: (schema: GraphQLSchema) => GraphQLSchema;
+}
+type CodegenServerConfig = TypeScriptPluginConfig & TypeScriptResolversPluginConfig;
+type DocumentModeConfig = Pick<Parameters<typeof plugin$1>[2], 'documentMode'>;
+type DocumentModeEnum = NonNullable<DocumentModeConfig['documentMode']>;
+type DocumentModeType = `${DocumentModeEnum}`;
+type GenericSdkConfig = Omit<Parameters<typeof plugin$1>[2], 'documentMode'> & {
+  documentMode?: DocumentModeType;
+};
+type CodegenClientConfig = TypeScriptPluginConfig & TypeScriptDocumentsPluginConfig & {
+  endpoint?: string;
+  /**
+   * Generate TypedDocumentNode exports for urql/Apollo Client compatibility.
+   * When enabled, generates typed document constants that can be used with
+   * any GraphQL client that supports TypedDocumentNode.
+   * @default false
+   */
+  typedDocumentNode?: boolean;
+};
+interface IESMImport {
+  name: string;
+  as?: string;
+  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription' | 'directive';
+}
+interface GenImport {
+  specifier: string;
+  imports: IESMImport[];
+  options?: ESMCodeGenOptions;
+}
+declare module 'nitro/types' {
+  interface Nitro {
+    scanSchemas: string[];
+    scanDocuments: string[];
+    scanResolvers: GenImport[];
+    scanDirectives: GenImport[];
+    graphql: {
+      buildDir: string;
+      watchDirs: string[];
+      clientDir: string;
+      serverDir: string;
+      dir: {
+        build: string;
+        client: string;
+        server: string;
+      };
+    };
+  }
+}
+declare module 'nitro/types' {
+  interface NitroOptions {
+    graphql?: NitroGraphQLOptions;
+  }
+  interface NitroRuntimeConfig {
+    graphql?: NitroGraphQLOptions;
+  }
+  interface NitroConfig {
+    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;
+}
+interface ExternalGraphQLService {
+  /** Unique name for this service (used for file naming and type generation) */
+  name: string;
+  /** GraphQL endpoint for this service (also used as schema source if `schema` is not specified) */
+  endpoint: string;
+  /**
+   * Schema source - can be URL(s) for remote schemas or file path(s) for local schemas
+   * @default Uses `endpoint` for introspection if not specified
+   */
+  schema?: string | string[];
+  /** Optional headers for schema introspection and client requests */
+  headers?: Record<string, string> | (() => Record<string, string>);
+  /** Optional: specific document patterns for this service */
+  documents?: string[];
+  /**
+   * Optional: Download and cache schema locally for offline usage
+   * - true or 'once': Download if file doesn't exist, then use cached version (offline-friendly)
+   * - 'always': Check for updates on every build (current behavior)
+   * - 'manual': Never download automatically, user manages schema files manually
+   * - false: Disable schema downloading
+   */
+  downloadSchema?: boolean | 'once' | 'always' | 'manual';
+  /** Optional: Custom path to save downloaded schema (default: .nitro/graphql/schemas/[serviceName].graphql) */
+  downloadPath?: string;
+  /** Optional: service-specific codegen configuration */
+  codegen?: {
+    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 */
+  enabled: boolean;
+  /** Service name for federation (used in subgraph config) */
+  serviceName?: string;
+  /** Service version for federation */
+  serviceVersion?: string;
+  /** 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;
+/**
+ * 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;
+}
+/**
+ * Security configuration for production environments
+ * All options auto-detect based on NODE_ENV when not explicitly set
+ */
+interface SecurityConfig {
+  /**
+   * Enable GraphQL introspection queries
+   * @default true in development, false in production
+   */
+  introspection?: boolean;
+  /**
+   * Enable GraphQL playground/sandbox UI
+   * @default true in development, false in production
+   */
+  playground?: boolean;
+  /**
+   * Mask internal error details in responses
+   * When enabled, internal errors show "Internal server error" instead of actual message
+   * @default false in development, true in production
+   */
+  maskErrors?: boolean;
+  /**
+   * Disable "Did you mean X?" field suggestions in error messages
+   * Prevents attackers from discovering field names via brute force
+   * @default false in development, true in production
+   */
+  disableSuggestions?: boolean;
+}
+interface NitroGraphQLOptions {
+  framework?: 'graphql-yoga' | 'apollo-server';
+  /**
+   * Enable/disable GraphQL server functionality
+   * When set to false, only external services client types will be generated
+   * Server routes, resolvers, schemas, and directives will not be processed
+   * @default true
+   */
+  server?: boolean;
+  endpoint?: {
+    graphql?: string;
+    healthCheck?: string;
+  };
+  playground?: boolean;
+  typedefs?: string[];
+  resolvers?: Array<IResolvers<any, any>>;
+  loader?: {
+    include?: RegExp;
+    exclude?: RegExp;
+    validate?: boolean;
+  };
+  codegen?: {
+    server?: CodegenServerConfig;
+    client?: CodegenClientConfig;
+    clientSDK?: GenericSdkConfig;
+  };
+  /** External GraphQL services to generate types and SDKs for */
+  externalServices?: ExternalGraphQLService[];
+  /** Apollo Federation configuration */
+  federation?: FederationConfig;
+  /** Server GraphQL directory path */
+  serverDir?: string;
+  /** Layer directories (populated by Nuxt module) */
+  layerDirectories?: string[];
+  layerServerDirs?: string[];
+  layerAppDirs?: string[];
+  /**
+   * 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;
+  /**
+   * Security configuration for production environments
+   * Auto-detects NODE_ENV and applies secure defaults in production
+   */
+  security?: SecurityConfig;
+  /**
+   * Extend GraphQL server with external packages
+   * Auto-appends /resolvers and /schema to each package path
+   * @example extend: ['@myorg/graphql', './generated']
+   */
+  extend?: ExtendSource[];
+  /**
+   * Skip local file scanning, use only extend sources
+   * When true, only files from `extend` are used (local server/graphql ignored)
+   * @default false
+   */
+  skipLocalScan?: boolean;
+}
+/**
+ * Extend source - package path or detailed config
+ * - string: auto-appends /resolvers and /schema
+ * - object: explicit paths for resolvers and/or schemas
+ */
+type ExtendSource = string | {
+  resolvers?: string | string[];
+  schemas?: string | string[];
+};
+//#endregion
+export { CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, NitroGraphQLOptions, PathsConfig, SdkConfig, SecurityConfig, StandardSchemaV1, TypesConfig };

package/dist/nitro/types.mjs

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

package/dist/nitro/virtual/generators.d.mts

@@ -0,0 +1,31 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/virtual/generators.d.ts
+
+declare const serverSchemas: {
+  id: string;
+  getCode: (nitro: Nitro) => string;
+};
+declare const serverResolvers: {
+  id: string;
+  getCode: (nitro: Nitro) => string;
+};
+declare const serverDirectives: {
+  id: string;
+  getCode: (nitro: Nitro) => string;
+};
+declare const graphqlConfig: {
+  id: string;
+  getCode: (nitro: Nitro) => string;
+};
+declare const moduleConfig: {
+  id: string;
+  getCode: (nitro: Nitro) => string;
+};
+declare const debugInfo: {
+  id: string;
+  getCode: (nitro: Nitro) => string;
+};
+declare function registerAllVirtualModules(nitro: Nitro): void;
+//#endregion
+export { debugInfo, graphqlConfig, moduleConfig, registerAllVirtualModules, serverDirectives, serverResolvers, serverSchemas };