nitro-graphql 2.0.0-beta.36 → 2.0.0-beta.38

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

@@ -0,0 +1,26 @@
+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,196 @@
+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 consola from "consola";
+import { dirname, join, relative } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+
+//#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)
+		},
+		layerServerDirs: [],
+		layerAppDirs: []
+	};
+}
+/**
+* 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), { recursive: true });
+	writeFileSync(schemaPath, result.schemaString, "utf-8");
+	const typesPath = join(ctx.config.typesDir, "nitro-graphql-server.d.ts");
+	mkdirSync(dirname(typesPath), { recursive: true });
+	writeFileSync(typesPath, result.types, "utf-8");
+	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 { readFileSync: readFileSync$1 } = await import("node:fs");
+	const result = await generateClientTypesCore({
+		schema: buildSchema(readFileSync$1(schemaPath, "utf-8")),
+		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 typesPath = join(ctx.config.typesDir, "nitro-graphql-client.d.ts");
+	mkdirSync(dirname(typesPath), { recursive: true });
+	writeFileSync(typesPath, result.types, "utf-8");
+	const sdkPath = join(ctx.config.clientDir, "default", "sdk.ts");
+	mkdirSync(dirname(sdkPath), { recursive: true });
+	writeFileSync(sdkPath, result.sdk, "utf-8");
+	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, { recursive: true });
+	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, "utf-8");
+			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 { readFileSync: readFileSync$1 } = await import("node:fs");
+			const schemaCode = generateSchemaModule(readFileSync$1(schemaPath, "utf-8"));
+			writeFileSync(join(runtimeDir, "schema.ts"), schemaCode, "utf-8");
+			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, "utf-8");
+		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$1) => {
+		watcher.on("ready", resolve$1);
+		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((resolve$1) => {
+		process.on("SIGINT", () => {
+			watcher.close();
+			resolve$1();
+		});
+	});
+}
+
+//#endregion
+export { generateAll, generateClient, generateServer };

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

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

package/dist/cli/commands/index.mjs

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

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

@@ -0,0 +1,12 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/commands/init.d.ts
+
+/**
+ * Initialize project structure
+ */
+declare function init(ctx: CLIContext, options?: {
+  force?: boolean;
+}): Promise<void>;
+//#endregion
+export { init };

package/dist/cli/commands/init.mjs

@@ -0,0 +1,100 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import consola from "consola";
+import { join, relative } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+
+//#region src/cli/commands/init.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Initialize project structure
+*/
+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 { init };

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

@@ -0,0 +1,10 @@
+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,69 @@
+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)
+		},
+		layerServerDirs: [],
+		layerAppDirs: []
+	});
+	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/config.d.mts

@@ -0,0 +1,75 @@
+import { GraphQLFramework } from "../core/constants.mjs";
+import { CoreClientUtilsConfig, CoreCodegenConfig, CoreExternalService, CoreFederationConfig, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig } from "../core/types/config.mjs";
+import "../core/types/index.mjs";
+
+//#region src/cli/config.d.ts
+
+/**
+ * CLI configuration options
+ * Used when running nitro-graphql as a standalone CLI tool
+ */
+interface CLIConfig {
+  /** Root directory (defaults to current working directory) */
+  rootDir?: string;
+  /** Build output directory */
+  buildDir?: string;
+  /** Server GraphQL directory (defaults to 'server/graphql') */
+  serverDir?: string;
+  /** Client GraphQL directory (defaults to 'graphql') */
+  clientDir?: string;
+  /** Types output directory */
+  typesDir?: string;
+  /** GraphQL framework (defaults to 'graphql-yoga') */
+  framework?: GraphQLFramework;
+  /** Codegen configuration */
+  codegen?: CoreCodegenConfig;
+  /** Security configuration */
+  security?: CoreSecurityConfig;
+  /** External GraphQL services */
+  externalServices?: CoreExternalService[];
+  /** Apollo Federation configuration */
+  federation?: CoreFederationConfig;
+  /** Path configuration */
+  paths?: CorePathsConfig;
+  /** Scaffold file configuration */
+  scaffold?: false | CoreScaffoldConfig;
+  /** Type generation configuration */
+  types?: false | CoreTypesConfig;
+  /** SDK generation configuration */
+  sdk?: false | CoreSdkConfig;
+  /** Client utilities configuration */
+  clientUtils?: false | CoreClientUtilsConfig;
+  /** Patterns to ignore during scanning */
+  ignore?: string[];
+  /** Watch mode configuration */
+  watch?: {
+    /** Enable watch mode */
+    enabled?: boolean;
+    /** Debounce time in ms */
+    debounce?: number;
+  };
+  /**
+   * Runtime file generation
+   * Generates resolvers.ts, schema.ts for standalone server usage
+   */
+  runtime?: boolean | {
+    /** Output directory for runtime files (defaults to '{buildDir}/runtime') */
+    outDir?: string;
+    /** What to include in generation */
+    include?: {
+      resolvers?: boolean;
+      schema?: boolean;
+      index?: boolean;
+    };
+  };
+}
+/**
+ * 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,24 @@
+#!/usr/bin/env node
+import { CLIConfig, defineConfig } from "./config.mjs";
+
+//#region src/cli/index.d.ts
+
+/**
+ * CLI context with resolved configuration
+ */
+interface CLIContext {
+  config: Required<Pick<CLIConfig, 'rootDir' | 'buildDir' | 'serverDir' | 'clientDir' | 'typesDir' | 'framework' | 'ignore'>> & CLIConfig;
+  cwd: string;
+}
+/**
+ * Load CLI configuration from file or defaults
+ */
+declare function loadConfig(cwd?: string): Promise<CLIConfig>;
+/**
+ * Create CLI context from configuration
+ */
+declare function createCLIContext(options?: {
+  cwd?: string;
+}): Promise<CLIContext>;
+//#endregion
+export { type CLIConfig, CLIContext, createCLIContext, defineConfig, loadConfig };