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

package/dist/nitro/setup/scanner.d.mts

@@ -1,59 +1,24 @@
-import { ExtendSource } from "../types.mjs";
+import { ExtendSource } from "../types/config.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro/setup/scanner.d.ts
 interface ScanOptions {
-  /** Silent mode - suppress logging */
   silent?: boolean;
-  /** Is this a rescan (dev mode hot reload) */
   isRescan?: boolean;
 }
-interface ScanResult {
-  schemas: number;
-  resolvers: number;
-  directives: number;
-  documents: number;
-}
-/**
- * Check if local file scanning should be performed
- * Centralized helper to avoid scattered skipLocalScan checks
- */
 declare function shouldScanLocalFiles(nitro: Nitro): boolean;
-/**
- * Check if server-side GraphQL is enabled
- */
 declare function isServerEnabled(nitro: Nitro): boolean;
-/**
- * Get extend sources from config
- */
 declare function getExtendSources(nitro: Nitro): ExtendSource[] | undefined;
 /**
- * Scan local GraphQL files (schemas, resolvers, directives, documents)
- * This is the low-level scan function - use performGraphQLScan for full workflow
- */
-declare function scanLocalFiles(nitro: Nitro): Promise<ScanResult>;
-/**
- * Scan only client documents (for external services or client-only mode)
- */
-declare function scanDocumentsOnly(nitro: Nitro): Promise<number>;
-/**
- * Initialize empty scan results (for skipLocalScan mode)
- */
-declare function initializeEmptyScanResults(nitro: Nitro): void;
-/**
- * Perform complete GraphQL scan workflow
- * This is the main entry point for both initial setup and dev mode rescan
+ * Perform complete GraphQL scan workflow.
+ * Builds an immutable state snapshot and assigns it to nitro.graphql.state atomically.
  *
- * Workflow:
- * 1. Check skipLocalScan flag
- * 2. Scan local files if enabled
- * 3. Resolve extend config (append to results)
- * 4. Log diagnostics if needed
+ * Flow:
+ * 1. Scan local files (or skip if skipLocalScan)
+ * 2. Merge extend sources into state
+ * 3. Assign frozen state to nitro.graphql.state (single atomic write)
  */
 declare function performGraphQLScan(nitro: Nitro, options?: ScanOptions): Promise<void>;
-/**
- * Log resolver diagnostics for development
- */
 declare function logResolverDiagnostics(nitro: Nitro): void;
 //#endregion
-export { ScanOptions, ScanResult, getExtendSources, initializeEmptyScanResults, isServerEnabled, logResolverDiagnostics, performGraphQLScan, scanDocumentsOnly, scanLocalFiles, shouldScanLocalFiles };
+export { ScanOptions, getExtendSources, isServerEnabled, logResolverDiagnostics, performGraphQLScan, shouldScanLocalFiles };

package/dist/nitro/setup/scanner.mjs

@@ -1,98 +1,96 @@
 import { LOG_TAG } from "../../core/constants.mjs";
+import { scanDirectivesCore } from "../../core/scanning/directives.mjs";
+import { scanDocumentsCore } from "../../core/scanning/documents.mjs";
+import { scanResolversCore } from "../../core/scanning/resolvers.mjs";
+import { scanSchemasCore } from "../../core/scanning/schemas.mjs";
 import { generateDirectiveSchemas } from "../../core/utils/directive-parser.mjs";
-import { NitroAdapter } from "../adapter.mjs";
+import { createScanContextFromNitro } from "../adapter.mjs";
+import { createScanState } from "../state.mjs";
 import { resolveExtendConfig } from "./extend-loader.mjs";
 import consola from "consola";
+import { relative } from "pathe";
 //#region src/nitro/setup/scanner.ts
 const logger = consola.withTag(LOG_TAG);
-/**
-* Check if local file scanning should be performed
-* Centralized helper to avoid scattered skipLocalScan checks
-*/
 function shouldScanLocalFiles(nitro) {
 	return nitro.options.graphql?.skipLocalScan !== true;
 }
-/**
-* Check if server-side GraphQL is enabled
-*/
 function isServerEnabled(nitro) {
 	return nitro.options.graphql?.server !== false;
 }
-/**
-* Get extend sources from config
-*/
 function getExtendSources(nitro) {
 	const extend = nitro.options.graphql?.extend;
 	return Array.isArray(extend) ? extend : void 0;
 }
 /**
-* Scan local GraphQL files (schemas, resolvers, directives, documents)
-* This is the low-level scan function - use performGraphQLScan for full workflow
+* Scan local GraphQL files and return an immutable state snapshot.
+* Does NOT mutate nitro — caller is responsible for assigning the state.
 */
 async function scanLocalFiles(nitro) {
-	const directivesResult = await NitroAdapter.scanDirectives(nitro);
-	nitro.scanDirectives = directivesResult.items;
+	const ctx = createScanContextFromNitro(nitro);
+	const directivesResult = await scanDirectivesCore(ctx);
 	const directiveSchemas = await generateDirectiveSchemas(directivesResult.items, nitro.graphql.buildDir);
-	nitro.graphql.directiveSchemas = directiveSchemas;
-	const schemasResult = await NitroAdapter.scanSchemas(nitro);
-	nitro.scanSchemas = schemasResult.items;
-	const docsResult = await NitroAdapter.scanDocuments(nitro);
-	nitro.scanDocuments = docsResult.items;
-	const resolversResult = await NitroAdapter.scanResolvers(nitro);
-	nitro.scanResolvers = resolversResult.items;
-	return {
-		schemas: schemasResult.items.length,
-		resolvers: resolversResult.items.length,
-		directives: directivesResult.items.length,
-		documents: docsResult.items.length
-	};
+	const schemasResult = await scanSchemasCore(ctx);
+	const [docsResult, resolversResult] = await Promise.all([scanDocumentsCore(ctx, {
+		externalServices: nitro.options.graphql?.externalServices,
+		clientDirRelative: relative(nitro.options.rootDir, nitro.graphql.clientDir)
+	}), scanResolversCore(ctx)]);
+	return createScanState({
+		schemas: schemasResult.items,
+		resolvers: resolversResult.items,
+		directives: directivesResult.items,
+		documents: docsResult.items,
+		directiveSchemas
+	});
 }
 /**
-* Scan only client documents (for external services or client-only mode)
+* Scan only client documents, preserving existing state for other fields
 */
 async function scanDocumentsOnly(nitro) {
-	const result = await NitroAdapter.scanDocuments(nitro);
-	nitro.scanDocuments = result.items;
-	return result.items.length;
+	return createScanState({
+		schemas: [],
+		resolvers: [],
+		directives: [],
+		documents: (await scanDocumentsCore(createScanContextFromNitro(nitro), {
+			externalServices: nitro.options.graphql?.externalServices,
+			clientDirRelative: relative(nitro.options.rootDir, nitro.graphql.clientDir)
+		})).items,
+		directiveSchemas: null
+	});
 }
 /**
-* Initialize empty scan results (for skipLocalScan mode)
-*/
-function initializeEmptyScanResults(nitro) {
-	nitro.scanSchemas = [];
-	nitro.scanResolvers = [];
-	nitro.scanDirectives = [];
-}
-/**
-* Perform complete GraphQL scan workflow
-* This is the main entry point for both initial setup and dev mode rescan
+* Perform complete GraphQL scan workflow.
+* Builds an immutable state snapshot and assigns it to nitro.graphql.state atomically.
 *
-* Workflow:
-* 1. Check skipLocalScan flag
-* 2. Scan local files if enabled
-* 3. Resolve extend config (append to results)
-* 4. Log diagnostics if needed
+* Flow:
+* 1. Scan local files (or skip if skipLocalScan)
+* 2. Merge extend sources into state
+* 3. Assign frozen state to nitro.graphql.state (single atomic write)
 */
 async function performGraphQLScan(nitro, options = {}) {
 	const { silent = false, isRescan = false } = options;
 	const serverEnabled = isServerEnabled(nitro);
 	const scanLocal = shouldScanLocalFiles(nitro);
 	const extendSources = getExtendSources(nitro);
-	if (isRescan && !scanLocal && extendSources?.length) return;
+	if (isRescan && extendSources?.length) return;
+	let state;
 	if (!scanLocal) {
 		if (!isRescan && !silent) if (extendSources?.length) logger.info(`Using ${extendSources.length} extend source(s), skipping local scanning`);
 		else logger.info("Skipping local scanning (skipLocalScan: true)");
-		initializeEmptyScanResults(nitro);
-		await scanDocumentsOnly(nitro);
-	} else if (serverEnabled) await scanLocalFiles(nitro);
-	else await scanDocumentsOnly(nitro);
-	await resolveExtendConfig(nitro, { silent: silent || isRescan });
+		state = await scanDocumentsOnly(nitro);
+	} else if (serverEnabled) state = await scanLocalFiles(nitro);
+	else state = await scanDocumentsOnly(nitro);
+	state = await resolveExtendConfig(nitro, state, { silent: silent || isRescan });
+	nitro.graphql.state = state;
+	nitro.scanSchemas = [...state.schemas];
+	nitro.scanResolvers = [...state.resolvers];
+	nitro.scanDirectives = [...state.directives];
+	nitro.scanDocuments = [...state.documents];
+	nitro.graphql.directiveSchemas = state.directiveSchemas;
+	nitro.graphql.extendConfigs = [...state.extendConfigs];
+	nitro.graphql.extendSchemas = [...state.extendSchemas];
 }
-/**
-* Log resolver diagnostics for development
-*/
 function logResolverDiagnostics(nitro) {
-	const resolvers = nitro.scanResolvers || [];
+	const resolvers = nitro.graphql.state.resolvers;
 	if (resolvers.length > 0) {
 		const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
 		const typeCount = {
@@ -115,4 +113,4 @@ function logResolverDiagnostics(nitro) {
 	} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
 }
 //#endregion
-export { getExtendSources, initializeEmptyScanResults, isServerEnabled, logResolverDiagnostics, performGraphQLScan, scanDocumentsOnly, scanLocalFiles, shouldScanLocalFiles };
+export { getExtendSources, isServerEnabled, logResolverDiagnostics, performGraphQLScan, shouldScanLocalFiles };

package/dist/nitro/setup/security.d.mts

@@ -0,0 +1,10 @@
+import { CoreSecurityConfig } from "../../core/types/config.mjs";
+//#region src/nitro/setup/security.d.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
+ */
+declare function resolveSecurityConfig(config?: CoreSecurityConfig): Required<CoreSecurityConfig>;
+//#endregion
+export { resolveSecurityConfig };

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/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,13 +1,15 @@
-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_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";
@@ -18,40 +20,37 @@ import { relative, resolve } from "pathe";
 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,
@@ -75,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) {
@@ -90,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,
@@ -118,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;
@@ -150,40 +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) {
+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 === "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 };