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

package/dist/core/utils/runtime.mjs

@@ -0,0 +1,111 @@
+import { basename, dirname, join, resolve } from "pathe";
+import { existsSync, mkdirSync, promises, readFileSync, writeFileSync } from "node:fs";
+import { pathToFileURL as pathToFileURL$1 } from "node:url";
+
+//#region src/core/utils/runtime.ts
+/**
+* Cross-runtime compatibility layer
+*
+* Provides runtime-agnostic file system and process utilities
+* that work across Node.js, Bun, and Deno.
+*/
+const _globalThis = globalThis;
+/**
+* Read file contents asynchronously
+*/
+async function readFile(path) {
+	return promises.readFile(path, "utf-8");
+}
+/**
+* Read file contents synchronously
+*/
+function readFileSync_(path) {
+	return readFileSync(path, "utf-8");
+}
+/**
+* Write file contents asynchronously
+*/
+async function writeFile(path, content) {
+	await promises.writeFile(path, content, "utf-8");
+}
+/**
+* Write file contents synchronously
+*/
+function writeFileSync_(path, content) {
+	writeFileSync(path, content, "utf-8");
+}
+/**
+* Check if file/directory exists asynchronously
+*/
+async function exists(path) {
+	try {
+		await promises.access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Check if file/directory exists synchronously
+*/
+function existsSync_(path) {
+	return existsSync(path);
+}
+/**
+* Create directory recursively asynchronously
+*/
+async function mkdir(path) {
+	await promises.mkdir(path, { recursive: true });
+}
+/**
+* Create directory recursively synchronously
+*/
+function mkdirSync_(path) {
+	mkdirSync(path, { recursive: true });
+}
+/**
+* Get current working directory
+* Works across Node.js, Bun, and Deno
+*/
+function getCwd() {
+	if (_globalThis.Deno) return _globalThis.Deno.cwd();
+	return process.cwd();
+}
+/**
+* Exit process with code
+* Works across Node.js, Bun, and Deno
+*/
+function exit(code) {
+	if (_globalThis.Deno) _globalThis.Deno.exit(code);
+	process.exit(code);
+}
+/**
+* Convert file path to file URL
+* Works across Node.js, Bun, and Deno
+*/
+function pathToFileURL(path) {
+	return pathToFileURL$1(path);
+}
+/**
+* Register signal handler (SIGINT, SIGTERM, etc.)
+* Works across Node.js, Bun, and Deno
+*/
+function onSignal(signal, handler) {
+	if (_globalThis.Deno) _globalThis.Deno.addSignalListener(signal, handler);
+	else process.on(signal, handler);
+}
+/**
+* Read directory contents
+*/
+async function readdir(path) {
+	return promises.readdir(path);
+}
+/**
+* Get file/directory stats
+*/
+async function stat(path) {
+	return promises.stat(path);
+}
+
+//#endregion
+export { basename, dirname, exists, existsSync_, exit, getCwd, join, mkdir, mkdirSync_, onSignal, pathToFileURL, readFile, readFileSync_, readdir, resolve, stat, writeFile, writeFileSync_ };

package/dist/core/utils/subscribe-templates.d.mts

@@ -0,0 +1,8 @@
+//#region src/core/utils/subscribe-templates.d.ts
+/**
+ * Template for GraphQL subscription client config
+ * Small config file that users can customize (like ofetch.ts pattern)
+ */
+declare const subscribeClientTemplate = "// This file is auto-generated once by nitro-graphql for quick start\n// You can modify this file to customize the subscription client\n// The implementation comes from nitro-graphql/subscribe - you'll get updates automatically!\n//\n// Usage Examples:\n// ---------------\n// Basic subscription:\n//   subscriptionClient.subscribe(query, variables, onData, onError)\n//\n// Multiplexed subscriptions (shared connection):\n//   const session = subscriptionClient.createSession()\n//   session.subscribe(query1, vars1, onData1)\n//   session.subscribe(query2, vars2, onData2)\n//\n// With authentication:\n//   Edit connectionParams below to add auth headers\n\nimport type {\n  ConnectionState,\n  SubscriptionClient,\n  SubscriptionClientConfig,\n  SubscriptionHandle,\n  SubscriptionSession,\n} from 'nitro-graphql/subscribe'\nimport { createSubscriptionClient } from 'nitro-graphql/subscribe'\n\n// Re-export types for convenience\nexport type { ConnectionState, SubscriptionClient, SubscriptionHandle, SubscriptionSession }\n\n// Configure the subscription client\n// Customize these settings according to your needs\nconst config: SubscriptionClientConfig = {\n  // WebSocket endpoint (default: '/api/graphql/ws')\n  wsEndpoint: '/api/graphql/ws',\n\n  // Connection timeout in ms (default: 10000)\n  connectionTimeoutMs: 10000,\n\n  // Max reconnection attempts (default: 5)\n  maxRetries: 5,\n\n  // Authentication params sent with connection_init\n  // Can be a function for dynamic values (e.g., JWT tokens)\n  // connectionParams: () => ({\n  //   authorization: `Bearer ${getToken()}`,\n  // }),\n}\n\n// Export configured client instance\nexport const subscriptionClient = createSubscriptionClient(config)\n";
+//#endregion
+export { subscribeClientTemplate };

package/dist/core/utils/subscribe-templates.mjs

@@ -0,0 +1,59 @@
+//#region src/core/utils/subscribe-templates.ts
+/**
+* Template for GraphQL subscription client config
+* Small config file that users can customize (like ofetch.ts pattern)
+*/
+const subscribeClientTemplate = `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file to customize the subscription client
+// The implementation comes from nitro-graphql/subscribe - you'll get updates automatically!
+//
+// Usage Examples:
+// ---------------
+// Basic subscription:
+//   subscriptionClient.subscribe(query, variables, onData, onError)
+//
+// Multiplexed subscriptions (shared connection):
+//   const session = subscriptionClient.createSession()
+//   session.subscribe(query1, vars1, onData1)
+//   session.subscribe(query2, vars2, onData2)
+//
+// With authentication:
+//   Edit connectionParams below to add auth headers
+
+import type {
+  ConnectionState,
+  SubscriptionClient,
+  SubscriptionClientConfig,
+  SubscriptionHandle,
+  SubscriptionSession,
+} from 'nitro-graphql/subscribe'
+import { createSubscriptionClient } from 'nitro-graphql/subscribe'
+
+// Re-export types for convenience
+export type { ConnectionState, SubscriptionClient, SubscriptionHandle, SubscriptionSession }
+
+// Configure the subscription client
+// Customize these settings according to your needs
+const config: SubscriptionClientConfig = {
+  // WebSocket endpoint (default: '/api/graphql/ws')
+  wsEndpoint: '/api/graphql/ws',
+
+  // Connection timeout in ms (default: 10000)
+  connectionTimeoutMs: 10000,
+
+  // Max reconnection attempts (default: 5)
+  maxRetries: 5,
+
+  // Authentication params sent with connection_init
+  // Can be a function for dynamic values (e.g., JWT tokens)
+  // connectionParams: () => ({
+  //   authorization: \`Bearer \${getToken()}\`,
+  // }),
+}
+
+// Export configured client instance
+export const subscriptionClient = createSubscriptionClient(config)
+`;
+
+//#endregion
+export { subscribeClientTemplate };

package/dist/core/validation/external-services.d.mts

@@ -0,0 +1,11 @@
+//#region src/core/validation/external-services.d.ts
+/**
+ * External services validation utilities
+ * Framework-agnostic validation helpers
+ */
+/**
+ * Validate external GraphQL service configuration
+ */
+declare function validateExternalServices(services: unknown[]): string[];
+//#endregion
+export { validateExternalServices };

package/dist/core/validation/external-services.mjs

@@ -0,0 +1,33 @@
+//#region src/core/validation/external-services.ts
+/**
+* External services validation utilities
+* Framework-agnostic validation helpers
+*/
+/**
+* Validate external GraphQL service configuration
+*/
+function validateExternalServices(services) {
+	const errors = [];
+	const serviceNames = /* @__PURE__ */ new Set();
+	for (const [index, service] of services.entries()) {
+		const prefix = `externalServices[${index}]`;
+		if (!service || typeof service !== "object") {
+			errors.push(`${prefix} must be an object`);
+			continue;
+		}
+		if (!("name" in service) || typeof service.name !== "string") errors.push(`${prefix}.name is required and must be a string`);
+		else if (serviceNames.has(service.name)) errors.push(`${prefix}.name "${service.name}" must be unique`);
+		else serviceNames.add(service.name);
+		if (!("endpoint" in service) || typeof service.endpoint !== "string") errors.push(`${prefix}.endpoint is required and must be a string`);
+		else try {
+			new URL(service.endpoint);
+		} catch {
+			errors.push(`${prefix}.endpoint "${service.endpoint}" must be a valid URL`);
+		}
+		if ("name" in service && typeof service.name === "string" && !/^[a-z]\w*$/i.test(service.name)) errors.push(`${prefix}.name "${service.name}" must be a valid identifier (letters, numbers, underscore, starting with letter)`);
+	}
+	return errors;
+}
+
+//#endregion
+export { validateExternalServices };

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

@@ -0,0 +1,2 @@
+import { validateExternalServices } from "./external-services.mjs";
+export { validateExternalServices };

package/dist/core/validation/index.mjs

@@ -0,0 +1,3 @@
+import { validateExternalServices } from "./external-services.mjs";
+
+export { validateExternalServices };

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

@@ -0,0 +1,107 @@
+import { FSWatcher } from "chokidar";
+
+//#region src/core/watcher/index.d.ts
+/**
+ * Configuration for core watcher
+ */
+interface CoreWatcherConfig {
+  /** Directories to watch */
+  watchDirs: string[];
+  /** Server directory path (to classify changes) */
+  serverDir: string;
+  /** Debounce delay in ms (default: 150) */
+  debounceMs?: number;
+  /** Persistent watcher (default: true) */
+  persistent?: boolean;
+  /** Ignore initial scan (default: true) */
+  ignoreInitial?: boolean;
+  /** Use polling mode (default: false, but auto-enabled in CI/test environments) */
+  usePolling?: boolean;
+}
+/**
+ * Callbacks for watcher events
+ */
+interface CoreWatcherCallbacks {
+  /** Called when server files change (schemas, resolvers, directives) */
+  onServerChange: () => Promise<void>;
+  /** Called when client files change (documents only) */
+  onClientChange: () => Promise<void>;
+  /** Called when watcher is ready */
+  onReady?: () => void;
+  /** Called on watcher error */
+  onError?: (error: unknown) => void;
+}
+/**
+ * File type classification
+ */
+type FileType = 'graphql' | 'resolver' | 'directive' | null;
+/**
+ * Change type classification
+ */
+type ChangeType = 'server' | 'client' | null;
+/**
+ * Check if a file is a GraphQL-related file
+ */
+declare function getFileType(path: string): FileType;
+/**
+ * Check if a file should be watched
+ */
+declare function isWatchableFile(path: string): boolean;
+/**
+ * Classify a file change as server or client
+ */
+declare function classifyChange(path: string, serverDir: string): ChangeType;
+/**
+ * Create the ignored function for chokidar
+ * Filters out non-GraphQL files and system directories
+ */
+declare function createIgnoredFunction(): (path: string) => boolean;
+/**
+ * Check if a path should be skipped (generated files)
+ */
+declare function shouldSkipPath(path: string): boolean;
+/**
+ * Create a core file watcher
+ *
+ * This is the shared watcher used by both Nitro and CLI.
+ * Framework-specific actions are passed as callbacks.
+ *
+ * @example
+ * ```typescript
+ * // In Nitro
+ * const watcher = createCoreWatcher(
+ *   { watchDirs, serverDir: nitro.graphql.serverDir },
+ *   {
+ *     onServerChange: async () => {
+ *       await performGraphQLScan(nitro, { silent: true, isRescan: true })
+ *       await generateServerTypes(nitro, { silent: true })
+ *       await nitro.hooks.callHook('dev:reload')
+ *     },
+ *     onClientChange: async () => {
+ *       await generateClientTypes(nitro, { silent: true })
+ *     },
+ *   }
+ * )
+ *
+ * // In CLI
+ * const watcher = createCoreWatcher(
+ *   { watchDirs, serverDir: ctx.config.serverDir },
+ *   {
+ *     onServerChange: async () => {
+ *       await generateAll(ctx, { silent: true })
+ *       await reloadHandler()
+ *     },
+ *     onClientChange: async () => {
+ *       await generateClient(ctx, { silent: true })
+ *     },
+ *   }
+ * )
+ * ```
+ */
+declare function createCoreWatcher(config: CoreWatcherConfig, callbacks: CoreWatcherCallbacks): FSWatcher;
+/**
+ * Close a watcher safely
+ */
+declare function closeWatcher(watcher: FSWatcher): Promise<void>;
+//#endregion
+export { ChangeType, CoreWatcherCallbacks, CoreWatcherConfig, FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };

package/dist/core/watcher/index.mjs

@@ -0,0 +1,141 @@
+import { DIRECTIVE_EXTENSIONS, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../constants.mjs";
+import { watch } from "chokidar";
+import { debounce } from "perfect-debounce";
+
+//#region src/core/watcher/index.ts
+/**
+* Check if a file is a GraphQL-related file
+*/
+function getFileType(path) {
+	if (GRAPHQL_EXTENSIONS.some((ext) => path.endsWith(ext))) return "graphql";
+	if (RESOLVER_EXTENSIONS.some((ext) => path.endsWith(ext))) return "resolver";
+	if (DIRECTIVE_EXTENSIONS.some((ext) => path.endsWith(ext))) return "directive";
+	return null;
+}
+/**
+* Check if a file should be watched
+*/
+function isWatchableFile(path) {
+	return getFileType(path) !== null;
+}
+/**
+* Classify a file change as server or client
+*/
+function classifyChange(path, serverDir) {
+	const fileType = getFileType(path);
+	if (!fileType) return null;
+	if (fileType === "resolver" || fileType === "directive") return "server";
+	if (fileType === "graphql") {
+		const normalizedPath = path.replace(/\\/g, "/");
+		const normalizedServerDir = serverDir.replace(/\\/g, "/");
+		if (normalizedPath.includes(normalizedServerDir)) return "server";
+		if (normalizedPath.includes("/server/graphql/") || normalizedPath.includes("\\server\\graphql\\")) return "server";
+		return "client";
+	}
+	return null;
+}
+/**
+* Create the ignored function for chokidar
+* Filters out non-GraphQL files and system directories
+*/
+function createIgnoredFunction() {
+	return (path) => {
+		if (path.includes("/node_modules/") || path.includes("/.git/") || path.includes("/.output/") || path.includes("/.nitro/") || path.includes("/.nuxt/") || path.includes("/.graphql/") || path.includes("/dist/")) return true;
+		if (!(path.split("/").pop() || "").includes(".") || path.endsWith("/")) return false;
+		return !isWatchableFile(path);
+	};
+}
+/**
+* Check if a path should be skipped (generated files)
+*/
+function shouldSkipPath(path) {
+	return path.includes("/sdk.ts") || path.includes("/sdk.js") || path.endsWith("/config.ts");
+}
+/**
+* Create a core file watcher
+*
+* This is the shared watcher used by both Nitro and CLI.
+* Framework-specific actions are passed as callbacks.
+*
+* @example
+* ```typescript
+* // In Nitro
+* const watcher = createCoreWatcher(
+*   { watchDirs, serverDir: nitro.graphql.serverDir },
+*   {
+*     onServerChange: async () => {
+*       await performGraphQLScan(nitro, { silent: true, isRescan: true })
+*       await generateServerTypes(nitro, { silent: true })
+*       await nitro.hooks.callHook('dev:reload')
+*     },
+*     onClientChange: async () => {
+*       await generateClientTypes(nitro, { silent: true })
+*     },
+*   }
+* )
+*
+* // In CLI
+* const watcher = createCoreWatcher(
+*   { watchDirs, serverDir: ctx.config.serverDir },
+*   {
+*     onServerChange: async () => {
+*       await generateAll(ctx, { silent: true })
+*       await reloadHandler()
+*     },
+*     onClientChange: async () => {
+*       await generateClient(ctx, { silent: true })
+*     },
+*   }
+* )
+* ```
+*/
+function createCoreWatcher(config, callbacks) {
+	const { watchDirs, serverDir, debounceMs = 150, persistent = true, ignoreInitial = true, usePolling } = config;
+	const shouldUsePolling = usePolling ?? (process.env.CI === "true" || process.env.VITE_TEST === "true");
+	const watcher = watch(watchDirs, {
+		persistent,
+		ignoreInitial,
+		ignored: createIgnoredFunction(),
+		usePolling: shouldUsePolling,
+		interval: shouldUsePolling ? 100 : void 0,
+		awaitWriteFinish: shouldUsePolling ? {
+			stabilityThreshold: 100,
+			pollInterval: 50
+		} : false
+	});
+	const pending = {
+		server: false,
+		client: false
+	};
+	async function processChanges() {
+		const changes = { ...pending };
+		pending.server = pending.client = false;
+		try {
+			if (changes.server) await callbacks.onServerChange();
+			else if (changes.client) await callbacks.onClientChange();
+		} catch (error) {
+			callbacks.onError?.(error);
+		}
+	}
+	const debouncedProcess = debounce(processChanges, debounceMs);
+	watcher.on("all", (_, path) => {
+		if (shouldSkipPath(path)) return;
+		const changeType = classifyChange(path, serverDir);
+		if (!changeType) return;
+		if (changeType === "server") pending.server = true;
+		else pending.client = true;
+		debouncedProcess();
+	});
+	if (callbacks.onReady) watcher.on("ready", callbacks.onReady);
+	if (callbacks.onError) watcher.on("error", callbacks.onError);
+	return watcher;
+}
+/**
+* Close a watcher safely
+*/
+async function closeWatcher(watcher) {
+	await watcher.close();
+}
+
+//#endregion
+export { classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };