nitro-graphql 2.0.0-beta.37 → 2.0.0-beta.39

package/dist/{setup → nitro/setup}/ts-config.mjs

@@ -1,8 +1,8 @@
-import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../utils/path-resolver.mjs";
-import { relativeWithDot } from "../utils/imports.mjs";
+import { relativeWithDot } from "../../core/utils/imports.mjs";
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../paths.mjs";
 import { dirname, join, resolve } from "pathe";
 
-//#region src/setup/ts-config.ts
+//#region src/nitro/setup/ts-config.ts
 /**
 * Setup TypeScript path aliases for GraphQL types
 * Called via nitro:config hook to extend tsconfig.json

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/{setup.mjs → nitro/setup.mjs}

@@ -1,35 +1,35 @@
-import { ENDPOINT_DEBUG, FRAMEWORK_NITRO, FRAMEWORK_NUXT, GRAPHQL_HTTP_METHODS, LOG_TAG } from "./constants.mjs";
-import { getDefaultPaths } from "./utils/path-resolver.mjs";
-import { generateServerTypes } from "./codegen/server-types.mjs";
-import { generateClientTypes } from "./codegen/index.mjs";
-import { DEFAULT_RUNTIME_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG } from "./config/defaults.mjs";
-import { validateExternalServices } from "./utils/validation.mjs";
+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 { scanAllGraphQLFiles } from "./setup/graphql-scanner.mjs";
+import { logStartupInfo, resolveSecurityConfig } from "./setup/logging.mjs";
 import { setupRollupChunking, setupRollupExternals } from "./setup/rollup-integration.mjs";
-import { generateScaffoldFiles } from "./setup/scaffold-generator.mjs";
+import { registerRouteHandlers } from "./setup/routes.mjs";
 import { setupTypeScriptPaths } from "./setup/ts-config.mjs";
 import defu from "defu";
-import { fileURLToPath } from "node:url";
 import consola from "consola";
-import { join, relative, resolve } from "pathe";
+import { relative, resolve } from "pathe";
 
-//#region src/setup.ts
+//#region src/nitro/setup.ts
 const logger = consola.withTag(LOG_TAG);
 /**
-* Resolves security configuration with environment-aware defaults
-* In production: introspection off, playground off, errors masked, suggestions disabled
-* In development: introspection on, playground on, errors shown, suggestions enabled
+* Scan all GraphQL files and update Nitro state
 */
-function resolveSecurityConfig(config) {
-	const isProd = process.env.NODE_ENV === "production";
-	return {
-		introspection: config?.introspection ?? !isProd,
-		playground: config?.playground ?? !isProd,
-		maskErrors: config?.maskErrors ?? isProd,
-		disableSuggestions: config?.disableSuggestions ?? isProd
-	};
+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
@@ -54,7 +54,6 @@ async function setupNitroGraphQL(nitro) {
 	if (serverEnabled) registerRouteHandlers(nitro);
 	setupTypeScriptConfiguration(nitro);
 	setupNuxtIntegration(nitro);
-	if (serverEnabled) generateScaffoldFiles(nitro);
 	logStartupInfo(nitro, serverEnabled);
 }
 /**
@@ -139,11 +138,18 @@ function setupFileWatching(nitro, serverEnabled) {
 * Scan all GraphQL files (schemas, resolvers, directives, documents)
 */
 async function scanGraphQLFiles(nitro, serverEnabled) {
-	if (serverEnabled) await scanAllGraphQLFiles(nitro);
-	else {
-		const { scanDocuments } = await import("./utils/index.mjs");
-		nitro.scanDocuments = await scanDocuments(nitro);
+	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
@@ -203,33 +209,6 @@ function setupCloseHooks(nitro, serverEnabled) {
 	});
 }
 /**
-* Register GraphQL route handlers
-*/
-function registerRouteHandlers(nitro) {
-	const runtime = fileURLToPath(new URL("routes", import.meta.url));
-	const framework = nitro.options.graphql?.framework;
-	if (framework === "graphql-yoga") for (const method of GRAPHQL_HTTP_METHODS) nitro.options.handlers.push({
-		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
-		handler: join(runtime, "graphql-yoga"),
-		method
-	});
-	if (framework === "apollo-server") for (const method of GRAPHQL_HTTP_METHODS) nitro.options.handlers.push({
-		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
-		handler: join(runtime, "apollo-server"),
-		method
-	});
-	nitro.options.handlers.push({
-		route: nitro.options.runtimeConfig.graphql?.endpoint?.healthCheck || "/api/graphql/health",
-		handler: join(runtime, "health"),
-		method: "GET"
-	});
-	if (nitro.options.dev) nitro.options.handlers.push({
-		route: ENDPOINT_DEBUG,
-		handler: join(runtime, "debug"),
-		method: "GET"
-	});
-}
-/**
 * Setup TypeScript configuration and path aliases
 */
 function setupTypeScriptConfiguration(nitro) {
@@ -247,52 +226,6 @@ function setupNuxtIntegration(nitro) {
 		if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
 	});
 }
-/**
-* Log startup information
-*/
-function logStartupInfo(nitro, serverEnabled) {
-	const externalServicesCount = nitro.options.graphql?.externalServices?.length || 0;
-	const docs = nitro.scanDocuments || [];
-	const isProd = process.env.NODE_ENV === "production";
-	if (serverEnabled) {
-		const securityConfig = resolveSecurityConfig(nitro.options.graphql?.security);
-		const framework = nitro.options.graphql?.framework || "unknown";
-		const schemas = nitro.scanSchemas?.length || 0;
-		const resolvers = nitro.scanResolvers?.length || 0;
-		consola.box({
-			title: "Nitro GraphQL",
-			message: [
-				`Framework: ${framework}`,
-				`Environment: ${isProd ? "production" : "development"}`,
-				`Schemas: ${schemas}`,
-				`Resolvers: ${resolvers}`,
-				externalServicesCount > 0 ? `External Services: ${externalServicesCount}` : "",
-				docs.length > 0 ? `Documents: ${docs.length}` : "",
-				"",
-				"Security:",
-				`├─ Introspection: ${securityConfig.introspection ? "enabled" : "disabled"}`,
-				`├─ Playground: ${securityConfig.playground ? "enabled" : "disabled"}`,
-				`├─ Error Masking: ${securityConfig.maskErrors ? "enabled" : "disabled"}`,
-				`└─ Field Suggestions: ${securityConfig.disableSuggestions ? "disabled" : "enabled"}`
-			].filter(Boolean).join("\n"),
-			style: {
-				borderColor: isProd ? "yellow" : "cyan",
-				borderStyle: "rounded"
-			}
-		});
-	} else consola.box({
-		title: "Nitro GraphQL (Client Only)",
-		message: [
-			"Server mode: disabled",
-			`External Services: ${externalServicesCount}`,
-			`Documents: ${docs.length}`
-		].join("\n"),
-		style: {
-			borderColor: "blue",
-			borderStyle: "rounded"
-		}
-	});
-}
 
 //#endregion
 export { resolveSecurityConfig, setupNitroGraphQL };

package/dist/{types/index.d.mts → nitro/types.d.mts}

@@ -1,12 +1,113 @@
-import { StandardSchemaV1 } from "./standard-schema.mjs";
 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/types/index.d.ts
+//#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']>;
@@ -73,8 +174,6 @@ interface ExternalServicePaths {
   sdk?: FileGenerationConfig;
   /** Type definitions file path (overrides global types.external config) */
   types?: FileGenerationConfig;
-  /** ofetch client wrapper path (overrides global clientUtils.ofetch config) */
-  ofetch?: FileGenerationConfig;
 }
 interface ExternalGraphQLService {
   /** Unique name for this service (used for file naming and type generation) */
@@ -129,34 +228,6 @@ interface FederationConfig {
  * - string: Generate at custom path (supports placeholders: {serviceName}, {buildDir}, {rootDir}, {framework})
  */
 type FileGenerationConfig = boolean | string;
-/**
- * Scaffold files configuration
- * Control auto-generation of scaffold/boilerplate files
- */
-interface ScaffoldConfig {
-  /** Enable/disable all scaffold files */
-  enabled?: boolean;
-  /** graphql.config.ts - GraphQL Config file for IDE tooling */
-  graphqlConfig?: FileGenerationConfig;
-  /** server/graphql/schema.ts - Schema definition file */
-  serverSchema?: FileGenerationConfig;
-  /** server/graphql/config.ts - GraphQL server configuration */
-  serverConfig?: FileGenerationConfig;
-  /** server/graphql/context.ts - H3 context augmentation */
-  serverContext?: FileGenerationConfig;
-}
-/**
- * Client utilities configuration
- * Control auto-generation of client-side utility files (Nuxt only)
- */
-interface ClientUtilsConfig {
-  /** Enable/disable all client utilities */
-  enabled?: boolean;
-  /** app/graphql/index.ts - Main exports file */
-  index?: FileGenerationConfig;
-  /** app/graphql/{serviceName}/ofetch.ts - ofetch client wrapper */
-  ofetch?: FileGenerationConfig;
-}
 /**
  * SDK files configuration
  * Control auto-generation of GraphQL SDK files
@@ -261,16 +332,6 @@ interface NitroGraphQLOptions {
   layerDirectories?: string[];
   layerServerDirs?: string[];
   layerAppDirs?: string[];
-  /**
-   * Scaffold files configuration
-   * Set to false to disable all scaffold file generation (library mode)
-   */
-  scaffold?: false | ScaffoldConfig;
-  /**
-   * Client utilities configuration
-   * Set to false to disable all client utility generation
-   */
-  clientUtils?: false | ClientUtilsConfig;
   /**
    * SDK files configuration
    * Set to false to disable all SDK generation
@@ -291,6 +352,27 @@ interface NitroGraphQLOptions {
    * 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 { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, SecurityConfig, StandardSchemaV1, TypesConfig };
+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 };

package/dist/nitro/virtual/generators.mjs

@@ -0,0 +1,193 @@
+import { getImportId } from "../../core/utils/imports.mjs";
+import { isAbsolute, resolve } from "pathe";
+import { genImport } from "knitwork";
+
+//#region src/nitro/virtual/generators.ts
+function normalizeExtendConfig(extend) {
+	if (!extend || !Array.isArray(extend) || extend.length === 0) return null;
+	const resolvers = [];
+	const schemas = [];
+	for (const source of extend) if (typeof source === "string") {
+		resolvers.push(`${source}/resolvers`);
+		schemas.push(`${source}/schema`);
+	} else if (source && typeof source === "object") {
+		const obj = source;
+		if (obj.resolvers) {
+			const r = Array.isArray(obj.resolvers) ? obj.resolvers : [obj.resolvers];
+			resolvers.push(...r);
+		}
+		if (obj.schemas) {
+			const s = Array.isArray(obj.schemas) ? obj.schemas : [obj.schemas];
+			schemas.push(...s);
+		}
+	}
+	if (resolvers.length === 0 && schemas.length === 0) return null;
+	return {
+		resolvers,
+		schemas
+	};
+}
+/**
+* Resolve extend path to absolute path
+* Supports: relative paths, absolute paths, package names
+*/
+function resolveExtendPath(nitro, inputPath) {
+	if (inputPath.startsWith("@") || !inputPath.startsWith(".") && !inputPath.startsWith("/")) return inputPath;
+	if (isAbsolute(inputPath)) return inputPath;
+	return resolve(nitro.options.rootDir, inputPath);
+}
+function generateImportModule(items, exportName, wrapperKey) {
+	if (!items.length) return `export const ${exportName} = []`;
+	const imports = items.flatMap(({ specifier, imports: list, options }) => list?.length ? [genImport(specifier, list, options)] : []);
+	const data = items.flatMap(({ imports: list }) => list.map((i) => `{ ${wrapperKey}: ${i.as || i.name} }`));
+	return `${imports.join("\n")}\n\nexport const ${exportName} = [\n${data.join(",\n")}\n]`;
+}
+function safeGenerateModuleCode(nitro, moduleName) {
+	try {
+		const generator = nitro.options.virtual?.[moduleName];
+		if (generator && typeof generator === "function") return generator();
+		return "// Module not found";
+	} catch (error) {
+		return `// Error: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+const serverSchemas = {
+	id: "#nitro-graphql/server-schemas",
+	getCode: (nitro) => {
+		const ext = normalizeExtendConfig(nitro.options.graphql?.extend);
+		const skipLocalScan = nitro.options.graphql?.skipLocalScan === true;
+		if (ext && ext.schemas.length > 0) {
+			const schemaPaths = ext.schemas.map((p) => resolveExtendPath(nitro, p));
+			const scannedSchemas = [...nitro.scanSchemas, ...nitro.options.graphql?.typedefs ?? []];
+			if (!skipLocalScan && scannedSchemas.length > 0) {
+				const extImports = schemaPaths.map((p, i) => `import { schemaString as extSchema${i} } from '${p}'`);
+				const scannedImports = scannedSchemas.map((s) => `import ${getImportId(s)} from '${s}';`);
+				const extDefs = schemaPaths.map((_, i) => `{ def: extSchema${i} }`);
+				const scannedDefs = scannedSchemas.map((s) => `{ def: ${getImportId(s)} }`);
+				return `${extImports.join("\n")}
+${scannedImports.join("\n")}
+
+export const schemas = [
+${[...extDefs, ...scannedDefs].join(",\n")}
+]`;
+			}
+			if (schemaPaths.length === 1) return `import { schemaString, typeDefs } from '${schemaPaths[0]}'
+export { schemaString, typeDefs }
+export const schemas = [{ def: schemaString }]`;
+			const imports = schemaPaths.map((p, i) => `import { schemaString as schema${i} } from '${p}'`);
+			const schemaVars = schemaPaths.map((_, i) => `schema${i}`);
+			const mergeCode = `export const schemaString = [${schemaVars.join(", ")}].join('\\n\\n')
+import { parse } from 'graphql'
+export const typeDefs = parse(schemaString)
+export const schemas = [${schemaVars.map((v) => `{ def: ${v} }`).join(", ")}]`;
+			return `${imports.join("\n")}\n\n${mergeCode}`;
+		}
+		const schemas = [...nitro.scanSchemas, ...nitro.options.graphql?.typedefs ?? []];
+		if (!schemas.length) {
+			if (nitro.options.dev) nitro.logger.warn("[nitro-graphql] No schemas found. Virtual module will export empty array.");
+			return "export const schemas = []";
+		}
+		const importStatements = schemas.map((s) => `import ${getImportId(s)} from '${s}';`);
+		const schemaArray = schemas.map((s) => `{ def: ${getImportId(s)} }`);
+		return `${importStatements.join("\n")}\n\nexport const schemas = [\n${schemaArray.join(",\n")}\n];`;
+	}
+};
+const serverResolvers = {
+	id: "#nitro-graphql/server-resolvers",
+	getCode: (nitro) => {
+		const ext = normalizeExtendConfig(nitro.options.graphql?.extend);
+		const skipLocalScan = nitro.options.graphql?.skipLocalScan === true;
+		if (ext && ext.resolvers.length > 0) {
+			const resolverPaths = ext.resolvers.map((p) => resolveExtendPath(nitro, p));
+			const imports$1 = resolverPaths.map((p, i) => `import { resolvers as resolvers${i} } from '${p}'`);
+			if (!skipLocalScan && nitro.scanResolvers.length > 0) {
+				const scannedCode = generateImportModule(nitro.scanResolvers, "scannedResolvers", "resolver");
+				const spreadAll$1 = [...resolverPaths.map((_, i) => `...resolvers${i}`), "...scannedResolvers"];
+				return `${imports$1.join("\n")}
+${scannedCode}
+
+export const resolvers = [${spreadAll$1.join(", ")}]`;
+			}
+			if (resolverPaths.length === 1) return `export { resolvers } from '${resolverPaths[0]}'`;
+			const spreadAll = resolverPaths.map((_, i) => `...resolvers${i}`);
+			return `${imports$1.join("\n")}
+
+export const resolvers = [${spreadAll.join(", ")}]`;
+		}
+		const imports = [...nitro.scanResolvers];
+		if (!imports.length) {
+			if (nitro.options.dev) nitro.logger.warn("[nitro-graphql] No resolvers found. Virtual module will export empty array.");
+			return "export const resolvers = []";
+		}
+		return generateImportModule(imports, "resolvers", "resolver");
+	}
+};
+const serverDirectives = {
+	id: "#nitro-graphql/server-directives",
+	getCode: (nitro) => {
+		const imports = nitro.scanDirectives || [];
+		if (!imports.length) return "export const directives = []";
+		return generateImportModule(imports, "directives", "directive");
+	}
+};
+const graphqlConfig = {
+	id: "#nitro-graphql/graphql-config",
+	getCode: (nitro) => {
+		return `import config from '${resolve(nitro.graphql.serverDir, "config.ts")}'
+const importedConfig = config
+export { importedConfig }
+`;
+	}
+};
+const moduleConfig = {
+	id: "#nitro-graphql/module-config",
+	getCode: (nitro) => {
+		const config = nitro.options.graphql || {};
+		return `export const moduleConfig = ${JSON.stringify(config, null, 2)};`;
+	}
+};
+const debugInfo = {
+	id: "#nitro-graphql/debug-info",
+	getCode: (nitro) => {
+		const virtualModuleCodes = {
+			"server-schemas": safeGenerateModuleCode(nitro, "#nitro-graphql/server-schemas"),
+			"server-resolvers": safeGenerateModuleCode(nitro, "#nitro-graphql/server-resolvers"),
+			"server-directives": safeGenerateModuleCode(nitro, "#nitro-graphql/server-directives"),
+			"module-config": safeGenerateModuleCode(nitro, "#nitro-graphql/module-config"),
+			"graphql-config": safeGenerateModuleCode(nitro, "#nitro-graphql/graphql-config")
+		};
+		const info = {
+			isDev: nitro.options.dev,
+			framework: nitro.options.framework.name,
+			graphqlFramework: nitro.options.graphql?.framework,
+			federation: nitro.options.graphql?.federation,
+			scanned: {
+				schemas: nitro.scanSchemas?.length || 0,
+				schemaFiles: nitro.scanSchemas || [],
+				resolvers: nitro.scanResolvers?.length || 0,
+				resolverFiles: nitro.scanResolvers || [],
+				directives: nitro.scanDirectives?.length || 0,
+				directiveFiles: nitro.scanDirectives || [],
+				documents: nitro.scanDocuments?.length || 0,
+				documentFiles: nitro.scanDocuments || []
+			},
+			virtualModules: virtualModuleCodes
+		};
+		return `export const debugInfo = ${JSON.stringify(info, null, 2)};`;
+	}
+};
+const allModules = [
+	serverSchemas,
+	serverResolvers,
+	serverDirectives,
+	graphqlConfig,
+	moduleConfig,
+	debugInfo
+];
+function registerAllVirtualModules(nitro) {
+	nitro.options.virtual ??= {};
+	for (const mod of allModules) nitro.options.virtual[mod.id] = () => mod.getCode(nitro);
+}
+
+//#endregion
+export { debugInfo, graphqlConfig, moduleConfig, registerAllVirtualModules, serverDirectives, serverResolvers, serverSchemas };

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

@@ -0,0 +1,20 @@
+//#region src/nitro/virtual/stubs.d.ts
+/**
+ * Virtual module stubs for #nitro-graphql/*
+ * Used during build to prevent import resolution errors.
+ * At runtime, Nitro overrides these with actual virtual modules.
+ */
+declare const schemas: Array<{
+  def: string;
+}>;
+declare const resolvers: Array<{
+  resolver: any;
+}>;
+declare const directives: Array<{
+  directive: any;
+}>;
+declare const moduleConfig: {};
+declare const importedConfig: {};
+declare const debugInfo: Record<string, any>;
+//#endregion
+export { debugInfo, directives, importedConfig, moduleConfig, resolvers, schemas };