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

package/dist/cli/commands/init.mjs

@@ -0,0 +1,195 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import consola from "consola";
+import { basename, join, relative, resolve } from "pathe";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { downloadTemplate } from "giget";
+
+//#region src/cli/commands/init.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Available templates from the examples directory
+*/
+const AVAILABLE_TEMPLATES = [
+	{
+		name: "nitro",
+		description: "Minimal Nitro + GraphQL starter"
+	},
+	{
+		name: "drizzle-orm",
+		description: "Nitro + GraphQL + Drizzle ORM with PostgreSQL"
+	},
+	{
+		name: "vite",
+		description: "Vite + Nitro GraphQL integration"
+	},
+	{
+		name: "vite-react",
+		description: "Vite + React + Nitro GraphQL"
+	},
+	{
+		name: "vite-vue",
+		description: "Vite + Vue + Nitro GraphQL"
+	},
+	{
+		name: "better-auth",
+		description: "Nitro + GraphQL + Better Auth integration"
+	}
+];
+/**
+* Default GitHub template source
+*/
+const DEFAULT_TEMPLATE_REGISTRY = "github:productdevbook/nitro-graphql/examples";
+/**
+* List available templates
+*/
+function listTemplates() {
+	logger.info("Available templates:\n");
+	for (const template of AVAILABLE_TEMPLATES) console.log(`  ${template.name.padEnd(15)} - ${template.description}`);
+	console.log("\nUsage:");
+	console.log("  nitro-graphql init <project-name> --template <template-name>");
+	console.log("  nitro-graphql init my-app -t drizzle-orm");
+	console.log("\nCustom templates:");
+	console.log("  nitro-graphql init my-app -t gh:user/repo");
+	console.log("  nitro-graphql init my-app -t github:user/repo/subdir");
+}
+/**
+* Initialize project from template
+*/
+async function initFromTemplate(projectName, templateName, options = {}) {
+	const { force, cwd = process.cwd() } = options;
+	const targetDir = resolve(cwd, projectName);
+	if (existsSync(targetDir) && !force) {
+		logger.error(`Directory "${projectName}" already exists. Use --force to overwrite.`);
+		process.exit(1);
+	}
+	let templateSource;
+	if (templateName.includes(":") || templateName.includes("/")) templateSource = templateName;
+	else {
+		if (!AVAILABLE_TEMPLATES.find((t) => t.name === templateName)) {
+			logger.error(`Unknown template: "${templateName}"`);
+			logger.info("Use --list to see available templates");
+			process.exit(1);
+		}
+		templateSource = `${DEFAULT_TEMPLATE_REGISTRY}/${templateName}`;
+	}
+	logger.info(`Downloading template: ${templateName}`);
+	logger.debug(`Source: ${templateSource}`);
+	try {
+		const result = await downloadTemplate(templateSource, {
+			dir: targetDir,
+			force
+		});
+		logger.success(`Template downloaded to: ${result.dir}`);
+		const packageJsonPath = join(targetDir, "package.json");
+		if (existsSync(packageJsonPath)) try {
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+			packageJson.name = basename(projectName).replace(/[^a-z0-9-]/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "my-graphql-app";
+			writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
+			logger.debug(`Updated package.json name to: ${packageJson.name}`);
+		} catch {
+			logger.warn("Could not update package.json name");
+		}
+		console.log("");
+		logger.info("Next steps:");
+		console.log(`  cd ${projectName}`);
+		console.log("  pnpm install");
+		console.log("  pnpm dev");
+		console.log("");
+	} catch (error) {
+		logger.error("Failed to download template:", error);
+		process.exit(1);
+	}
+}
+/**
+* Initialize project structure (basic scaffolding)
+*/
+async function init(ctx, options = {}) {
+	const { force } = options;
+	const dirs = [ctx.config.serverDir, ctx.config.clientDir];
+	for (const dir of dirs) if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+		logger.info(`Created directory: ${dir}`);
+	}
+	const configPath = join(ctx.config.rootDir, "nitro-graphql.config.ts");
+	if (force || !existsSync(configPath)) {
+		const relativeServerDir = relative(ctx.config.rootDir, ctx.config.serverDir) || "server/graphql";
+		const relativeClientDir = relative(ctx.config.rootDir, ctx.config.clientDir) || "graphql";
+		writeFileSync(configPath, `import { defineConfig } from 'nitro-graphql/cli'
+
+export default defineConfig({
+  framework: '${ctx.config.framework}',
+  serverDir: './${relativeServerDir}',
+  clientDir: './${relativeClientDir}',
+})
+`, "utf-8");
+		logger.success(`Created config file: ${configPath}`);
+	} else logger.info(`Config file already exists: ${configPath}`);
+	const tsconfigPath = join(ctx.config.rootDir, "tsconfig.json");
+	if (force || !existsSync(tsconfigPath)) {
+		const relativeBuildDir = relative(ctx.config.rootDir, ctx.config.buildDir) || ".graphql";
+		writeFileSync(tsconfigPath, `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "paths": {
+      "#graphql/server": ["./${relativeBuildDir}/types/nitro-graphql-server.d.ts"],
+      "#graphql/client": ["./${relativeBuildDir}/types/nitro-graphql-client.d.ts"],
+      "#graphql/schema": ["./${relative(ctx.config.rootDir, ctx.config.serverDir) || "server/graphql"}/schema.ts"]
+    }
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "${relativeBuildDir}"]
+}
+`, "utf-8");
+		logger.success(`Created tsconfig.json: ${tsconfigPath}`);
+	} else logger.info(`tsconfig.json already exists: ${tsconfigPath}`);
+	const schemaPath = join(ctx.config.serverDir, "schema.graphql");
+	if (force || !existsSync(schemaPath)) {
+		writeFileSync(schemaPath, `# GraphQL Schema
+# Add your type definitions here
+
+type Query {
+  hello: String!
+}
+
+type Mutation {
+  # Add your mutations here
+  _empty: String
+}
+`, "utf-8");
+		logger.success(`Created example schema: ${schemaPath}`);
+	} else logger.info(`Schema file already exists: ${schemaPath}`);
+	const resolverPath = join(ctx.config.serverDir, "hello.resolver.ts");
+	if (force || !existsSync(resolverPath)) {
+		writeFileSync(resolverPath, `import { defineQuery } from 'nitro-graphql/define'
+
+export const helloQueries = defineQuery({
+  hello: () => 'Hello, world!',
+})
+`, "utf-8");
+		logger.success(`Created example resolver: ${resolverPath}`);
+	} else logger.info(`Resolver file already exists: ${resolverPath}`);
+	const queryPath = join(ctx.config.clientDir, "hello.graphql");
+	if (force || !existsSync(queryPath)) {
+		writeFileSync(queryPath, `query Hello {
+  hello
+}
+`, "utf-8");
+		logger.success(`Created example query: ${queryPath}`);
+	} else logger.info(`Query file already exists: ${queryPath}`);
+	logger.info("");
+	logger.info("Next steps:");
+	logger.info("  1. Run \"nitro-graphql generate\" to generate types");
+	logger.info("  2. Add more schemas to your server directory");
+	logger.info("  3. Add more queries/mutations to your client directory");
+}
+
+//#endregion
+export { AVAILABLE_TEMPLATES, init, initFromTemplate, listTemplates };

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

@@ -0,0 +1,9 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/commands/validate.d.ts
+/**
+ * Validate GraphQL schemas
+ */
+declare function validate(ctx: CLIContext): Promise<boolean>;
+//#endregion
+export { validate };

package/dist/cli/commands/validate.mjs

@@ -0,0 +1,67 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import { validateNoDuplicateTypes } from "../../core/codegen/validation.mjs";
+import { scanSchemasCore } from "../../core/scanning/schemas.mjs";
+import consola from "consola";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/cli/commands/validate.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Validate GraphQL schemas
+*/
+async function validate(ctx) {
+	const schemaResult = await scanSchemasCore({
+		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)
+		}
+	});
+	if (schemaResult.errors.length > 0) {
+		for (const error of schemaResult.errors) logger.error(error);
+		return false;
+	}
+	if (schemaResult.items.length === 0) {
+		logger.warn("No GraphQL schemas found to validate");
+		return true;
+	}
+	const schemaContents = [];
+	for (const schemaPath of schemaResult.items) {
+		if (!existsSync(schemaPath)) {
+			logger.error(`Schema file not found: ${schemaPath}`);
+			return false;
+		}
+		try {
+			const content = readFileSync(schemaPath, "utf-8");
+			schemaContents.push(content);
+		} catch (error) {
+			logger.error(`Failed to read schema file ${schemaPath}:`, error);
+			return false;
+		}
+	}
+	if (!validateNoDuplicateTypes(schemaResult.items, schemaContents)) {
+		logger.error("Schema validation failed");
+		return false;
+	}
+	try {
+		const { buildSchema, print } = await import("graphql");
+		const { mergeTypeDefs } = await import("@graphql-tools/merge");
+		const mergedTypeDefs = mergeTypeDefs(schemaContents);
+		buildSchema(typeof mergedTypeDefs === "string" ? mergedTypeDefs : print(mergedTypeDefs));
+		logger.info(`Validated ${schemaResult.items.length} schema file(s)`);
+		return true;
+	} catch (error) {
+		logger.error("Schema syntax error:", error);
+		return false;
+	}
+}
+
+//#endregion
+export { validate };

package/dist/cli/completions.d.mts

@@ -0,0 +1,6 @@
+import { ArgsDef, CommandDef } from "citty";
+
+//#region src/cli/completions.d.ts
+declare function initCompletions<T extends ArgsDef = ArgsDef>(command: CommandDef<T>): Promise<void>;
+//#endregion
+export { initCompletions };

package/dist/cli/completions.mjs

@@ -0,0 +1,34 @@
+import { AVAILABLE_TEMPLATES } from "./commands/init.mjs";
+
+//#region src/cli/completions.ts
+async function initCompletions(command) {
+	const { default: tab } = await import("@bomb.sh/tab/citty");
+	await tab(command, { subCommands: {
+		"init": { options: {
+			template: (complete) => {
+				for (const template of AVAILABLE_TEMPLATES) complete(template.name, template.description);
+				complete("gh:", "GitHub shorthand (gh:user/repo)");
+				complete("github:", "GitHub template (github:user/repo/path)");
+				complete("gitlab:", "GitLab template (gitlab:user/repo)");
+			},
+			cwd: (complete) => {
+				complete(".", "Current directory");
+			}
+		} },
+		"generate": { options: { cwd: (complete) => {
+			complete(".", "Current directory");
+		} } },
+		"generate:server": { options: { cwd: (complete) => {
+			complete(".", "Current directory");
+		} } },
+		"generate:client": { options: { cwd: (complete) => {
+			complete(".", "Current directory");
+		} } },
+		"validate": { options: { cwd: (complete) => {
+			complete(".", "Current directory");
+		} } }
+	} });
+}
+
+//#endregion
+export { initCompletions };

package/dist/cli/config.d.mts

@@ -0,0 +1,18 @@
+import { NitroGraphQLOptions } from "../nitro/types.mjs";
+
+//#region src/cli/config.d.ts
+/**
+ * CLI configuration options
+ * Now unified with NitroGraphQLOptions - all options available in both CLI and module context
+ */
+type CLIConfig = NitroGraphQLOptions;
+/**
+ * Define CLI configuration with type safety
+ */
+declare function defineConfig(config: CLIConfig): CLIConfig;
+/**
+ * Default CLI configuration values
+ */
+declare const DEFAULT_CLI_CONFIG: CLIConfig;
+//#endregion
+export { CLIConfig, DEFAULT_CLI_CONFIG, defineConfig };

package/dist/cli/config.mjs

@@ -0,0 +1,20 @@
+//#region src/cli/config.ts
+/**
+* Define CLI configuration with type safety
+*/
+function defineConfig(config) {
+	return config;
+}
+/**
+* Default CLI configuration values
+*/
+const DEFAULT_CLI_CONFIG = {
+	framework: "graphql-yoga",
+	serverDir: "server/graphql",
+	clientDir: "graphql",
+	buildDir: ".graphql",
+	ignore: ["**/node_modules/**", "**/dist/**"]
+};
+
+//#endregion
+export { DEFAULT_CLI_CONFIG, defineConfig };

package/dist/cli/index.d.mts

@@ -0,0 +1,26 @@
+import { NitroGraphQLOptions } from "../nitro/types.mjs";
+import { CLIConfig, defineConfig } from "./config.mjs";
+
+//#region src/cli/index.d.ts
+/**
+ * CLI context with resolved configuration
+ * Uses NitroGraphQLOptions directly as CLI and module options are now unified
+ */
+interface CLIContext {
+  config: Required<Pick<NitroGraphQLOptions, 'rootDir' | 'buildDir' | 'serverDir' | 'clientDir' | 'typesDir' | 'framework'>> & {
+    ignore: string[];
+  } & NitroGraphQLOptions;
+  cwd: string;
+}
+/**
+ * Load CLI configuration from file or defaults
+ */
+declare function loadConfig(cwd?: string): Promise<NitroGraphQLOptions>;
+/**
+ * Create CLI context from configuration
+ */
+declare function createCLIContext(options?: {
+  cwd?: string;
+}): Promise<CLIContext>;
+//#endregion
+export { type CLIConfig, CLIContext, createCLIContext, defineConfig, loadConfig };

package/dist/cli/index.mjs

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+import { DEFAULT_CLI_CONFIG, defineConfig } from "./config.mjs";
+import { LOG_TAG } from "../core/constants.mjs";
+import { existsSync_, exit, getCwd } from "../core/utils/runtime.mjs";
+import consola from "consola";
+import { resolve } from "pathe";
+import { defineCommand, runMain } from "citty";
+
+//#region src/cli/index.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Load CLI configuration from file or defaults
+*/
+async function loadConfig(cwd = getCwd()) {
+	for (const file of [
+		"nitro-graphql.config.ts",
+		"nitro-graphql.config.js",
+		"nitro-graphql.config.mjs",
+		"graphql.config.ts"
+	]) {
+		const configPath = resolve(cwd, file);
+		if (existsSync_(configPath)) try {
+			const module = await import(configPath);
+			const config = module.default || module;
+			logger.info(`Loaded config from ${file}`);
+			return {
+				...DEFAULT_CLI_CONFIG,
+				...config
+			};
+		} catch (error) {
+			logger.warn(`Failed to load config from ${file}:`, error);
+		}
+	}
+	logger.debug("Using default configuration");
+	return { ...DEFAULT_CLI_CONFIG };
+}
+/**
+* Create CLI context from configuration
+*/
+async function createCLIContext(options = {}) {
+	const cwd = options.cwd || getCwd();
+	const config = await loadConfig(cwd);
+	const rootDir = config.rootDir ? resolve(cwd, config.rootDir) : cwd;
+	const buildDir = config.buildDir ? resolve(rootDir, config.buildDir) : resolve(rootDir, ".nitro-graphql");
+	const serverDir = config.serverDir ? resolve(rootDir, config.serverDir) : resolve(rootDir, "server/graphql");
+	const clientDir = config.clientDir ? resolve(rootDir, config.clientDir) : resolve(rootDir, "graphql");
+	const typesDir = config.typesDir ? resolve(rootDir, config.typesDir) : resolve(buildDir, "types");
+	return {
+		cwd,
+		config: {
+			...config,
+			rootDir,
+			buildDir,
+			serverDir,
+			clientDir,
+			typesDir,
+			framework: config.framework || "graphql-yoga",
+			ignore: config.ignore || ["**/node_modules/**", "**/dist/**"]
+		}
+	};
+}
+const generateCommand = defineCommand({
+	meta: {
+		name: "generate",
+		description: "Generate all GraphQL types"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		silent: {
+			type: "boolean",
+			alias: "s",
+			description: "Suppress output"
+		},
+		watch: {
+			type: "boolean",
+			alias: "w",
+			description: "Watch mode"
+		},
+		runtime: {
+			type: "boolean",
+			alias: "r",
+			description: "Generate runtime files (resolvers.ts, schema.ts)"
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		const silent = Boolean(args.silent);
+		const watch = Boolean(args.watch);
+		const runtime = Boolean(args.runtime) || Boolean(ctx.config.runtime);
+		if (!silent) logger.info("Generating GraphQL types...");
+		const { generateAll } = await import("./commands/generate.mjs");
+		await generateAll(ctx, {
+			silent,
+			watch,
+			runtime
+		});
+		if (!silent) logger.success("Type generation complete!");
+	}
+});
+const generateServerCommand = defineCommand({
+	meta: {
+		name: "generate:server",
+		description: "Generate server types only"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		silent: {
+			type: "boolean",
+			alias: "s",
+			description: "Suppress output"
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		const silent = Boolean(args.silent);
+		if (!silent) logger.info("Generating server types...");
+		const { generateServer } = await import("./commands/generate.mjs");
+		await generateServer(ctx, { silent });
+		if (!silent) logger.success("Server type generation complete!");
+	}
+});
+const generateClientCommand = defineCommand({
+	meta: {
+		name: "generate:client",
+		description: "Generate client types only"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		silent: {
+			type: "boolean",
+			alias: "s",
+			description: "Suppress output"
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		const silent = Boolean(args.silent);
+		if (!silent) logger.info("Generating client types...");
+		const { generateClient } = await import("./commands/generate.mjs");
+		await generateClient(ctx, { silent });
+		if (!silent) logger.success("Client type generation complete!");
+	}
+});
+const validateCommand = defineCommand({
+	meta: {
+		name: "validate",
+		description: "Validate GraphQL schemas"
+	},
+	args: { cwd: {
+		type: "string",
+		description: "Set working directory"
+	} },
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		logger.info("Validating GraphQL schemas...");
+		const { validate } = await import("./commands/validate.mjs");
+		if (await validate(ctx)) logger.success("Schema validation passed!");
+		else {
+			logger.error("Schema validation failed!");
+			exit(1);
+		}
+	}
+});
+const initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Initialize project structure or download a template"
+	},
+	args: {
+		projectName: {
+			type: "positional",
+			description: "Project name (directory to create)",
+			required: false
+		},
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Force overwrite existing files"
+		},
+		template: {
+			type: "string",
+			alias: "t",
+			description: "Template to use (e.g., drizzle-orm, vite-react)"
+		},
+		list: {
+			type: "boolean",
+			alias: "l",
+			description: "List available templates"
+		}
+	},
+	async run({ args }) {
+		const { listTemplates, initFromTemplate, init } = await import("./commands/init.mjs");
+		if (args.list) {
+			listTemplates();
+			return;
+		}
+		if (args.template) {
+			const projectName = args.projectName || args.template;
+			logger.info(`Creating project "${projectName}" from template "${args.template}"...`);
+			await initFromTemplate(projectName, args.template, {
+				force: Boolean(args.force),
+				cwd: args.cwd || getCwd()
+			});
+			logger.success("Project created successfully!");
+			return;
+		}
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		logger.info("Initializing nitro-graphql project...");
+		await init(ctx, { force: Boolean(args.force) });
+		logger.success("Project initialized!");
+	}
+});
+const buildCmd = 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(ctx) {
+		const { buildCommand } = await import("./commands/build.mjs");
+		return buildCommand.run(ctx);
+	}
+});
+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(ctx) {
+		const { devCommand: devCommandImpl } = await import("./commands/dev.mjs");
+		return devCommandImpl.run(ctx);
+	}
+});
+const main = defineCommand({
+	meta: {
+		name: "nitro-graphql",
+		version: "2.0.0",
+		description: "GraphQL CLI for Nitro - type generation and dev server"
+	},
+	subCommands: {
+		"dev": devCommand,
+		"d": devCommand,
+		"build": buildCmd,
+		"b": buildCmd,
+		"generate": generateCommand,
+		"gen": generateCommand,
+		"g": generateCommand,
+		"generate:server": generateServerCommand,
+		"gen:server": generateServerCommand,
+		"generate:client": generateClientCommand,
+		"gen:client": generateClientCommand,
+		"validate": validateCommand,
+		"v": validateCommand,
+		"init": initCommand
+	}
+});
+async function run() {
+	const { initCompletions } = await import("./completions.mjs");
+	await initCompletions(main);
+	return runMain(main);
+}
+run();
+
+//#endregion
+export { createCLIContext, defineConfig, loadConfig };