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

package/dist/core/pubsub/index.mjs

@@ -1,148 +1,2 @@
-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 };
+import { createPubSub, mapAsyncIterator, withFilter } from "./memory-pubsub.mjs";
+export { createPubSub, mapAsyncIterator, withFilter };

package/dist/core/pubsub/memory-pubsub.d.mts

@@ -0,0 +1,109 @@
+//#region src/core/pubsub/memory-pubsub.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/memory-pubsub.mjs

@@ -0,0 +1,146 @@
+import { EventEmitter } from "node:events";
+//#region src/core/pubsub/memory-pubsub.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.mjs

@@ -1,8 +1,8 @@
-import { scanDirectory } from "./common.mjs";
+import { scanDirectory } from "./file-scanner.mjs";
 import { readFile } from "node:fs/promises";
+import consola from "consola";
 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
@@ -67,7 +67,8 @@ async function parseSingleFile(filePath, parseCall) {
 		});
 		if (result.resolver.imports.length > 0) return result.resolver;
 		return null;
-	} catch {
+	} catch (error) {
+		consola.debug(`[nitro-graphql] Failed to parse file ${filePath}:`, error);
 		return null;
 	}
 }
@@ -111,6 +112,5 @@ function parseExports(filePath, program, config) {
 		warnings
 	};
 }
-
 //#endregion
-export { parseSingleFile, scanWithAST };
+export { parseSingleFile, scanWithAST };

package/dist/core/scanning/directives.mjs

@@ -1,7 +1,6 @@
 import { DIRECTIVE_GLOB_PATTERN } from "../constants.mjs";
 import { scanWithAST } from "./ast-scanner.mjs";
-import { hash } from "ohash";
-
+import { getImportId } from "../utils/imports.mjs";
 //#region src/core/scanning/directives.ts
 /**
 * Parse a defineDirective call and return the import info
@@ -11,7 +10,7 @@ function parseDirectiveCall(calleeName, exportName, filePath) {
 	return {
 		name: exportName,
 		type: "directive",
-		as: `_${hash(exportName + filePath).replace(/-/g, "").slice(0, 6)}`
+		as: getImportId(exportName + filePath)
 	};
 }
 /**
@@ -24,6 +23,5 @@ function scanDirectivesCore(ctx) {
 		emitWarnings: false
 	});
 }
-
 //#endregion
-export { parseDirectiveCall, scanDirectivesCore };
+export { parseDirectiveCall, scanDirectivesCore };

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

@@ -1,4 +1,3 @@
-import { CoreExternalService } from "../types/config.mjs";
 import { ScanContext, ScanResult } from "../types/scanning.mjs";
 
 //#region src/core/scanning/documents.d.ts
@@ -6,8 +5,10 @@ import { ScanContext, ScanResult } from "../types/scanning.mjs";
  * Options for scanning documents
  */
 interface ScanDocumentsOptions {
-  /** External services to exclude from main scan */
-  externalServices?: CoreExternalService[];
+  /** External services to exclude from main scan (only documents field is used) */
+  externalServices?: Array<{
+    documents?: string[];
+  }>;
   /** Client directory relative path */
   clientDirRelative?: string;
 }

package/dist/core/scanning/documents.mjs

@@ -1,8 +1,8 @@
 import { GRAPHQL_GLOB_PATTERN } from "../constants.mjs";
-import { scanDirectory } from "./common.mjs";
+import { scanDirectory } from "./file-scanner.mjs";
 import { relative } from "pathe";
-
 //#region src/core/scanning/documents.ts
+const REGEX_SPECIAL_CHARS_RE = /[.*+?^${}()|[\]\\]/g;
 /**
 * Scan for GraphQL client documents (.graphql, .gql) in client directory
 * Excludes files from external service directories
@@ -17,7 +17,7 @@ async function scanDocumentsCore(ctx, options = {}) {
 		return {
 			items: allFiles.filter((f) => !f.path.startsWith("external/")).filter((f) => {
 				const relativePath = f.path;
-				for (const pattern of externalPatterns) if (pattern.replace(new RegExp(`^${clientDirRelative.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/`), "").split("/")[0] === relativePath.split("/")[0]) return false;
+				for (const pattern of externalPatterns) if (pattern.replace(new RegExp(`^${clientDirRelative.replace(REGEX_SPECIAL_CHARS_RE, "\\$&")}/`), "").split("/")[0] === relativePath.split("/")[0]) return false;
 				return true;
 			}).map((f) => f.fullPath),
 			warnings,
@@ -32,6 +32,5 @@ async function scanDocumentsCore(ctx, options = {}) {
 		};
 	}
 }
-
 //#endregion
-export { scanDocumentsCore };
+export { scanDocumentsCore };

package/dist/core/scanning/{common.d.mts → file-scanner.d.mts}

@@ -1,6 +1,6 @@
 import { ScanContext, ScannedFile } from "../types/scanning.mjs";
 
-//#region src/core/scanning/common.d.ts
+//#region src/core/scanning/file-scanner.d.ts
 /**
  * Scan a directory for files matching a glob pattern
  */

package/dist/core/scanning/{common.mjs → file-scanner.mjs}

@@ -1,16 +1,7 @@
-import { GLOB_SCAN_PATTERN } from "../constants.mjs";
+import { DEFAULT_IGNORE_PATTERNS, 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/**"
-];
+//#region src/core/scanning/file-scanner.ts
 /**
 * Scan a directory for files matching a glob pattern
 */
@@ -54,6 +45,5 @@ function filterByExtension(files, extensions) {
 function extractPaths(files) {
 	return files.map((f) => f.fullPath);
 }
-
 //#endregion
-export { deduplicateFiles, extractPaths, filterByExtension, scanDirectory };
+export { deduplicateFiles, extractPaths, filterByExtension, scanDirectory };

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

@@ -1,7 +1,7 @@
 import { ASTScanConfig, parseSingleFile, scanWithAST } from "./ast-scanner.mjs";
-import { deduplicateFiles, extractPaths, filterByExtension, scanDirectory } from "./common.mjs";
 import { parseDirectiveCall, scanDirectivesCore } from "./directives.mjs";
 import { ScanDocumentsOptions, scanDocumentsCore } from "./documents.mjs";
+import { deduplicateFiles, extractPaths, filterByExtension, scanDirectory } from "./file-scanner.mjs";
 import { parseResolverCall, scanResolversCore } from "./resolvers.mjs";
-import { scanGraphqlCore, scanSchemasCore } from "./schemas.mjs";
-export { type ASTScanConfig, type ScanDocumentsOptions, deduplicateFiles, extractPaths, filterByExtension, parseDirectiveCall, parseResolverCall, parseSingleFile, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST };
+import { scanSchemasCore } from "./schemas.mjs";
+export { type ASTScanConfig, type ScanDocumentsOptions, deduplicateFiles, extractPaths, filterByExtension, parseDirectiveCall, parseResolverCall, parseSingleFile, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanResolversCore, scanSchemasCore, scanWithAST };

package/dist/core/scanning/index.mjs

@@ -1,8 +1,7 @@
-import { deduplicateFiles, extractPaths, filterByExtension, scanDirectory } from "./common.mjs";
+import { deduplicateFiles, extractPaths, filterByExtension, scanDirectory } from "./file-scanner.mjs";
 import { parseSingleFile, scanWithAST } from "./ast-scanner.mjs";
 import { parseDirectiveCall, scanDirectivesCore } from "./directives.mjs";
 import { scanDocumentsCore } from "./documents.mjs";
 import { parseResolverCall, scanResolversCore } from "./resolvers.mjs";
-import { scanGraphqlCore, scanSchemasCore } from "./schemas.mjs";
-
-export { deduplicateFiles, extractPaths, filterByExtension, parseDirectiveCall, parseResolverCall, parseSingleFile, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST };
+import { scanSchemasCore } from "./schemas.mjs";
+export { deduplicateFiles, extractPaths, filterByExtension, parseDirectiveCall, parseResolverCall, parseSingleFile, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanResolversCore, scanSchemasCore, scanWithAST };

package/dist/core/scanning/resolvers.mjs

@@ -1,44 +1,43 @@
 import { DEFINE_FUNCTIONS, RESOLVER_GLOB_PATTERN } from "../constants.mjs";
 import { scanWithAST } from "./ast-scanner.mjs";
-import { hash } from "ohash";
-
+import { getImportId } from "../utils/imports.mjs";
 //#region src/core/scanning/resolvers.ts
 /**
 * Parse a define* function call and return the import info
 * Exported for use by manifest loader
 */
 function parseResolverCall(calleeName, exportName, filePath) {
-	const aliasHash = `_${hash(exportName + filePath).replace(/-/g, "").slice(0, 6)}`;
+	const alias = getImportId(exportName + filePath);
 	switch (calleeName) {
 		case "defineResolver": return {
 			name: exportName,
 			type: "resolver",
-			as: aliasHash
+			as: alias
 		};
 		case "defineQuery": return {
 			name: exportName,
 			type: "query",
-			as: aliasHash
+			as: alias
 		};
 		case "defineMutation": return {
 			name: exportName,
 			type: "mutation",
-			as: aliasHash
+			as: alias
 		};
 		case "defineField": return {
 			name: exportName,
 			type: "type",
-			as: aliasHash
+			as: alias
 		};
 		case "defineSubscription": return {
 			name: exportName,
 			type: "subscription",
-			as: aliasHash
+			as: alias
 		};
 		case "defineDirective": return {
 			name: exportName,
 			type: "directive",
-			as: aliasHash
+			as: alias
 		};
 		default: return null;
 	}
@@ -54,6 +53,5 @@ function scanResolversCore(ctx) {
 		validFunctions: DEFINE_FUNCTIONS
 	});
 }
-
 //#endregion
-export { parseResolverCall, scanResolversCore };
+export { parseResolverCall, scanResolversCore };

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

@@ -5,9 +5,5 @@ import { ScanContext, ScanResult } from "../types/scanning.mjs";
  * Scan for GraphQL schema files (.graphql, .gql) in server directory
  */
 declare function scanSchemasCore(ctx: ScanContext): Promise<ScanResult<string>>;
-/**
- * Scan for GraphQL files (.graphql, .gql) in server directory
- */
-declare function scanGraphqlCore(ctx: ScanContext): Promise<ScanResult<string>>;
 //#endregion
-export { scanGraphqlCore, scanSchemasCore };
+export { scanSchemasCore };

package/dist/core/scanning/schemas.mjs

@@ -1,7 +1,6 @@
 import { GRAPHQL_GLOB_PATTERN } from "../constants.mjs";
-import { extractPaths, scanDirectory } from "./common.mjs";
+import { extractPaths, scanDirectory } from "./file-scanner.mjs";
 import { relative } from "pathe";
-
 //#region src/core/scanning/schemas.ts
 /**
 * Scan for GraphQL schema files (.graphql, .gql) in server directory
@@ -25,28 +24,5 @@ async function scanSchemasCore(ctx) {
 		};
 	}
 }
-/**
-* Scan for GraphQL files (.graphql, .gql) in server directory
-*/
-async function scanGraphqlCore(ctx) {
-	const warnings = [];
-	const errors = [];
-	try {
-		const serverDirRelative = relative(ctx.rootDir, ctx.serverDir);
-		return {
-			items: extractPaths(await scanDirectory(ctx, ctx.rootDir, serverDirRelative, "**/*.{graphql,gql}")),
-			warnings,
-			errors
-		};
-	} catch (error) {
-		errors.push(`GraphQL scanning error: ${error}`);
-		return {
-			items: [],
-			warnings,
-			errors
-		};
-	}
-}
-
 //#endregion
-export { scanGraphqlCore, scanSchemasCore };
+export { scanSchemasCore };