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

package/dist/cli/server/debug-handler.d.mts

@@ -0,0 +1,9 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/server/debug-handler.d.ts
+/**
+ * Create a debug handler for the CLI dev server
+ */
+declare function createDebugHandler(ctx: CLIContext): (request: Request) => Promise<Response>;
+//#endregion
+export { createDebugHandler };

package/dist/cli/server/debug-handler.mjs

@@ -0,0 +1,68 @@
+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 { CLIAdapter } from "../adapter.mjs";
+import { generateDebugHtml } from "../../core/debug/template.mjs";
+//#region src/cli/server/debug-handler.ts
+/**
+* Create a debug handler for the CLI dev server
+*/
+function createDebugHandler(ctx) {
+	return async (request) => {
+		const debugInfo = await collectDebugInfo(ctx);
+		if (new URL(request.url).searchParams.get("format") === "json") return Response.json(debugInfo);
+		return new Response(generateDebugHtml(debugInfo), { headers: { "Content-Type": "text/html" } });
+	};
+}
+/**
+* Collect debug information from CLI context
+*/
+async function collectDebugInfo(ctx) {
+	const scanCtx = CLIAdapter.createScanContext(ctx);
+	const [schemasResult, resolversResult, directivesResult, documentsResult] = await Promise.all([
+		scanSchemasCore(scanCtx),
+		scanResolversCore(scanCtx),
+		scanDirectivesCore(scanCtx),
+		scanDocumentsCore(scanCtx, { externalServices: ctx.config.externalServices })
+	]);
+	const resolverFiles = resolversResult.items.map((r) => {
+		return {
+			file: r.specifier.split("/").at(-1) || r.specifier,
+			exports: r.imports.map((i) => ({
+				name: i.name,
+				type: i.type
+			}))
+		};
+	});
+	const schemaFiles = schemasResult.items.map((s) => {
+		return s.split("/").slice(-3).join("/");
+	});
+	const documentFiles = documentsResult.items.map((d) => {
+		return d.split("/").slice(-3).join("/");
+	});
+	return {
+		environment: {
+			dev: true,
+			framework: "cli"
+		},
+		graphql: { framework: ctx.config.framework || "graphql-yoga" },
+		scanned: {
+			schemas: schemasResult.items.length,
+			resolvers: resolversResult.items.length,
+			directives: directivesResult.items.length,
+			documents: documentsResult.items.length,
+			schemaFiles,
+			resolverFiles,
+			documentFiles
+		},
+		runtime: {
+			loadedResolvers: resolversResult.items.length,
+			loadedSchemas: schemasResult.items.length,
+			loadedDirectives: directivesResult.items.length
+		},
+		virtualModules: { "cli-config": JSON.stringify(ctx.config, null, 2) }
+	};
+}
+//#endregion
+export { createDebugHandler };

package/dist/cli/server/dev-server.d.mts

@@ -0,0 +1,29 @@
+import { CLIContext } from "../index.mjs";
+import { serve } from "srvx";
+
+//#region src/cli/server/dev-server.d.ts
+interface DevServerOptions {
+  /** Server port (default: 4000) */
+  port?: number;
+  /** Server hostname (default: localhost) */
+  hostname?: string;
+  /** Open browser after start */
+  open?: boolean;
+}
+interface DevServerInstance {
+  /** The srvx server instance */
+  server: ReturnType<typeof serve>;
+  /** Reload the GraphQL schema (for hot reload) */
+  reload: () => Promise<void>;
+  /** Stop the server */
+  close: () => Promise<void>;
+}
+/**
+ * Start the CLI development server
+ *
+ * Uses srvx for runtime-agnostic HTTP server.
+ * GraphQL handled by the same core factory that Nitro uses.
+ */
+declare function startDevServer(ctx: CLIContext, options?: DevServerOptions): Promise<DevServerInstance>;
+//#endregion
+export { DevServerInstance, DevServerOptions, startDevServer };

package/dist/cli/server/dev-server.mjs

@@ -0,0 +1,62 @@
+import { createDebugHandler } from "./debug-handler.mjs";
+import { createGraphQLHandler, getServerInstance, reloadGraphQLHandler } from "./graphql-handler.mjs";
+import { createHealthHandler } from "./health-handler.mjs";
+import { createSandboxHandler } from "./sandbox-handler.mjs";
+import { createWebSocketPlugin } from "./ws-handler.mjs";
+import consola from "consola";
+import { plugin } from "crossws/server";
+import { serve } from "srvx";
+//#region src/cli/server/dev-server.ts
+const logger = consola.withTag("nitro-graphql");
+/**
+* Start the CLI development server
+*
+* Uses srvx for runtime-agnostic HTTP server.
+* GraphQL handled by the same core factory that Nitro uses.
+*/
+async function startDevServer(ctx, options = {}) {
+	const port = options.port || 4e3;
+	const hostname = options.hostname || "localhost";
+	const endpoint = ctx.config.endpoint?.graphql || "/graphql";
+	logger.info("Starting GraphQL dev server...");
+	let graphqlHandler = await createGraphQLHandler(ctx);
+	const healthHandler = createHealthHandler();
+	const sandboxHandler = createSandboxHandler();
+	const debugHandler = createDebugHandler(ctx);
+	const server = serve({
+		port,
+		hostname,
+		plugins: [plugin(createWebSocketPlugin(() => {
+			const instance = getServerInstance();
+			if (!instance) throw new Error("GraphQL server not initialized");
+			return instance.schema;
+		}))],
+		async fetch(request) {
+			const path = new URL(request.url).pathname;
+			if (path === endpoint || path === "/api/graphql") return graphqlHandler(request);
+			if (path === "/api/graphql/sandbox.js" || path === `${endpoint}/sandbox.js`) return sandboxHandler(request);
+			if (path === "/health" || path === "/api/graphql/health") return healthHandler(request);
+			if (path === "/_nitro/graphql/debug") return debugHandler(request);
+			return new Response("Not Found", { status: 404 });
+		}
+	});
+	await server.ready();
+	logger.success(`GraphQL server running at http://${hostname}:${port}${endpoint}`);
+	logger.info(`Health check at http://${hostname}:${port}/health`);
+	logger.info(`Debug dashboard at http://${hostname}:${port}/_nitro/graphql/debug`);
+	return {
+		server,
+		async reload() {
+			logger.info("Reloading GraphQL schema...");
+			graphqlHandler = await reloadGraphQLHandler(ctx);
+			logger.success("Schema reloaded!");
+		},
+		async close() {
+			logger.info("Shutting down server...");
+			await server.close();
+			logger.success("Server stopped");
+		}
+	};
+}
+//#endregion
+export { startDevServer };

package/dist/cli/server/graphql-handler.d.mts

@@ -0,0 +1,21 @@
+import { CLIContext } from "../index.mjs";
+import { CoreServerInstance } from "../../core/server/types.mjs";
+
+//#region src/cli/server/graphql-handler.d.ts
+/**
+ * Create the GraphQL request handler
+ *
+ * Uses the same createYogaServer() from core that Nitro uses,
+ * ensuring 100% consistent behavior between CLI and Nitro module.
+ */
+declare function createGraphQLHandler(ctx: CLIContext): Promise<(request: Request) => Promise<Response>>;
+/**
+ * Reload the GraphQL handler (for hot reload)
+ */
+declare function reloadGraphQLHandler(ctx: CLIContext): Promise<(request: Request) => Promise<Response>>;
+/**
+ * Get the current server instance (for WebSocket setup, etc.)
+ */
+declare function getServerInstance(): CoreServerInstance | null;
+//#endregion
+export { createGraphQLHandler, getServerInstance, reloadGraphQLHandler };

package/dist/cli/server/graphql-handler.mjs

@@ -0,0 +1,43 @@
+import { BASE_SCHEMA, createYogaServer } from "../../core/server/yoga.mjs";
+import { loadDirectiveDefinitions, loadResolverDefinitions, loadSchemaDefinitions } from "./loader.mjs";
+import consola from "consola";
+//#region src/cli/server/graphql-handler.ts
+const logger = consola.withTag("nitro-graphql");
+let serverInstance = null;
+/**
+* Create the GraphQL request handler
+*
+* Uses the same createYogaServer() from core that Nitro uses,
+* ensuring 100% consistent behavior between CLI and Nitro module.
+*/
+async function createGraphQLHandler(ctx) {
+	const loadedSchemas = await loadSchemaDefinitions(ctx);
+	const resolvers = await loadResolverDefinitions(ctx);
+	const directives = await loadDirectiveDefinitions(ctx);
+	const schemas = [BASE_SCHEMA, ...loadedSchemas];
+	serverInstance = await createYogaServer({
+		schemas,
+		resolvers,
+		directives,
+		moduleConfig: { federation: ctx.config.federation },
+		endpoint: ctx.config.endpoint?.graphql || "/graphql",
+		security: ctx.config.security
+	});
+	logger.success(`GraphQL server created with ${schemas.length} schema(s) and ${resolvers.length} resolver(s)`);
+	return (request) => serverInstance.fetch(request);
+}
+/**
+* Reload the GraphQL handler (for hot reload)
+*/
+async function reloadGraphQLHandler(ctx) {
+	serverInstance = null;
+	return createGraphQLHandler(ctx);
+}
+/**
+* Get the current server instance (for WebSocket setup, etc.)
+*/
+function getServerInstance() {
+	return serverInstance;
+}
+//#endregion
+export { createGraphQLHandler, getServerInstance, reloadGraphQLHandler };

package/dist/cli/server/health-handler.d.mts

@@ -0,0 +1,12 @@
+//#region src/cli/server/health-handler.d.ts
+/**
+ * CLI Health Handler
+ *
+ * Simple health check endpoint for the CLI dev server.
+ */
+/**
+ * Create a health check handler
+ */
+declare function createHealthHandler(): (request: Request) => Response;
+//#endregion
+export { createHealthHandler };

package/dist/cli/server/health-handler.mjs

@@ -0,0 +1,29 @@
+//#region src/cli/server/health-handler.ts
+/**
+* CLI Health Handler
+*
+* Simple health check endpoint for the CLI dev server.
+*/
+/**
+* Create a health check handler
+*/
+function createHealthHandler() {
+	return (_request) => {
+		return Response.json({
+			status: "ok",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			runtime: detectRuntime()
+		});
+	};
+}
+/**
+* Detect the current JavaScript runtime
+*/
+function detectRuntime() {
+	if (typeof Bun !== "undefined") return "bun";
+	if (typeof Deno !== "undefined") return "deno";
+	if (typeof process !== "undefined" && process.versions?.node) return `node/${process.versions.node}`;
+	return "unknown";
+}
+//#endregion
+export { createHealthHandler };

package/dist/cli/server/loader.d.mts

@@ -0,0 +1,33 @@
+import { CLIContext } from "../index.mjs";
+import { DirectiveWrapper, ResolverDefinition, SchemaDefinition } from "../../core/schema/builder.mjs";
+
+//#region src/cli/server/loader.d.ts
+/**
+ * Clear extend cache (for hot reload)
+ */
+declare function clearExtendCache(): void;
+/**
+ * Load schema definitions from GraphQL files
+ * Includes schemas from extend sources
+ */
+declare function loadSchemaDefinitions(ctx: CLIContext): Promise<SchemaDefinition[]>;
+/**
+ * Load resolver definitions by dynamically importing resolver modules
+ * Includes resolvers from extend sources
+ */
+declare function loadResolverDefinitions(ctx: CLIContext): Promise<ResolverDefinition[]>;
+/**
+ * Load directive definitions by dynamically importing directive modules
+ * Includes directives from extend sources
+ */
+declare function loadDirectiveDefinitions(ctx: CLIContext): Promise<DirectiveWrapper[]>;
+/**
+ * Load all GraphQL components (schemas, resolvers, directives)
+ */
+declare function loadAllComponents(ctx: CLIContext): Promise<{
+  schemas: SchemaDefinition[];
+  resolvers: ResolverDefinition[];
+  directives: DirectiveWrapper[];
+}>;
+//#endregion
+export { clearExtendCache, loadAllComponents, loadDirectiveDefinitions, loadResolverDefinitions, loadSchemaDefinitions };

package/dist/cli/server/loader.mjs

@@ -0,0 +1,144 @@
+import { scanDirectivesCore } from "../../core/scanning/directives.mjs";
+import { scanResolversCore } from "../../core/scanning/resolvers.mjs";
+import { scanSchemasCore } from "../../core/scanning/schemas.mjs";
+import { pathToFileURL, readFileSync_ } from "../../core/utils/runtime.mjs";
+import { scanAllExtendSources } from "../../core/extend/loader.mjs";
+import { CLIAdapter } from "../adapter.mjs";
+import consola from "consola";
+//#region src/cli/server/loader.ts
+const logger = consola.withTag("nitro-graphql");
+let cachedExtendResult = null;
+/**
+* Get extend scan result (cached)
+*/
+async function getExtendResult(ctx) {
+	if (!cachedExtendResult) cachedExtendResult = await scanAllExtendSources(ctx.config.extend, ctx.config.rootDir);
+	return cachedExtendResult;
+}
+/**
+* Clear extend cache (for hot reload)
+*/
+function clearExtendCache() {
+	cachedExtendResult = null;
+}
+/**
+* Load schema definitions from GraphQL files
+* Includes schemas from extend sources
+*/
+async function loadSchemaDefinitions(ctx) {
+	const result = await scanSchemasCore(CLIAdapter.createScanContext(ctx));
+	const extendResult = await getExtendResult(ctx);
+	const allSchemas = [...result.items, ...extendResult.schemas];
+	if (allSchemas.length === 0) {
+		logger.warn("No GraphQL schema files found");
+		return [];
+	}
+	logger.debug(`Found ${allSchemas.length} schema file(s)`);
+	return allSchemas.map((schemaPath) => ({ def: readFileSync_(schemaPath) }));
+}
+/**
+* Load resolver from a scanned item
+*/
+async function loadResolverFromItem(item) {
+	const filePath = item.specifier;
+	if (!filePath) {
+		logger.warn("Resolver item has no specifier, skipping");
+		return [];
+	}
+	const resolvers = [];
+	try {
+		const module = await import(`${pathToFileURL(filePath).href}?t=${Date.now()}`);
+		for (const imp of item.imports) {
+			const exported = module[imp.name];
+			if (exported && typeof exported === "object") {
+				resolvers.push({ resolver: exported });
+				logger.debug(`Loaded resolver: ${imp.name} from ${filePath}`);
+			}
+		}
+	} catch (error) {
+		logger.error(`Failed to load resolver from ${filePath}:`, error);
+	}
+	return resolvers;
+}
+/**
+* Load resolver definitions by dynamically importing resolver modules
+* Includes resolvers from extend sources
+*/
+async function loadResolverDefinitions(ctx) {
+	const result = await scanResolversCore(CLIAdapter.createScanContext(ctx));
+	const extendResult = await getExtendResult(ctx);
+	const allItems = [...result.items, ...extendResult.resolvers];
+	if (allItems.length === 0) {
+		logger.warn("No resolver files found");
+		return [];
+	}
+	logger.debug(`Found ${allItems.length} resolver file(s)`);
+	const resolvers = [];
+	for (const item of allItems) {
+		const loaded = await loadResolverFromItem(item);
+		resolvers.push(...loaded);
+	}
+	return resolvers;
+}
+/**
+* Load directive from a scanned item
+*/
+async function loadDirectiveFromItem(item) {
+	const filePath = item.specifier;
+	if (!filePath) {
+		logger.warn("Directive item has no specifier, skipping");
+		return [];
+	}
+	const directives = [];
+	try {
+		const module = await import(`${pathToFileURL(filePath).href}?t=${Date.now()}`);
+		for (const imp of item.imports) {
+			const exported = module[imp.name];
+			if (exported && typeof exported === "object") {
+				directives.push({ directive: exported });
+				logger.debug(`Loaded directive: ${imp.name} from ${filePath}`);
+			}
+		}
+	} catch (error) {
+		logger.error(`Failed to load directive from ${filePath}:`, error);
+	}
+	return directives;
+}
+/**
+* Load directive definitions by dynamically importing directive modules
+* Includes directives from extend sources
+*/
+async function loadDirectiveDefinitions(ctx) {
+	const result = await scanDirectivesCore(CLIAdapter.createScanContext(ctx));
+	const extendResult = await getExtendResult(ctx);
+	const allItems = [...result.items, ...extendResult.directives];
+	if (allItems.length === 0) {
+		logger.debug("No directive files found");
+		return [];
+	}
+	logger.debug(`Found ${allItems.length} directive file(s)`);
+	const directives = [];
+	for (const item of allItems) {
+		const loaded = await loadDirectiveFromItem(item);
+		directives.push(...loaded);
+	}
+	return directives;
+}
+/**
+* Load all GraphQL components (schemas, resolvers, directives)
+*/
+async function loadAllComponents(ctx) {
+	clearExtendCache();
+	const [schemas, resolvers, directives] = await Promise.all([
+		loadSchemaDefinitions(ctx),
+		loadResolverDefinitions(ctx),
+		loadDirectiveDefinitions(ctx)
+	]);
+	return {
+		schemas,
+		resolvers,
+		directives
+	};
+}
+//#endregion
+export { clearExtendCache, loadAllComponents, loadDirectiveDefinitions, loadResolverDefinitions, loadSchemaDefinitions };

package/dist/cli/server/sandbox-handler.d.mts

@@ -0,0 +1,12 @@
+//#region src/cli/server/sandbox-handler.d.ts
+/**
+ * CLI Sandbox Script Handler
+ *
+ * Uses core sandbox handler.
+ */
+/**
+ * Create a handler that serves the Apollo Sandbox script
+ */
+declare function createSandboxHandler(): (request: Request) => Promise<Response>;
+//#endregion
+export { createSandboxHandler };

package/dist/cli/server/sandbox-handler.mjs

@@ -0,0 +1,17 @@
+import { createSandboxResponse } from "../../core/server/sandbox.mjs";
+//#region src/cli/server/sandbox-handler.ts
+/**
+* CLI Sandbox Script Handler
+*
+* Uses core sandbox handler.
+*/
+/**
+* Create a handler that serves the Apollo Sandbox script
+*/
+function createSandboxHandler() {
+	return async (_request) => {
+		return createSandboxResponse();
+	};
+}
+//#endregion
+export { createSandboxHandler };

package/dist/cli/server/watcher.d.mts

@@ -0,0 +1,20 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/server/watcher.d.ts
+interface WatcherInstance {
+  /** Close the watcher */
+  close: () => Promise<void>;
+}
+/**
+ * Create a file watcher for the dev server
+ *
+ * Uses core watcher module with CLI-specific callbacks.
+ * Watches for changes in:
+ * - GraphQL schema files (*.graphql)
+ * - Resolver files (*.resolver.ts)
+ * - Directive files (*.directive.ts)
+ * - Client documents (*.graphql in client dir)
+ */
+declare function createDevWatcher(ctx: CLIContext, onReload: () => Promise<void>): WatcherInstance;
+//#endregion
+export { WatcherInstance, createDevWatcher };

package/dist/cli/server/watcher.mjs

@@ -0,0 +1,64 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import { closeWatcher, createCoreWatcher } from "../../core/watcher/index.mjs";
+import { generateAll } from "../commands/generate.mjs";
+import consola from "consola";
+//#region src/cli/server/watcher.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Create a file watcher for the dev server
+*
+* Uses core watcher module with CLI-specific callbacks.
+* Watches for changes in:
+* - GraphQL schema files (*.graphql)
+* - Resolver files (*.resolver.ts)
+* - Directive files (*.directive.ts)
+* - Client documents (*.graphql in client dir)
+*/
+function createDevWatcher(ctx, onReload) {
+	const serverDir = ctx.config.serverDir;
+	const clientDir = ctx.config.clientDir;
+	const watchDirs = [serverDir];
+	if (clientDir !== serverDir) watchDirs.push(clientDir);
+	logger.info("Watching for changes in:", watchDirs.join(", "));
+	const watcher = createCoreWatcher({
+		watchDirs,
+		serverDir,
+		debounceMs: 150
+	}, {
+		onServerChange: async () => {
+			logger.info("Server files changed, regenerating...");
+			try {
+				await generateAll(ctx, {
+					silent: true,
+					runtime: false
+				});
+				await onReload();
+			} catch (error) {
+				logger.error("Hot reload failed:", error);
+			}
+		},
+		onClientChange: async () => {
+			logger.info("Client files changed, regenerating...");
+			try {
+				await generateAll(ctx, {
+					silent: true,
+					runtime: false
+				});
+			} catch (error) {
+				logger.error("Client type generation failed:", error);
+			}
+		},
+		onReady: () => {
+			logger.success("File watcher ready");
+		},
+		onError: (error) => {
+			logger.error("Watcher error:", error);
+		}
+	});
+	return { async close() {
+		await closeWatcher(watcher);
+		logger.debug("File watcher closed");
+	} };
+}
+//#endregion
+export { createDevWatcher };

package/dist/cli/server/ws-handler.d.mts

@@ -0,0 +1,28 @@
+import { GraphQLSchema } from "graphql";
+import { Hooks } from "crossws";
+
+//#region src/cli/server/ws-handler.d.ts
+/**
+ * Create WebSocket hooks for GraphQL subscriptions
+ *
+ * @param getSchema - Function to get the GraphQL schema
+ * @param context - Optional context to pass to resolvers
+ */
+declare function createGraphQLWebSocketHooks(getSchema: () => Promise<GraphQLSchema> | GraphQLSchema, context?: Record<string, unknown>): Partial<Hooks>;
+/**
+ * Create crossws plugin configuration for srvx
+ *
+ * @example
+ * ```typescript
+ * import { plugin as ws } from 'crossws/server'
+ * import { createWebSocketPlugin } from './ws-handler'
+ *
+ * const server = serve({
+ *   plugins: [ws(createWebSocketPlugin(getSchema))],
+ *   fetch(req) { ... }
+ * })
+ * ```
+ */
+declare function createWebSocketPlugin(getSchema: () => Promise<GraphQLSchema> | GraphQLSchema, context?: Record<string, unknown>): Partial<Hooks>;
+//#endregion
+export { createGraphQLWebSocketHooks, createWebSocketPlugin };

package/dist/cli/server/ws-handler.mjs

@@ -0,0 +1,48 @@
+import { handleProtocols } from "graphql-ws";
+import { makeHooks } from "graphql-ws/use/crossws";
+//#region src/cli/server/ws-handler.ts
+/**
+* Create WebSocket hooks for GraphQL subscriptions
+*
+* @param getSchema - Function to get the GraphQL schema
+* @param context - Optional context to pass to resolvers
+*/
+function createGraphQLWebSocketHooks(getSchema, context) {
+	return {
+		upgrade(request) {
+			const selected = handleProtocols(request.headers.get("sec-websocket-protocol") || "");
+			if (selected) return { headers: { "Sec-WebSocket-Protocol": selected } };
+			return {};
+		},
+		...makeHooks({
+			schema: getSchema,
+			context: async (ctx) => {
+				const baseContext = { connectionParams: ctx.connectionParams };
+				if (context) return {
+					...baseContext,
+					...context
+				};
+				return baseContext;
+			}
+		})
+	};
+}
+/**
+* Create crossws plugin configuration for srvx
+*
+* @example
+* ```typescript
+* import { plugin as ws } from 'crossws/server'
+* import { createWebSocketPlugin } from './ws-handler'
+*
+* const server = serve({
+*   plugins: [ws(createWebSocketPlugin(getSchema))],
+*   fetch(req) { ... }
+* })
+* ```
+*/
+function createWebSocketPlugin(getSchema, context) {
+	return createGraphQLWebSocketHooks(getSchema, context);
+}
+//#endregion
+export { createGraphQLWebSocketHooks, createWebSocketPlugin };

package/dist/config.d.mts

@@ -0,0 +1,2 @@
+import { CLIConfig, DEFAULT_CLI_CONFIG, defineConfig } from "./cli/config.mjs";
+export { type CLIConfig, DEFAULT_CLI_CONFIG, defineConfig };

package/dist/config.mjs

@@ -0,0 +1,2 @@
+import { DEFAULT_CLI_CONFIG, defineConfig } from "./cli/config.mjs";
+export { DEFAULT_CLI_CONFIG, defineConfig };