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

package/dist/core/index.mjs

@@ -0,0 +1,28 @@
+import { BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, CODEGEN_EXTERNALS, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_GRAPHQL_SCALARS, DEFAULT_SERVER_TYPES_PATH, DEFINE_DIRECTIVE, DEFINE_FIELD, DEFINE_FUNCTIONS, DEFINE_GRAPHQL_CONFIG, DEFINE_MUTATION, DEFINE_QUERY, DEFINE_RESOLVER, DEFINE_SCHEMA, DEFINE_SUBSCRIPTION, DIRECTIVE_EXTENSIONS, DIRECTIVE_GLOB_PATTERN, DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_BUILD_NUXT, DIR_CLIENT_GRAPHQL, DIR_EXTERNAL, DIR_ROUTES_GRAPHQL, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, FEDERATION_EXTERNALS, FILE_CLIENT_TYPES, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_DIRECTIVES_GRAPHQL, FILE_GRAPHQL_CONFIG, FILE_GRAPHQL_DTS, FILE_INDEX_TS, FILE_OFETCH_TS, FILE_SCHEMA_GRAPHQL, FILE_SCHEMA_TS, FILE_SDK_TS, FILE_SERVER_TYPES, FRAMEWORK_NITRO, FRAMEWORK_NUXT, FRAMEWORK_STANDALONE, GLOB_SCAN_PATTERN, GRAPHQL_EXTENSIONS, GRAPHQL_FRAMEWORK_APOLLO, GRAPHQL_FRAMEWORK_YOGA, GRAPHQL_GLOB_PATTERN, GRAPHQL_HTTP_METHODS, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_INTERNAL_ERROR, LOG_TAG, PATTERN_CLIENT_EXTERNAL_TYPES, PLACEHOLDER_BUILD_DIR, PLACEHOLDER_CLIENT_DIR, PLACEHOLDER_FRAMEWORK, PLACEHOLDER_ROOT_DIR, PLACEHOLDER_SERVER_DIR, PLACEHOLDER_SERVICE_NAME, PLACEHOLDER_TYPES_DIR, RESOLVER_EXTENSIONS, RESOLVER_GLOB_PATTERN, RESOLVER_TYPE_DIRECTIVE, RESOLVER_TYPE_MUTATION, RESOLVER_TYPE_QUERY, RESOLVER_TYPE_RESOLVER, RESOLVER_TYPE_SUBSCRIPTION, RESOLVER_TYPE_TYPE, SERVICE_DEFAULT } from "./constants.mjs";
+import { GENERATED_FILE_HEADER, pluginContent } from "./codegen/plugin.mjs";
+import { loadGraphQLDocuments } from "./codegen/document-loader.mjs";
+import { ensureDir, readFileSafe, writeFile, writeFileIfChanged } from "./utils/file-io.mjs";
+import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./codegen/schema-loader.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder } from "./codegen/client.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./codegen/runtime.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./codegen/server.mjs";
+import { validateNoDuplicateTypes, validateSchemaFiles } from "./codegen/validation.mjs";
+import { createLogger, createSilentLogger, defaultLogger } from "./utils/logger.mjs";
+import { createCoreConfig, createCoreContext, createScanContext, mergeGraphQLOptions } from "./config.mjs";
+import { isLocalPath, loadPackageConfig, resolvePackageFiles } from "./manifest.mjs";
+import { deduplicateFiles, extractPaths, filterByExtension, scanDirectory } from "./scanning/common.mjs";
+import { parseSingleFile, scanWithAST } from "./scanning/ast-scanner.mjs";
+import { parseDirectiveCall, scanDirectivesCore } from "./scanning/directives.mjs";
+import { scanDocumentsCore } from "./scanning/documents.mjs";
+import { parseResolverCall, scanResolversCore } from "./scanning/resolvers.mjs";
+import { scanGraphqlCore, scanSchemasCore } from "./scanning/schemas.mjs";
+import { loadFederationSupport, resetFederationCache, warnFederationUnavailable } from "./schema/federation.mjs";
+import { BASE_SCHEMA, buildGraphQLSchema, createMergedSchema, parse, subscribe, validate } from "./schema/builder.mjs";
+import { APOLLO_SANDBOX_CDN, createSandboxResponse, fetchSandboxScript } from "./server/sandbox.mjs";
+import { BASE_SCHEMA as BASE_SCHEMA$1, apolloSandboxHtml, createYogaServer } from "./server/yoga.mjs";
+import { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./utils/directive-parser.mjs";
+import { createDefaultMaskError } from "./utils/errors.mjs";
+import { getImportId, relativeWithDot } from "./utils/imports.mjs";
+import { generateOfetchTemplate } from "./utils/ofetch-templates.mjs";
+import { validateExternalServices } from "./validation/external-services.mjs";
+export { APOLLO_SANDBOX_CDN, BASE_SCHEMA, BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, CODEGEN_EXTERNALS, DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_GRAPHQL_SCALARS, DEFAULT_SERVER_CODEGEN_CONFIG, DEFAULT_SERVER_TYPES_PATH, DEFINE_DIRECTIVE, DEFINE_FIELD, DEFINE_FUNCTIONS, DEFINE_GRAPHQL_CONFIG, DEFINE_MUTATION, DEFINE_QUERY, DEFINE_RESOLVER, DEFINE_SCHEMA, DEFINE_SUBSCRIPTION, DIRECTIVE_EXTENSIONS, DIRECTIVE_GLOB_PATTERN, DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_BUILD_NUXT, DIR_CLIENT_GRAPHQL, DIR_EXTERNAL, DIR_ROUTES_GRAPHQL, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, DirectiveParser, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, FEDERATION_EXTERNALS, FILE_CLIENT_TYPES, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_DIRECTIVES_GRAPHQL, FILE_GRAPHQL_CONFIG, FILE_GRAPHQL_DTS, FILE_INDEX_TS, FILE_OFETCH_TS, FILE_SCHEMA_GRAPHQL, FILE_SCHEMA_TS, FILE_SDK_TS, FILE_SERVER_TYPES, FRAMEWORK_NITRO, FRAMEWORK_NUXT, FRAMEWORK_STANDALONE, GENERATED_FILE_HEADER, GLOB_SCAN_PATTERN, GRAPHQL_EXTENSIONS, GRAPHQL_FRAMEWORK_APOLLO, GRAPHQL_FRAMEWORK_YOGA, GRAPHQL_GLOB_PATTERN, GRAPHQL_HTTP_METHODS, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_INTERNAL_ERROR, LOG_TAG, PATTERN_CLIENT_EXTERNAL_TYPES, PLACEHOLDER_BUILD_DIR, PLACEHOLDER_CLIENT_DIR, PLACEHOLDER_FRAMEWORK, PLACEHOLDER_ROOT_DIR, PLACEHOLDER_SERVER_DIR, PLACEHOLDER_SERVICE_NAME, PLACEHOLDER_TYPES_DIR, RESOLVER_EXTENSIONS, RESOLVER_GLOB_PATTERN, RESOLVER_TYPE_DIRECTIVE, RESOLVER_TYPE_MUTATION, RESOLVER_TYPE_QUERY, RESOLVER_TYPE_RESOLVER, RESOLVER_TYPE_SUBSCRIPTION, RESOLVER_TYPE_TYPE, SERVICE_DEFAULT, BASE_SCHEMA$1 as YOGA_BASE_SCHEMA, apolloSandboxHtml, buildGraphQLSchema, createCoreConfig, createCoreContext, createDefaultMaskError, createLogger, createMergedSchema, createSandboxResponse, createScanContext, createSilentLogger, createYogaServer, deduplicateFiles, defaultLogger, directiveParser, downloadAndSaveSchema, ensureDir, extractPaths, extractSubscriptions, fetchSandboxScript, filterByExtension, generateClientTypesCore, generateDirectiveSchema, generateDirectiveSchemas, generateExternalClientTypesCore, generateOfetchTemplate, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, generateTypes, getImportId, graphQLLoadSchemaSync, isLocalPath, loadExternalSchema, loadFederationSupport, loadGraphQLDocuments, loadPackageConfig, mergeGraphQLOptions, parse, parseDirectiveCall, parseResolverCall, parseSingleFile, pluginContent, readFileSafe, relativeWithDot, resetFederationCache, resolvePackageFiles, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST, subscribe, validate, validateExternalServices, validateNoDuplicateTypes, validateSchemaFiles, warnFederationUnavailable, writeFile, writeFileIfChanged };

package/dist/core/manifest.d.mts

@@ -0,0 +1,56 @@
+//#region src/core/manifest.d.ts
+/**
+ * Package Config Loader
+ * Loads package configuration for extend functionality
+ */
+/**
+ * Package config structure (subset of CLIConfig)
+ */
+interface PackageConfig {
+  serverDir?: string;
+  clientDir?: string;
+}
+/**
+ * Resolved package with config and base directory
+ */
+interface ResolvedPackage {
+  config: PackageConfig;
+  baseDir: string;
+}
+/**
+ * Resolved extend paths
+ */
+interface ResolvedExtend {
+  schemas: string[];
+  resolvers: string[];
+  directives: string[];
+  documents: string[];
+  serverDir: string;
+  clientDir?: string;
+  /** Path to config.ts if it exists */
+  configPath?: string;
+  /** Path to schema.ts if it exists */
+  schemaPath?: string;
+}
+/**
+ * Check if source is a local path (relative or absolute)
+ */
+declare function isLocalPath(source: string): boolean;
+/**
+ * Load config from package or local directory
+ * Uses c12 for proper config loading with TypeScript support
+ *
+ * @param source - Package name or local path (./path, ../path, /absolute/path)
+ * @param rootDir - Root directory for resolution
+ * @returns Resolved package with config and base directory, or null if not found
+ */
+declare function loadPackageConfig(source: string, rootDir: string): Promise<ResolvedPackage | null>;
+/**
+ * Scan package's serverDir and resolve all GraphQL files
+ *
+ * @param pkg - Resolved package with config
+ * @returns Resolved file paths
+ */
+declare function resolvePackageFiles(pkg: ResolvedPackage): Promise<ResolvedExtend>;
+//#endregion
+export { PackageConfig, ResolvedExtend, ResolvedPackage, isLocalPath, loadPackageConfig, resolvePackageFiles };

package/dist/core/manifest.mjs

@@ -0,0 +1,100 @@
+import { DIRECTIVE_EXTENSIONS, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "./constants.mjs";
+import { dirname, isAbsolute, resolve } from "pathe";
+import { existsSync } from "node:fs";
+import { loadConfig } from "c12";
+import { resolvePath } from "mlly";
+import { glob } from "tinyglobby";
+//#region src/core/manifest.ts
+/**
+* Package Config Loader
+* Loads package configuration for extend functionality
+*/
+/**
+* Check if source is a local path (relative or absolute)
+*/
+function isLocalPath(source) {
+	return source.startsWith(".") || isAbsolute(source);
+}
+/**
+* Load config from package or local directory
+* Uses c12 for proper config loading with TypeScript support
+*
+* @param source - Package name or local path (./path, ../path, /absolute/path)
+* @param rootDir - Root directory for resolution
+* @returns Resolved package with config and base directory, or null if not found
+*/
+async function loadPackageConfig(source, rootDir) {
+	try {
+		let pkgDir;
+		if (isLocalPath(source)) {
+			pkgDir = resolve(rootDir, source);
+			if (!existsSync(pkgDir)) return null;
+		} else pkgDir = dirname(await resolvePath(`${source}/package.json`, {
+			url: rootDir,
+			extensions: [".json"]
+		}));
+		const { config } = await loadConfig({
+			name: "nitro-graphql",
+			cwd: pkgDir,
+			defaultConfig: { serverDir: "server/graphql" }
+		});
+		const resolvedConfig = {
+			serverDir: config?.serverDir || "server/graphql",
+			clientDir: config?.clientDir
+		};
+		if (!existsSync(resolve(pkgDir, resolvedConfig.serverDir))) return null;
+		return {
+			config: resolvedConfig,
+			baseDir: pkgDir
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Scan package's serverDir and resolve all GraphQL files
+*
+* @param pkg - Resolved package with config
+* @returns Resolved file paths
+*/
+async function resolvePackageFiles(pkg) {
+	const serverDir = resolve(pkg.baseDir, pkg.config.serverDir || "server/graphql");
+	const clientDir = pkg.config.clientDir ? resolve(pkg.baseDir, pkg.config.clientDir) : void 0;
+	const schemaPattern = `**/*{${GRAPHQL_EXTENSIONS.join(",")}}`;
+	const resolverPattern = `**/*{${RESOLVER_EXTENSIONS.join(",")}}`;
+	const directivePattern = `**/*{${DIRECTIVE_EXTENSIONS.join(",")}}`;
+	const scanPromises = [
+		glob(schemaPattern, {
+			cwd: serverDir,
+			absolute: true
+		}),
+		glob(resolverPattern, {
+			cwd: serverDir,
+			absolute: true
+		}),
+		glob(directivePattern, {
+			cwd: serverDir,
+			absolute: true
+		})
+	];
+	if (clientDir && existsSync(clientDir)) scanPromises.push(glob(schemaPattern, {
+		cwd: clientDir,
+		absolute: true
+	}));
+	else scanPromises.push(Promise.resolve([]));
+	const [schemas = [], resolvers = [], directives = [], documents = []] = await Promise.all(scanPromises);
+	const configPath = resolve(serverDir, "config.ts");
+	const schemaPath = resolve(serverDir, "schema.ts");
+	return {
+		schemas: schemas.sort((a, b) => a.localeCompare(b)),
+		resolvers: resolvers.sort((a, b) => a.localeCompare(b)),
+		directives: directives.sort((a, b) => a.localeCompare(b)),
+		documents: documents.sort((a, b) => a.localeCompare(b)),
+		serverDir,
+		clientDir,
+		configPath: existsSync(configPath) ? configPath : void 0,
+		schemaPath: existsSync(schemaPath) ? schemaPath : void 0
+	};
+}
+//#endregion
+export { isLocalPath, loadPackageConfig, resolvePackageFiles };

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

@@ -0,0 +1,109 @@
+//#region src/core/pubsub/index.d.ts
+/**
+ * Built-in PubSub implementation for GraphQL Subscriptions
+ * Simple EventEmitter-based implementation for single-instance deployments
+ *
+ * For multi-instance deployments, use external PubSub solutions like:
+ * - Redis (with ioredis)
+ * - Kafka
+ * - RabbitMQ
+ * - Cloud Pub/Sub services
+ */
+/**
+ * Generic PubSub engine interface
+ * Compatible with various PubSub implementations
+ */
+interface PubSubEngine<Topics extends Record<string, unknown> = Record<string, unknown>> {
+  /**
+   * Publish an event to a topic
+   * @param topic - Topic name to publish to
+   * @param payload - Event payload
+   */
+  publish: <K extends keyof Topics>(topic: K, payload: Topics[K]) => Promise<void>;
+  /**
+   * Subscribe to a topic
+   * @param topic - Topic name to subscribe to
+   * @returns AsyncIterable that yields events
+   */
+  subscribe: <K extends keyof Topics>(topic: K) => AsyncIterable<Topics[K]>;
+}
+/**
+ * Type alias for typed PubSub instances
+ */
+type TypedPubSub<Topics extends Record<string, unknown>> = PubSubEngine<Topics>;
+/**
+ * Create a simple in-memory PubSub instance
+ *
+ * This implementation uses EventEmitter for lightweight pub/sub functionality.
+ * Suitable for:
+ * - Development environments
+ * - Single-instance production deployments
+ * - Testing
+ *
+ * NOT suitable for:
+ * - Multi-instance/clustered deployments (events won't propagate across instances)
+ * - High-throughput scenarios (consider Redis-based PubSub)
+ *
+ * @example
+ * ```typescript
+ * // Define your topic types
+ * interface MyTopics {
+ *   'user:created': { id: string; name: string }
+ *   'message:sent': { channelId: string; content: string }
+ * }
+ *
+ * // Create typed PubSub instance
+ * const pubsub = createPubSub<MyTopics>()
+ *
+ * // Publish events
+ * await pubsub.publish('user:created', { id: '123', name: 'John' })
+ *
+ * // Subscribe to events (in a resolver)
+ * export const userSubscriptions = defineSubscription({
+ *   userCreated: {
+ *     subscribe: async function* () {
+ *       yield* pubsub.subscribe('user:created')
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function createPubSub<Topics extends Record<string, unknown> = Record<string, unknown>>(): PubSubEngine<Topics>;
+/**
+ * Filter subscription events based on a predicate
+ *
+ * @example
+ * ```typescript
+ * export const chatSubscriptions = defineSubscription({
+ *   messageAdded: {
+ *     subscribe: async function* (_, { channelId }) {
+ *       yield* withFilter(
+ *         pubsub.subscribe('message:added'),
+ *         (message) => message.channelId === channelId
+ *       )
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function withFilter<T>(asyncIterable: AsyncIterable<T>, filter: (value: T) => boolean | Promise<boolean>): AsyncIterable<T>;
+/**
+ * Map subscription events to a different shape
+ *
+ * @example
+ * ```typescript
+ * export const chatSubscriptions = defineSubscription({
+ *   messageAdded: {
+ *     subscribe: async function* () {
+ *       yield* mapAsyncIterator(
+ *         pubsub.subscribe('message:added'),
+ *         (event) => ({ messageAdded: event.message })
+ *       )
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function mapAsyncIterator<T, U>(asyncIterable: AsyncIterable<T>, mapper: (value: T) => U | Promise<U>): AsyncIterable<U>;
+//#endregion
+export { PubSubEngine, TypedPubSub, createPubSub, mapAsyncIterator, withFilter };

package/dist/core/pubsub/index.mjs

@@ -0,0 +1,146 @@
+import { EventEmitter } from "node:events";
+//#region src/core/pubsub/index.ts
+/**
+* Built-in PubSub implementation for GraphQL Subscriptions
+* Simple EventEmitter-based implementation for single-instance deployments
+*
+* For multi-instance deployments, use external PubSub solutions like:
+* - Redis (with ioredis)
+* - Kafka
+* - RabbitMQ
+* - Cloud Pub/Sub services
+*/
+/**
+* Create a simple in-memory PubSub instance
+*
+* This implementation uses EventEmitter for lightweight pub/sub functionality.
+* Suitable for:
+* - Development environments
+* - Single-instance production deployments
+* - Testing
+*
+* NOT suitable for:
+* - Multi-instance/clustered deployments (events won't propagate across instances)
+* - High-throughput scenarios (consider Redis-based PubSub)
+*
+* @example
+* ```typescript
+* // Define your topic types
+* interface MyTopics {
+*   'user:created': { id: string; name: string }
+*   'message:sent': { channelId: string; content: string }
+* }
+*
+* // Create typed PubSub instance
+* const pubsub = createPubSub<MyTopics>()
+*
+* // Publish events
+* await pubsub.publish('user:created', { id: '123', name: 'John' })
+*
+* // Subscribe to events (in a resolver)
+* export const userSubscriptions = defineSubscription({
+*   userCreated: {
+*     subscribe: async function* () {
+*       yield* pubsub.subscribe('user:created')
+*     }
+*   }
+* })
+* ```
+*/
+function createPubSub() {
+	const emitter = new EventEmitter();
+	emitter.setMaxListeners(0);
+	return {
+		async publish(topic, payload) {
+			emitter.emit(String(topic), payload);
+		},
+		subscribe(topic) {
+			const topicStr = String(topic);
+			return { [Symbol.asyncIterator]() {
+				const queue = [];
+				let resolve = null;
+				let done = false;
+				const listener = (payload) => {
+					if (resolve) {
+						resolve({
+							value: payload,
+							done: false
+						});
+						resolve = null;
+					} else queue.push(payload);
+				};
+				emitter.on(topicStr, listener);
+				return {
+					next() {
+						if (done) return Promise.resolve({
+							value: void 0,
+							done: true
+						});
+						if (queue.length > 0) return Promise.resolve({
+							value: queue.shift(),
+							done: false
+						});
+						return new Promise((r) => {
+							resolve = r;
+						});
+					},
+					return() {
+						done = true;
+						emitter.off(topicStr, listener);
+						return Promise.resolve({
+							value: void 0,
+							done: true
+						});
+					},
+					throw(error) {
+						done = true;
+						emitter.off(topicStr, listener);
+						return Promise.reject(error);
+					}
+				};
+			} };
+		}
+	};
+}
+/**
+* Filter subscription events based on a predicate
+*
+* @example
+* ```typescript
+* export const chatSubscriptions = defineSubscription({
+*   messageAdded: {
+*     subscribe: async function* (_, { channelId }) {
+*       yield* withFilter(
+*         pubsub.subscribe('message:added'),
+*         (message) => message.channelId === channelId
+*       )
+*     }
+*   }
+* })
+* ```
+*/
+async function* withFilter(asyncIterable, filter) {
+	for await (const value of asyncIterable) if (await filter(value)) yield value;
+}
+/**
+* Map subscription events to a different shape
+*
+* @example
+* ```typescript
+* export const chatSubscriptions = defineSubscription({
+*   messageAdded: {
+*     subscribe: async function* () {
+*       yield* mapAsyncIterator(
+*         pubsub.subscribe('message:added'),
+*         (event) => ({ messageAdded: event.message })
+*       )
+*     }
+*   }
+* })
+* ```
+*/
+async function* mapAsyncIterator(asyncIterable, mapper) {
+	for await (const value of asyncIterable) yield await mapper(value);
+}
+//#endregion
+export { createPubSub, mapAsyncIterator, withFilter };

package/dist/core/scanning/ast-scanner.d.mts

@@ -0,0 +1,27 @@
+import { ResolverImport, ScanContext, ScanResult, ScannedResolver } from "../types/scanning.mjs";
+
+//#region src/core/scanning/ast-scanner.d.ts
+/**
+ * Configuration for AST-based scanning
+ */
+interface ASTScanConfig {
+  /** Glob pattern for files to scan */
+  pattern: string;
+  /** Parse a function call and return import info, or null if not a valid export */
+  parseCall: (calleeName: string, exportName: string, filePath: string) => ResolverImport | null;
+  /** Whether to emit warnings for common issues (default: true for resolvers) */
+  emitWarnings?: boolean;
+  /** Valid function names for warning messages */
+  validFunctions?: readonly string[];
+}
+/**
+ * Scan files matching a pattern and parse their exports using AST
+ */
+declare function scanWithAST(ctx: ScanContext, config: ASTScanConfig): Promise<ScanResult<ScannedResolver>>;
+/**
+ * Parse a single file and extract exports using AST
+ * Used for manifest resolver files
+ */
+declare function parseSingleFile(filePath: string, parseCall: (calleeName: string, exportName: string, filePath: string) => ResolverImport | null): Promise<ScannedResolver | null>;
+//#endregion
+export { ASTScanConfig, parseSingleFile, scanWithAST };

package/dist/core/scanning/ast-scanner.mjs

@@ -0,0 +1,114 @@
+import { scanDirectory } from "./common.mjs";
+import { readFile } from "node:fs/promises";
+import { basename, relative } from "pathe";
+import { parseSync } from "oxc-parser";
+//#region src/core/scanning/ast-scanner.ts
+/**
+* Scan files matching a pattern and parse their exports using AST
+*/
+async function scanWithAST(ctx, config) {
+	const warnings = [];
+	const errors = [];
+	try {
+		const serverDirRelative = relative(ctx.rootDir, ctx.serverDir);
+		const files = await scanDirectory(ctx, ctx.rootDir, serverDirRelative, config.pattern);
+		const results = [];
+		for (const file of files) try {
+			const fileContent = await readFile(file.fullPath, "utf-8");
+			const parsed = parseSync(file.fullPath, fileContent);
+			if (parsed.errors && parsed.errors.length > 0) {
+				if (ctx.isDev) {
+					const fileName = basename(file.fullPath);
+					const firstError = parsed.errors[0];
+					const location = firstError?.labels?.[0];
+					const lineInfo = location ? `:${location.start}` : "";
+					const message = firstError?.message.split(",")[0] || "Syntax error";
+					errors.push(`${fileName}${lineInfo} - ${message}`);
+				}
+				continue;
+			}
+			const result = parseExports(file.fullPath, parsed.program, config);
+			if (ctx.isDev && config.emitWarnings && result.warnings.length > 0) {
+				const relPath = relative(ctx.rootDir, file.fullPath);
+				for (const warning of result.warnings) warnings.push(`${relPath}: ${warning}`);
+			}
+			if (result.resolver.imports.length > 0) results.push(result.resolver);
+		} catch (error) {
+			const relPath = relative(ctx.rootDir, file.fullPath);
+			errors.push(`Failed to parse file ${relPath}: ${error}`);
+		}
+		return {
+			items: results,
+			warnings,
+			errors
+		};
+	} catch (error) {
+		errors.push(`Scanning error: ${error}`);
+		return {
+			items: [],
+			warnings,
+			errors
+		};
+	}
+}
+/**
+* Parse a single file and extract exports using AST
+* Used for manifest resolver files
+*/
+async function parseSingleFile(filePath, parseCall) {
+	try {
+		const parsed = parseSync(filePath, await readFile(filePath, "utf-8"));
+		if (parsed.errors && parsed.errors.length > 0) return null;
+		const result = parseExports(filePath, parsed.program, {
+			pattern: "",
+			parseCall,
+			emitWarnings: false
+		});
+		if (result.resolver.imports.length > 0) return result.resolver;
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Parse exports from AST program
+*/
+function parseExports(filePath, program, config) {
+	const warnings = [];
+	const resolver = {
+		specifier: filePath,
+		imports: []
+	};
+	let hasDefaultExport = false;
+	let hasNamedExport = false;
+	const namedExports = [];
+	for (const node of program.body) {
+		if (node.type === "ExportDefaultDeclaration") hasDefaultExport = true;
+		if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+			for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.init && decl.id.type === "Identifier") {
+				hasNamedExport = true;
+				namedExports.push(decl.id.name);
+				if (decl.init && decl.init.type === "CallExpression") {
+					if (decl.init.callee.type === "Identifier") {
+						const imp = config.parseCall(decl.init.callee.name, decl.id.name, filePath);
+						if (imp) resolver.imports.push(imp);
+					}
+				}
+			}
+		}
+	}
+	if (config.emitWarnings) {
+		if (hasDefaultExport && !hasNamedExport) warnings.push("Using default export instead of named export. Must use named exports like \"export const myResolver = defineQuery(...)\". Default exports are not detected.");
+		if (resolver.imports.length === 0 && hasNamedExport) {
+			const validFunctions = config.validFunctions?.join(", ") || "define* functions";
+			warnings.push(`File has named exports [${namedExports.join(", ")}] but none use the required define functions (${validFunctions}). Exports will not be registered.`);
+		}
+		if (!hasDefaultExport && !hasNamedExport) warnings.push("No exports found. Files must export using define* functions.");
+	}
+	return {
+		resolver,
+		warnings
+	};
+}
+//#endregion
+export { parseSingleFile, scanWithAST };

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

@@ -0,0 +1,25 @@
+import { ScanContext, ScannedFile } from "../types/scanning.mjs";
+
+//#region src/core/scanning/common.d.ts
+/**
+ * Scan a directory for files matching a glob pattern
+ */
+declare function scanDirectory(ctx: ScanContext, baseDir: string, subDir: string, globPattern?: string): Promise<ScannedFile[]>;
+/**
+ * Deduplicate files by fullPath
+ */
+declare function deduplicateFiles<T extends {
+  fullPath: string;
+}>(files: T[]): T[];
+/**
+ * Filter files by extension
+ */
+declare function filterByExtension<T extends {
+  fullPath: string;
+}>(files: T[], extensions: readonly string[]): T[];
+/**
+ * Extract file paths from scanned files
+ */
+declare function extractPaths(files: ScannedFile[]): string[];
+//#endregion
+export { deduplicateFiles, extractPaths, filterByExtension, scanDirectory };

package/dist/core/scanning/common.mjs

@@ -0,0 +1,57 @@
+import { GLOB_SCAN_PATTERN } from "../constants.mjs";
+import { join, relative } from "pathe";
+import { glob } from "tinyglobby";
+//#region src/core/scanning/common.ts
+const DEFAULT_IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/.output/**",
+	"**/.nitro/**",
+	"**/.nuxt/**",
+	"**/.graphql/**"
+];
+/**
+* Scan a directory for files matching a glob pattern
+*/
+async function scanDirectory(ctx, baseDir, subDir, globPattern = GLOB_SCAN_PATTERN) {
+	return (await glob(join(subDir, globPattern), {
+		cwd: baseDir,
+		dot: true,
+		ignore: [...DEFAULT_IGNORE_PATTERNS, ...ctx.ignorePatterns],
+		absolute: true
+	}).catch((error) => {
+		if (error?.code === "ENOTDIR") {
+			ctx.logger.warn(`Ignoring \`${join(baseDir, subDir)}\`. It must be a directory.`);
+			return [];
+		}
+		throw error;
+	})).map((fullPath) => ({
+		fullPath,
+		path: relative(join(baseDir, subDir), fullPath)
+	})).sort((a, b) => a.path.localeCompare(b.path));
+}
+/**
+* Deduplicate files by fullPath
+*/
+function deduplicateFiles(files) {
+	const seenPaths = /* @__PURE__ */ new Set();
+	return files.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	});
+}
+/**
+* Filter files by extension
+*/
+function filterByExtension(files, extensions) {
+	return files.filter((file) => extensions.some((ext) => file.fullPath.endsWith(ext)));
+}
+/**
+* Extract file paths from scanned files
+*/
+function extractPaths(files) {
+	return files.map((f) => f.fullPath);
+}
+//#endregion
+export { deduplicateFiles, extractPaths, filterByExtension, scanDirectory };

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

@@ -0,0 +1,13 @@
+import { ResolverImport, ScanContext, ScanResult, ScannedResolver } from "../types/scanning.mjs";
+
+//#region src/core/scanning/directives.d.ts
+/**
+ * Parse a defineDirective call and return the import info
+ */
+declare function parseDirectiveCall(calleeName: string, exportName: string, filePath: string): ResolverImport | null;
+/**
+ * Scan for directive files (.directive.ts/.js)
+ */
+declare function scanDirectivesCore(ctx: ScanContext): Promise<ScanResult<ScannedResolver>>;
+//#endregion
+export { parseDirectiveCall, scanDirectivesCore };