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

package/dist/cli/adapter.d.mts

@@ -0,0 +1,13 @@
+import { FrameworkAdapter } from "../core/types/adapter.mjs";
+import { CLIContext } from "./index.mjs";
+
+//#region src/cli/adapter.d.ts
+/**
+ * CLI Framework Adapter
+ *
+ * Enables the CLI to use the same core functions as the Nitro module.
+ * The adapter converts CLIContext to the types expected by core functions.
+ */
+declare const CLIAdapter: FrameworkAdapter<CLIContext>;
+//#endregion
+export { CLIAdapter };

package/dist/cli/adapter.mjs

@@ -0,0 +1,69 @@
+import { LOG_TAG } from "../core/constants.mjs";
+import { createCoreConfig, createCoreContext, createScanContext } from "../core/config.mjs";
+import consola from "consola";
+
+//#region src/cli/adapter.ts
+/**
+* Create a CoreLogger from consola for CLI usage
+*/
+function createCLILogger() {
+	const logger = consola.withTag(LOG_TAG);
+	return {
+		info: (...args) => logger.info(...args),
+		warn: (...args) => logger.warn(...args),
+		error: (...args) => logger.error(...args),
+		debug: (...args) => logger.debug(...args),
+		success: (...args) => logger.success(...args)
+	};
+}
+/**
+* CLI Framework Adapter
+*
+* Enables the CLI to use the same core functions as the Nitro module.
+* The adapter converts CLIContext to the types expected by core functions.
+*/
+const CLIAdapter = {
+	name: "cli",
+	createCoreConfig: (ctx) => {
+		return createCoreConfig({
+			rootDir: ctx.config.rootDir,
+			buildDir: ctx.config.buildDir,
+			serverDir: ctx.config.serverDir,
+			clientDir: ctx.config.clientDir,
+			isNuxt: false,
+			isDev: true,
+			graphqlOptions: {
+				framework: ctx.config.framework,
+				endpoint: ctx.config.endpoint?.graphql,
+				security: ctx.config.security,
+				federation: ctx.config.federation,
+				externalServices: ctx.config.externalServices?.map((s) => ({
+					name: s.name,
+					endpoint: s.endpoint,
+					schema: (Array.isArray(s.schema) ? s.schema[0] : s.schema) || s.endpoint,
+					headers: s.headers,
+					documents: s.documents,
+					paths: s.paths ? {
+						sdk: typeof s.paths.sdk === "string" ? s.paths.sdk : void 0,
+						types: typeof s.paths.types === "string" ? s.paths.types : void 0
+					} : void 0
+				})),
+				codegen: ctx.config.codegen
+			},
+			logger: createCLILogger(),
+			ignorePatterns: ctx.config.ignore || []
+		});
+	},
+	createCoreContext: (ctx) => {
+		return createCoreContext(CLIAdapter.createCoreConfig(ctx));
+	},
+	createScanContext: (ctx) => {
+		return createScanContext(CLIAdapter.createCoreConfig(ctx));
+	},
+	getLogger: () => {
+		return createCLILogger();
+	}
+};
+
+//#endregion
+export { CLIAdapter };

package/dist/cli/commands/build.d.mts

@@ -0,0 +1,21 @@
+import * as citty0 from "citty";
+
+//#region src/cli/commands/build.d.ts
+/**
+ * CLI Build Command
+ *
+ * Builds GraphQL types and validates schemas for production.
+ */
+declare const buildCommand: citty0.CommandDef<{
+  readonly cwd: {
+    readonly type: "string";
+    readonly description: "Working directory";
+  };
+  readonly skipValidation: {
+    readonly type: "boolean";
+    readonly description: "Skip schema validation";
+    readonly default: false;
+  };
+}>;
+//#endregion
+export { buildCommand };

package/dist/cli/commands/build.mjs

@@ -0,0 +1,52 @@
+import { createCLIContext } from "../index.mjs";
+import { generateAll } from "./generate.mjs";
+import { validate } from "./validate.mjs";
+import consola from "consola";
+import { defineCommand } from "citty";
+
+//#region src/cli/commands/build.ts
+/**
+* CLI Build Command
+*
+* Builds GraphQL types and validates schemas for production.
+*/
+const logger = consola.withTag("nitro-graphql");
+const buildCommand = defineCommand({
+	meta: {
+		name: "build",
+		description: "Build GraphQL types for production"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Working directory"
+		},
+		skipValidation: {
+			type: "boolean",
+			description: "Skip schema validation",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		logger.info("Building GraphQL for production...");
+		if (!args.skipValidation) {
+			logger.info("Validating schemas...");
+			if (!await validate(ctx)) {
+				logger.error("Schema validation failed!");
+				process.exit(1);
+			}
+			logger.success("Schema validation passed");
+		}
+		logger.info("Generating types...");
+		await generateAll(ctx, {
+			silent: false,
+			runtime: true
+		});
+		logger.success("Build complete!");
+		logger.info(`Output: ${ctx.config.buildDir}`);
+	}
+});
+
+//#endregion
+export { buildCommand };

package/dist/cli/commands/dev.d.mts

@@ -0,0 +1,40 @@
+import * as citty0 from "citty";
+
+//#region src/cli/commands/dev.d.ts
+/**
+ * Dev Command
+ *
+ * Starts the GraphQL development server with hot reload.
+ * Runtime-agnostic: works on Node.js, Bun, and Deno.
+ */
+declare const devCommand: citty0.CommandDef<{
+  readonly cwd: {
+    readonly type: "string";
+    readonly description: "Working directory";
+  };
+  readonly port: {
+    readonly type: "string";
+    readonly alias: "p";
+    readonly default: "4000";
+    readonly description: "Server port";
+  };
+  readonly host: {
+    readonly type: "string";
+    readonly alias: "H";
+    readonly default: "localhost";
+    readonly description: "Server host";
+  };
+  readonly open: {
+    readonly type: "boolean";
+    readonly alias: "o";
+    readonly description: "Open browser";
+  };
+  readonly watch: {
+    readonly type: "boolean";
+    readonly alias: "w";
+    readonly default: true;
+    readonly description: "Enable file watching for hot reload";
+  };
+}>;
+//#endregion
+export { devCommand };

package/dist/cli/commands/dev.mjs

@@ -0,0 +1,76 @@
+import { exit, onSignal } from "../../core/utils/runtime.mjs";
+import { createCLIContext } from "../index.mjs";
+import { startDevServer } from "../server/dev-server.mjs";
+import { createDevWatcher } from "../server/watcher.mjs";
+import consola from "consola";
+import { defineCommand } from "citty";
+
+//#region src/cli/commands/dev.ts
+/**
+* Dev Command
+*
+* Starts the GraphQL development server with hot reload.
+* Runtime-agnostic: works on Node.js, Bun, and Deno.
+*/
+const logger = consola.withTag("nitro-graphql");
+const devCommand = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Start GraphQL development server"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Working directory"
+		},
+		port: {
+			type: "string",
+			alias: "p",
+			default: "4000",
+			description: "Server port"
+		},
+		host: {
+			type: "string",
+			alias: "H",
+			default: "localhost",
+			description: "Server host"
+		},
+		open: {
+			type: "boolean",
+			alias: "o",
+			description: "Open browser"
+		},
+		watch: {
+			type: "boolean",
+			alias: "w",
+			default: true,
+			description: "Enable file watching for hot reload"
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		const serverInstance = await startDevServer(ctx, {
+			port: Number.parseInt(args.port),
+			hostname: args.host,
+			open: args.open
+		});
+		let watcher = null;
+		if (args.watch) {
+			watcher = createDevWatcher(ctx, async () => {
+				await serverInstance.reload();
+			});
+			logger.info("File watching enabled - changes will trigger hot reload");
+		}
+		const shutdown = async () => {
+			logger.info("Shutting down...");
+			if (watcher) await watcher.close();
+			await serverInstance.close();
+			exit(0);
+		};
+		onSignal("SIGINT", shutdown);
+		onSignal("SIGTERM", shutdown);
+	}
+});
+
+//#endregion
+export { devCommand };

package/dist/cli/commands/generate.d.mts

@@ -0,0 +1,25 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/commands/generate.d.ts
+/**
+ * Generate all types (server + client + optional runtime)
+ */
+declare function generateAll(ctx: CLIContext, options?: {
+  silent?: boolean;
+  watch?: boolean;
+  runtime?: boolean;
+}): Promise<void>;
+/**
+ * Generate server types
+ */
+declare function generateServer(ctx: CLIContext, options?: {
+  silent?: boolean;
+}): Promise<void>;
+/**
+ * Generate client types
+ */
+declare function generateClient(ctx: CLIContext, options?: {
+  silent?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateAll, generateClient, generateServer };

package/dist/cli/commands/generate.mjs

@@ -0,0 +1,198 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import { loadGraphQLDocuments } from "../../core/codegen/document-loader.mjs";
+import { generateClientTypesCore } from "../../core/codegen/client.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "../../core/codegen/runtime.mjs";
+import { generateServerTypesCore } from "../../core/codegen/server.mjs";
+import { scanDocumentsCore } from "../../core/scanning/documents.mjs";
+import { scanResolversCore } from "../../core/scanning/resolvers.mjs";
+import { scanSchemasCore } from "../../core/scanning/schemas.mjs";
+import { buildGraphQLSchema } from "../../core/schema/builder.mjs";
+import { existsSync_, mkdirSync_, onSignal, readFileSync_, writeFileSync_ } from "../../core/utils/runtime.mjs";
+import consola from "consola";
+import { dirname, join, relative, resolve as resolve$1 } from "pathe";
+
+//#region src/cli/commands/generate.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Create ScanContext from CLI context
+*/
+function createScanContext(ctx) {
+	return {
+		rootDir: ctx.config.rootDir,
+		serverDir: ctx.config.serverDir,
+		clientDir: ctx.config.clientDir,
+		ignorePatterns: ctx.config.ignore,
+		isDev: false,
+		logger: {
+			info: (msg, ...args) => logger.info(msg, ...args),
+			warn: (msg, ...args) => logger.warn(msg, ...args),
+			error: (msg, ...args) => logger.error(msg, ...args),
+			success: (msg, ...args) => logger.success(msg, ...args),
+			debug: (msg, ...args) => logger.debug(msg, ...args)
+		}
+	};
+}
+/**
+* Generate all types (server + client + optional runtime)
+*/
+async function generateAll(ctx, options = {}) {
+	await generateServer(ctx, options);
+	await generateClient(ctx, options);
+	if (options.runtime) await generateRuntimeFiles(ctx, options);
+	if (options.watch) await watchAndRegenerate(ctx, options);
+}
+/**
+* Generate server types
+*/
+async function generateServer(ctx, options = {}) {
+	const schemaResult = await scanSchemasCore(createScanContext(ctx));
+	if (schemaResult.errors.length > 0) for (const error of schemaResult.errors) logger.error(error);
+	if (schemaResult.items.length === 0) {
+		if (!options.silent) logger.info("No GraphQL schemas found in server directory");
+		return;
+	}
+	const schema = await buildGraphQLSchema(schemaResult.items);
+	if (!schema) {
+		logger.error("Failed to build GraphQL schema");
+		return;
+	}
+	const result = await generateServerTypesCore({
+		framework: ctx.config.framework,
+		schema,
+		config: ctx.config.codegen?.server,
+		federationEnabled: ctx.config.federation?.enabled
+	});
+	const schemaPath = join(ctx.config.buildDir, "schema.graphql");
+	mkdirSync_(dirname(schemaPath));
+	writeFileSync_(schemaPath, result.schemaString);
+	const typesConfig = ctx.config.types;
+	let typesPath;
+	if (typesConfig && typeof typesConfig === "object" && typeof typesConfig.server === "string") typesPath = resolve$1(ctx.config.rootDir, typesConfig.server);
+	else typesPath = join(ctx.config.typesDir, "nitro-graphql-server.d.ts");
+	mkdirSync_(dirname(typesPath));
+	writeFileSync_(typesPath, result.types);
+	if (!options.silent) logger.success(`Generated server types: ${relative(ctx.config.rootDir, typesPath)}`);
+}
+/**
+* Generate client types
+*/
+async function generateClient(ctx, options = {}) {
+	const scanCtx = createScanContext(ctx);
+	const schemaPath = join(ctx.config.buildDir, "schema.graphql");
+	if (!existsSync_(schemaPath)) {
+		if (!options.silent) logger.info("Server schema not found. Generate server types first.");
+		return;
+	}
+	const docsResult = await scanDocumentsCore(scanCtx, { externalServices: ctx.config.externalServices });
+	if (docsResult.errors.length > 0) for (const error of docsResult.errors) logger.error(error);
+	if (docsResult.items.length === 0) {
+		if (!options.silent) logger.info("No GraphQL documents found in client directory");
+		return;
+	}
+	const documents = await loadGraphQLDocuments(docsResult.items);
+	const { buildSchema } = await import("graphql");
+	const result = await generateClientTypesCore({
+		schema: buildSchema(readFileSync_(schemaPath)),
+		documents,
+		config: ctx.config.codegen?.client,
+		sdkConfig: ctx.config.codegen?.clientSDK,
+		options: { silent: options.silent }
+	});
+	if (result === false) {
+		if (!options.silent) logger.warn("Client type generation skipped");
+		return;
+	}
+	const typesConfig = ctx.config.types;
+	let typesPath;
+	if (typesConfig && typeof typesConfig === "object" && typeof typesConfig.client === "string") typesPath = resolve$1(ctx.config.rootDir, typesConfig.client);
+	else typesPath = join(ctx.config.typesDir, "nitro-graphql-client.d.ts");
+	mkdirSync_(dirname(typesPath));
+	writeFileSync_(typesPath, result.types);
+	const sdkPath = join(ctx.config.clientDir, "default", "sdk.ts");
+	mkdirSync_(dirname(sdkPath));
+	writeFileSync_(sdkPath, result.sdk);
+	if (!options.silent) logger.success(`Generated client types: ${relative(ctx.config.rootDir, typesPath)}`);
+}
+/**
+* Generate runtime files (resolvers.ts, schema.ts, index.ts)
+*/
+async function generateRuntimeFiles(ctx, options = {}) {
+	const scanCtx = createScanContext(ctx);
+	const runtimeConfig = ctx.config.runtime;
+	const runtimeDir = typeof runtimeConfig === "object" && runtimeConfig.outDir ? join(ctx.config.rootDir, runtimeConfig.outDir) : join(ctx.config.buildDir, "runtime");
+	mkdirSync_(runtimeDir);
+	const include = typeof runtimeConfig === "object" && runtimeConfig.include ? runtimeConfig.include : {
+		resolvers: true,
+		schema: true,
+		index: true
+	};
+	if (include.resolvers !== false) {
+		const resolversResult = await scanResolversCore(scanCtx);
+		if (resolversResult.items.length > 0) {
+			const resolverCode = generateResolverModule(resolversResult.items, runtimeDir);
+			writeFileSync_(join(runtimeDir, "resolvers.ts"), resolverCode);
+			if (!options.silent) logger.success(`Generated runtime: ${relative(ctx.config.rootDir, join(runtimeDir, "resolvers.ts"))}`);
+		} else if (!options.silent) logger.info("No resolvers found for runtime generation");
+	}
+	if (include.schema !== false) {
+		const schemaPath = join(ctx.config.buildDir, "schema.graphql");
+		if (existsSync_(schemaPath)) {
+			const schemaCode = generateSchemaModule(readFileSync_(schemaPath));
+			writeFileSync_(join(runtimeDir, "schema.ts"), schemaCode);
+			if (!options.silent) logger.success(`Generated runtime: ${relative(ctx.config.rootDir, join(runtimeDir, "schema.ts"))}`);
+		} else if (!options.silent) logger.info("Schema not found for runtime generation. Run generate first.");
+	}
+	if (include.index !== false) {
+		const indexCode = generateRuntimeIndex();
+		writeFileSync_(join(runtimeDir, "index.ts"), indexCode);
+		if (!options.silent) logger.success(`Generated runtime: ${relative(ctx.config.rootDir, join(runtimeDir, "index.ts"))}`);
+	}
+}
+/**
+* Watch mode - regenerate on file changes
+*/
+async function watchAndRegenerate(ctx, options = {}) {
+	const { watch } = await import("chokidar");
+	const watchDirs = [ctx.config.serverDir, ctx.config.clientDir];
+	const watcher = watch(watchDirs, {
+		ignoreInitial: true,
+		ignored: [
+			...ctx.config.ignore || [],
+			/node_modules/,
+			/\.git/
+		],
+		persistent: true
+	});
+	await new Promise((resolve) => {
+		watcher.on("ready", resolve);
+		watcher.on("error", (error) => logger.error("Watcher error:", error));
+	});
+	const relPath = (p) => relative(ctx.config.rootDir, p) || ".";
+	logger.info(`Watching: ${watchDirs.map(relPath).join(", ")}`);
+	let debounceTimer = null;
+	const debounceMs = ctx.config.watch?.debounce ?? 300;
+	watcher.on("all", (event, filePath) => {
+		if (!filePath.endsWith(".graphql") && !filePath.endsWith(".resolver.ts")) return;
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(async () => {
+			try {
+				await generateAll(ctx, {
+					silent: options.silent ?? true,
+					watch: false
+				});
+				logger.success(`Types regenerated (${relPath(filePath)})`);
+			} catch (error) {
+				logger.error("Regeneration failed:", error);
+			}
+		}, debounceMs);
+	});
+	await new Promise((resolvePromise) => {
+		onSignal("SIGINT", () => {
+			watcher.close();
+			resolvePromise();
+		});
+	});
+}
+
+//#endregion
+export { generateAll, generateClient, generateServer };

package/dist/cli/commands/index.d.mts

@@ -0,0 +1,5 @@
+import { buildCommand } from "./build.mjs";
+import { generateAll, generateClient, generateServer } from "./generate.mjs";
+import { init } from "./init.mjs";
+import { validate } from "./validate.mjs";
+export { buildCommand, generateAll, generateClient, generateServer, init, validate };

package/dist/cli/commands/index.mjs

@@ -0,0 +1,6 @@
+import { init } from "./init.mjs";
+import { generateAll, generateClient, generateServer } from "./generate.mjs";
+import { validate } from "./validate.mjs";
+import { buildCommand } from "./build.mjs";
+
+export { buildCommand, generateAll, generateClient, generateServer, init, validate };

package/dist/cli/commands/init.d.mts

@@ -0,0 +1,45 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/commands/init.d.ts
+/**
+ * Available templates from the examples directory
+ */
+declare const AVAILABLE_TEMPLATES: readonly [{
+  readonly name: "nitro";
+  readonly description: "Minimal Nitro + GraphQL starter";
+}, {
+  readonly name: "drizzle-orm";
+  readonly description: "Nitro + GraphQL + Drizzle ORM with PostgreSQL";
+}, {
+  readonly name: "vite";
+  readonly description: "Vite + Nitro GraphQL integration";
+}, {
+  readonly name: "vite-react";
+  readonly description: "Vite + React + Nitro GraphQL";
+}, {
+  readonly name: "vite-vue";
+  readonly description: "Vite + Vue + Nitro GraphQL";
+}, {
+  readonly name: "better-auth";
+  readonly description: "Nitro + GraphQL + Better Auth integration";
+}];
+type TemplateName = typeof AVAILABLE_TEMPLATES[number]['name'];
+/**
+ * List available templates
+ */
+declare function listTemplates(): void;
+/**
+ * Initialize project from template
+ */
+declare function initFromTemplate(projectName: string, templateName: string, options?: {
+  force?: boolean;
+  cwd?: string;
+}): Promise<void>;
+/**
+ * Initialize project structure (basic scaffolding)
+ */
+declare function init(ctx: CLIContext, options?: {
+  force?: boolean;
+}): Promise<void>;
+//#endregion
+export { AVAILABLE_TEMPLATES, TemplateName, init, initFromTemplate, listTemplates };