nitro-graphql 2.0.0-beta.70 → 2.0.0-beta.73

package/dist/nitro/setup/security.mjs

@@ -0,0 +1,17 @@
+//#region src/nitro/setup/security.ts
+/**
+* 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
+*/
+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
+	};
+}
+//#endregion
+export { resolveSecurityConfig };

package/dist/nitro/setup/ts-config.mjs

@@ -1,7 +1,6 @@
 import { relativeWithDot } from "../../core/utils/imports.mjs";
 import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../paths.mjs";
 import { dirname, join, resolve } from "pathe";
-
 //#region src/nitro/setup/ts-config.ts
 /**
 * Setup TypeScript path aliases for GraphQL types
@@ -64,6 +63,5 @@ function setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, type
 		}
 	}
 }
-
 //#endregion
-export { setupTypeScriptPaths };
+export { setupTypeScriptPaths };

package/dist/nitro/setup/type-generation.d.mts

@@ -0,0 +1,13 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup/type-generation.d.ts
+/**
+ * Regenerate all types (server + client)
+ * Shared helper that passes schema string directly to avoid disk round-trip
+ */
+declare function regenerateTypes(nitro: Nitro, options?: {
+  serverEnabled?: boolean;
+  silent?: boolean;
+}): Promise<void>;
+//#endregion
+export { regenerateTypes };

package/dist/nitro/setup/type-generation.mjs

@@ -0,0 +1,16 @@
+import { generateClientTypes } from "../codegen/client-types.mjs";
+import { generateServerTypes } from "../codegen/server-types.mjs";
+import { isServerEnabled } from "./scanner.mjs";
+//#region src/nitro/setup/type-generation.ts
+/**
+* Regenerate all types (server + client)
+* Shared helper that passes schema string directly to avoid disk round-trip
+*/
+async function regenerateTypes(nitro, options = {}) {
+	const { serverEnabled = isServerEnabled(nitro), silent = false } = options;
+	const opts = silent ? { silent: true } : void 0;
+	if (serverEnabled) await generateClientTypes(nitro, opts, await generateServerTypes(nitro, opts));
+	else await generateClientTypes(nitro, opts);
+}
+//#endregion
+export { regenerateTypes };

package/dist/nitro/setup.d.mts

@@ -1,11 +1,12 @@
-import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { resolveSecurityConfig } from "./setup/security.mjs";
+import { regenerateTypes } from "./setup/type-generation.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
+ * Executes setup resolvers in sequence
  */
 declare function setupNitroGraphQL(nitro: Nitro): Promise<void>;
 //#endregion
-export { resolveSecurityConfig, setupNitroGraphQL };
+export { regenerateTypes, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/setup.mjs

@@ -1,58 +1,56 @@
-import { FRAMEWORK_NITRO, FRAMEWORK_NUXT, LOG_TAG } from "../core/constants.mjs";
+import { LOG_TAG } from "../core/constants.mjs";
 import { validateExternalServices } from "../core/validation/external-services.mjs";
+import { DEFAULT_RUNTIME_CONFIG, DEFAULT_TYPES_CONFIG } from "./defaults.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 { emptyScanState } from "./state.mjs";
 import { resolveExtendDirs } from "./setup/extend-loader.mjs";
 import { isServerEnabled, logResolverDiagnostics, performGraphQLScan } from "./setup/scanner.mjs";
+import { regenerateTypes } from "./setup/type-generation.mjs";
 import { getWatchDirectories, setupFileWatcher } from "./setup/file-watcher.mjs";
-import { logStartupInfo, resolveSecurityConfig } from "./setup/logging.mjs";
+import { resolveSecurityConfig } from "./setup/security.mjs";
+import { logStartupInfo } from "./setup/logging.mjs";
 import { setupNoExternals, 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);
 /**
 * Main setup function for nitro-graphql
-* Coordinates all initialization steps for the module
+* Executes setup resolvers in sequence
 */
 async function setupNitroGraphQL(nitro) {
-	const serverEnabled = isServerEnabled(nitro);
-	initializeConfiguration(nitro, serverEnabled);
-	validateConfiguration(nitro);
-	setupBuildDirectories(nitro);
-	if (serverEnabled) {
-		setupNoExternals(nitro);
-		setupRollupExternals(nitro);
-		setupRollupChunking(nitro);
-	}
-	initializeRuntimeConfig(nitro);
-	const extendDirs = await resolveExtendDirs(nitro);
-	if (nitro.options.dev) setupFileWatching(nitro, serverEnabled, extendDirs);
-	await performGraphQLScan(nitro);
-	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);
+	const resolvers = [
+		resolveConfiguration,
+		resolveValidation,
+		resolveBuildDirectories,
+		resolveRollupIntegration,
+		resolveRuntimeConfig,
+		resolveFileWatching,
+		resolveGraphQLScan,
+		resolveDevHooks,
+		resolveVirtualModules,
+		resolveTypeGeneration,
+		resolveCloseHooks,
+		resolveRouteHandlers,
+		resolveTypeScriptConfig,
+		resolveStartupLogging
+	];
+	for (const resolver of resolvers) await resolver(nitro);
 }
 /**
-* Initialize default configuration values
+* Resolve default configuration values and initialize Nitro GraphQL state
 */
-function initializeConfiguration(nitro, serverEnabled) {
+function resolveConfiguration(nitro) {
 	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\".");
+	if (isServerEnabled(nitro) && !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 ||= {
+		state: emptyScanState(),
 		buildDir: "",
 		watchDirs: [],
 		clientDir: defaultPaths.clientDir,
@@ -76,9 +74,9 @@ function initializeConfiguration(nitro, serverEnabled) {
 	};
 }
 /**
-* Validate external services configuration
+* Validate external services and federation configuration
 */
-function validateConfiguration(nitro) {
+function resolveValidation(nitro) {
 	if (nitro.options.graphql?.externalServices?.length) {
 		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
 		if (validationErrors.length > 0) {
@@ -91,27 +89,26 @@ function validateConfiguration(nitro) {
 	if (nitro.options.graphql?.federation?.enabled) logger.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
 }
 /**
-* Setup build directories
+* Resolve build directories and relative paths
 */
-function setupBuildDirectories(nitro) {
-	const graphqlBuildDir = resolve(nitro.options.rootDir, ".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;
-	}
+function resolveBuildDirectories(nitro) {
+	nitro.graphql.buildDir = resolve(nitro.options.rootDir, ".graphql");
+	nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+	nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
 }
 /**
-* Initialize runtime configuration
+* Resolve Rollup/Rolldown integration (externals, chunking, noExternals)
 */
-function initializeRuntimeConfig(nitro) {
+function resolveRollupIntegration(nitro) {
+	if (!isServerEnabled(nitro)) return;
+	setupNoExternals(nitro);
+	setupRollupExternals(nitro);
+	setupRollupChunking(nitro);
+}
+/**
+* Resolve runtime configuration with security defaults
+*/
+function resolveRuntimeConfig(nitro) {
 	const securityConfig = resolveSecurityConfig(nitro.options.graphql?.security);
 	nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
 		...DEFAULT_RUNTIME_CONFIG,
@@ -119,20 +116,28 @@ function initializeRuntimeConfig(nitro) {
 	});
 }
 /**
-* Setup file watching for development mode
+* Resolve file watching for development mode
 */
-function setupFileWatching(nitro, serverEnabled, extendDirs = []) {
+async function resolveFileWatching(nitro) {
+	if (!nitro.options.dev) return;
+	const serverEnabled = isServerEnabled(nitro);
+	const extendDirs = await resolveExtendDirs(nitro);
 	const watchDirs = serverEnabled ? getWatchDirectories(nitro, extendDirs) : [nitro.graphql.clientDir].filter(Boolean);
 	nitro.graphql.watchDirs = watchDirs;
 	const watcher = setupFileWatcher(nitro, watchDirs);
-	nitro.hooks.hook("close", () => {
-		watcher.close();
-	});
+	nitro.hooks.hook("close", () => watcher.close());
 }
 /**
-* Setup dev mode hooks for rescanning files
+* Resolve initial GraphQL file scanning
 */
-function setupDevHooks(nitro) {
+async function resolveGraphQLScan(nitro) {
+	await performGraphQLScan(nitro);
+}
+/**
+* Resolve dev mode hooks for rescanning and diagnostics
+*/
+function resolveDevHooks(nitro) {
+	if (!isServerEnabled(nitro)) return;
 	let hasShownInitialLogs = false;
 	let lastDevStart = 0;
 	const DEBOUNCE_MS = 500;
@@ -151,41 +156,47 @@ function setupDevHooks(nitro) {
 	});
 }
 /**
-* Generate server and client types
+* Resolve virtual modules registration via Rollup config
 */
-async function generateTypes(nitro, serverEnabled) {
-	if (serverEnabled) {
-		await generateServerTypes(nitro);
-		await generateClientTypes(nitro, { isInitial: true });
-	} else await generateClientTypes(nitro, { isInitial: true });
+async function resolveVirtualModules(nitro) {
+	if (!isServerEnabled(nitro)) return;
+	await rollupConfig(nitro);
 }
 /**
-* Setup close hooks for final type generation
+* Resolve initial type generation
 */
-function setupCloseHooks(nitro, serverEnabled) {
+async function resolveTypeGeneration(nitro) {
+	await regenerateTypes(nitro, { serverEnabled: isServerEnabled(nitro) });
+}
+/**
+* Resolve close hooks for final type generation
+*/
+function resolveCloseHooks(nitro) {
 	nitro.hooks.hook("close", async () => {
-		if (serverEnabled) await generateServerTypes(nitro, { silent: true });
-		await generateClientTypes(nitro, { silent: true });
+		await regenerateTypes(nitro, { silent: true });
 	});
 }
 /**
-* Setup TypeScript configuration and path aliases
+* Resolve route handler registration
 */
-function setupTypeScriptConfiguration(nitro) {
-	nitro.options.typescript.strict = DEFAULT_TYPESCRIPT_STRICT;
+function resolveRouteHandlers(nitro) {
+	if (!isServerEnabled(nitro)) return;
+	registerRouteHandlers(nitro);
+}
+/**
+* Resolve TypeScript configuration and path aliases
+*/
+function resolveTypeScriptConfig(nitro) {
+	nitro.options.typescript.strict = true;
 	nitro.hooks.hook("types:extend", (types) => {
 		setupTypeScriptPaths(nitro, types);
 	});
 }
 /**
-* Setup Nuxt-specific integration
+* Resolve startup logging
 */
-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 || [];
-	});
+function resolveStartupLogging(nitro) {
+	logStartupInfo(nitro, isServerEnabled(nitro));
 }
-
 //#endregion
-export { resolveSecurityConfig, setupNitroGraphQL };
+export { regenerateTypes, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/state.d.mts

@@ -0,0 +1,32 @@
+import { ScannedResolver } from "../core/types/scanning.mjs";
+import { GraphQLScanState } from "./types/augmentation.mjs";
+
+//#region src/nitro/state.d.ts
+/**
+ * Create an empty scan state
+ */
+declare function emptyScanState(): GraphQLScanState;
+/**
+ * Create a scan state from local scan results
+ */
+declare function createScanState(result: {
+  schemas: string[];
+  resolvers: ScannedResolver[];
+  directives: ScannedResolver[];
+  documents: string[];
+  directiveSchemas: string | null;
+}): GraphQLScanState;
+/**
+ * Merge extend results into an existing state, producing a new frozen snapshot.
+ * Deduplicates by path/specifier to prevent double-counting.
+ */
+declare function mergeScanState(base: GraphQLScanState, extend: {
+  schemas?: string[];
+  resolvers?: ScannedResolver[];
+  directives?: ScannedResolver[];
+  documents?: string[];
+  configPath?: string;
+  schemaPath?: string;
+}): GraphQLScanState;
+//#endregion
+export { createScanState, emptyScanState, mergeScanState };

package/dist/nitro/state.mjs

@@ -0,0 +1,58 @@
+//#region src/nitro/state.ts
+/**
+* Create an empty scan state
+*/
+function emptyScanState() {
+	return Object.freeze({
+		schemas: [],
+		resolvers: [],
+		directives: [],
+		documents: [],
+		directiveSchemas: null,
+		extendConfigs: [],
+		extendSchemas: []
+	});
+}
+/**
+* Create a scan state from local scan results
+*/
+function createScanState(result) {
+	return Object.freeze({
+		schemas: [...result.schemas],
+		resolvers: [...result.resolvers],
+		directives: [...result.directives],
+		documents: [...result.documents],
+		directiveSchemas: result.directiveSchemas,
+		extendConfigs: [],
+		extendSchemas: []
+	});
+}
+/**
+* Merge extend results into an existing state, producing a new frozen snapshot.
+* Deduplicates by path/specifier to prevent double-counting.
+*/
+function mergeScanState(base, extend) {
+	const schemas = [...base.schemas];
+	const resolvers = [...base.resolvers];
+	const directives = [...base.directives];
+	const documents = [...base.documents];
+	const extendConfigs = [...base.extendConfigs];
+	const extendSchemas = [...base.extendSchemas];
+	for (const s of extend.schemas || []) if (!schemas.includes(s)) schemas.push(s);
+	for (const r of extend.resolvers || []) if (!resolvers.some((existing) => existing.specifier === r.specifier)) resolvers.push(r);
+	for (const d of extend.directives || []) if (!directives.some((existing) => existing.specifier === d.specifier)) directives.push(d);
+	for (const doc of extend.documents || []) if (!documents.includes(doc)) documents.push(doc);
+	if (extend.configPath && !extendConfigs.includes(extend.configPath)) extendConfigs.push(extend.configPath);
+	if (extend.schemaPath && !extendSchemas.includes(extend.schemaPath)) extendSchemas.push(extend.schemaPath);
+	return Object.freeze({
+		schemas,
+		resolvers,
+		directives,
+		documents,
+		directiveSchemas: base.directiveSchemas,
+		extendConfigs,
+		extendSchemas
+	});
+}
+//#endregion
+export { createScanState, emptyScanState, mergeScanState };

package/dist/nitro/types/augmentation.d.mts

@@ -0,0 +1,59 @@
+import { ScannedResolver } from "../../core/types/scanning.mjs";
+import { NitroGraphQLOptions } from "./config.mjs";
+
+//#region src/nitro/types/augmentation.d.ts
+/**
+ * Immutable scan state snapshot
+ * Built atomically from local scan + extend results.
+ * All consumers (virtual modules, codegen, logging) read from this single snapshot.
+ * Never mutate — replace the entire object for updates.
+ */
+interface GraphQLScanState {
+  readonly schemas: readonly string[];
+  readonly resolvers: readonly ScannedResolver[];
+  readonly directives: readonly ScannedResolver[];
+  readonly documents: readonly string[];
+  readonly directiveSchemas: string | null;
+  readonly extendConfigs: readonly string[];
+  readonly extendSchemas: readonly string[];
+}
+declare module 'nitro/types' {
+  interface Nitro {
+    /** @deprecated Use nitro.graphql.state.schemas — kept for backward compatibility */
+    scanSchemas: string[];
+    /** @deprecated Use nitro.graphql.state.documents */
+    scanDocuments: string[];
+    /** @deprecated Use nitro.graphql.state.resolvers */
+    scanResolvers: ScannedResolver[];
+    /** @deprecated Use nitro.graphql.state.directives */
+    scanDirectives: ScannedResolver[];
+    graphql: {
+      /** Immutable scan state — the single source of truth for all scanned files */state: GraphQLScanState; /** Absolute path to GraphQL build directory (e.g. /project/.graphql) */
+      buildDir: string; /** Directories watched for file changes in dev mode */
+      watchDirs: string[]; /** Absolute path to client GraphQL directory (e.g. /project/graphql) */
+      clientDir: string; /** Absolute path to server GraphQL directory (e.g. /project/server/graphql) */
+      serverDir: string; /** Relative paths (from rootDir) — used for display and config resolution */
+      dir: {
+        build: string;
+        client: string;
+        server: string;
+      }; /** @deprecated Use nitro.graphql.state.directiveSchemas */
+      directiveSchemas: string | null; /** @deprecated Use nitro.graphql.state.extendConfigs */
+      extendConfigs: string[]; /** @deprecated Use nitro.graphql.state.extendSchemas */
+      extendSchemas: string[];
+    };
+  }
+}
+declare module 'nitro/types' {
+  interface NitroOptions {
+    graphql?: NitroGraphQLOptions;
+  }
+  interface NitroRuntimeConfig {
+    graphql?: NitroGraphQLOptions;
+  }
+  interface NitroConfig {
+    graphql?: NitroGraphQLOptions;
+  }
+}
+//#endregion
+export { GraphQLScanState };

package/dist/nitro/types/augmentation.mjs

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