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

package/dist/cli/index.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+import { LOG_TAG } from "../core/constants.mjs";
+import { DEFAULT_CLI_CONFIG, defineConfig } from "./config.mjs";
+import consola from "consola";
+import { resolve } from "pathe";
+import { existsSync } from "node:fs";
+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 = process.cwd()) {
+	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 || process.cwd();
+	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!");
+			process.exit(1);
+		}
+	}
+});
+const initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Initialize project structure"
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "Set working directory"
+		},
+		force: {
+			type: "boolean",
+			alias: "f",
+			description: "Force overwrite existing files"
+		}
+	},
+	async run({ args }) {
+		const ctx = await createCLIContext({ cwd: args.cwd });
+		logger.info("Initializing nitro-graphql project...");
+		const { init } = await import("./commands/init.mjs");
+		await init(ctx, { force: Boolean(args.force) });
+		logger.success("Project initialized!");
+	}
+});
+const main = defineCommand({
+	meta: {
+		name: "nitro-graphql",
+		version: "2.0.0",
+		description: "GraphQL type generation CLI for Nitro"
+	},
+	subCommands: {
+		"generate": generateCommand,
+		"gen": generateCommand,
+		"g": generateCommand,
+		"generate:server": generateServerCommand,
+		"gen:server": generateServerCommand,
+		"generate:client": generateClientCommand,
+		"gen:client": generateClientCommand,
+		"validate": validateCommand,
+		"v": validateCommand,
+		"init": initCommand
+	}
+});
+runMain(main);
+
+//#endregion
+export { createCLIContext, defineConfig, loadConfig };

package/dist/core/codegen/client.d.mts

@@ -0,0 +1,23 @@
+import { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, ExternalServiceCodegenConfig } from "../types/codegen.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { Source } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/codegen/client.d.ts
+
+/**
+ * Default client codegen configuration
+ */
+declare const DEFAULT_CLIENT_CODEGEN_CONFIG: ClientCodegenConfig;
+/**
+ * Generate client-side GraphQL types
+ * Pure function that generates TypeScript types from a GraphQL schema and documents
+ */
+declare function generateClientTypesCore(input: ClientCodegenInput): Promise<ClientCodegenResult | false>;
+/**
+ * Generate client types for external GraphQL service
+ */
+declare function generateExternalClientTypesCore(service: ExternalServiceCodegenConfig, schema: GraphQLSchema, documents: Source[], virtualTypesPath?: string): Promise<ClientCodegenResult | false>;
+//#endregion
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/core/codegen/client.mjs

@@ -0,0 +1,150 @@
+import { DEFAULT_GRAPHQL_SCALARS } from "../constants.mjs";
+import { pluginContent } from "./plugin.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { defu as defu$1 } from "defu";
+import { codegen } from "@graphql-codegen/core";
+import { preset } from "@graphql-codegen/import-types-preset";
+import { plugin } from "@graphql-codegen/typed-document-node";
+import { plugin as plugin$1 } from "@graphql-codegen/typescript";
+import { plugin as plugin$2 } from "@graphql-codegen/typescript-generic-sdk";
+import { plugin as plugin$3 } from "@graphql-codegen/typescript-operations";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { parse } from "graphql";
+
+//#region src/core/codegen/client.ts
+/**
+* Default client codegen configuration
+*/
+const DEFAULT_CLIENT_CODEGEN_CONFIG = {
+	emitLegacyCommonJSImports: false,
+	useTypeImports: true,
+	enumsAsTypes: true,
+	strictScalars: true,
+	maybeValue: "T | null | undefined",
+	inputMaybeValue: "T | undefined",
+	documentMode: "string",
+	pureMagicComment: true,
+	dedupeOperationSuffix: true,
+	rawRequest: true,
+	scalars: DEFAULT_GRAPHQL_SCALARS
+};
+/**
+* Generate generic SDK content for schema-only generation
+*/
+function generateGenericSdkContent() {
+	return `// THIS FILE IS GENERATED, DO NOT EDIT!
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+import type { GraphQLResolveInfo } from 'graphql'
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> }
+
+export interface Requester<C = {}, E = unknown> {
+  <R, V>(doc: string, vars?: V, options?: C): Promise<R> | AsyncIterable<R>
+}
+
+export type Sdk = {
+  request: <R, V = Record<string, any>>(document: string, variables?: V) => Promise<R>
+}
+
+export function getSdk(requester: Requester): Sdk {
+  return {
+    request: <R, V = Record<string, any>>(document: string, variables?: V): Promise<R> => {
+      return requester<R, V>(document, variables)
+    }
+  }
+}
+`;
+}
+/**
+* Generate client-side GraphQL types
+* Pure function that generates TypeScript types from a GraphQL schema and documents
+*/
+async function generateClientTypesCore(input) {
+	const { schema, documents, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath } = input;
+	if (documents.length === 0 && !serviceName) return false;
+	const mergedConfig = defu$1(DEFAULT_CLIENT_CODEGEN_CONFIG, config);
+	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
+	try {
+		if (documents.length === 0) return {
+			types: await codegen({
+				filename: outputPath || "client-types.generated.ts",
+				schema: parse(printSchemaWithDirectives(schema)),
+				documents: [],
+				config: mergedConfig,
+				plugins: [{ pluginContent: {} }, { typescript: {} }],
+				pluginMap: {
+					pluginContent: { plugin: pluginContent },
+					typescript: { plugin: plugin$1 }
+				}
+			}),
+			sdk: generateGenericSdkContent()
+		};
+		const enableTypedDocumentNode = config.typedDocumentNode === true;
+		const plugins = [
+			{ pluginContent: {} },
+			{ typescript: {} },
+			{ typescriptOperations: {} }
+		];
+		const pluginMap = {
+			pluginContent: { plugin: pluginContent },
+			typescript: { plugin: plugin$1 },
+			typescriptOperations: { plugin: plugin$3 }
+		};
+		if (enableTypedDocumentNode) {
+			plugins.push({ typedDocumentNode: {} });
+			pluginMap.typedDocumentNode = { plugin };
+		}
+		const output = await codegen({
+			filename: outputPath || "client-types.generated.ts",
+			schema: parse(printSchemaWithDirectives(schema)),
+			documents: [...documents],
+			config: mergedConfig,
+			plugins,
+			pluginMap
+		});
+		const typesPath = virtualTypesPath || (serviceName ? `#graphql/client/${serviceName}` : "#graphql/client");
+		const sdkOutput = await preset.buildGeneratesSection({
+			baseOutputDir: outputPath || "client-types.generated.ts",
+			schema: parse(printSchemaWithDirectives(schema)),
+			documents: [...documents],
+			config: mergedSdkConfig,
+			presetConfig: { typesPath },
+			plugins: [{ pluginContent: {} }, { typescriptGenericSdk: {} }],
+			pluginMap: {
+				pluginContent: { plugin: pluginContent },
+				typescriptGenericSdk: { plugin: plugin$2 }
+			}
+		});
+		return {
+			types: output,
+			sdk: (await Promise.all(sdkOutput.map(async (config$1) => {
+				return {
+					file: config$1.filename,
+					content: await codegen(config$1)
+				};
+			})))[0]?.content || ""
+		};
+	} catch {
+		return false;
+	}
+}
+/**
+* Generate client types for external GraphQL service
+*/
+async function generateExternalClientTypesCore(service, schema, documents, virtualTypesPath) {
+	return generateClientTypesCore({
+		schema,
+		documents,
+		config: service.codegen?.client || {},
+		sdkConfig: service.codegen?.clientSDK || {},
+		serviceName: service.name,
+		virtualTypesPath
+	});
+}
+
+//#endregion
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/core/codegen/document-loader.d.mts

@@ -0,0 +1,10 @@
+import { Source } from "@graphql-tools/utils";
+
+//#region src/core/codegen/document-loader.d.ts
+
+/**
+ * Load GraphQL documents from files
+ */
+declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
+//#endregion
+export { loadGraphQLDocuments };

package/dist/core/codegen/document-loader.mjs

@@ -0,0 +1,18 @@
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { loadDocuments } from "@graphql-tools/load";
+
+//#region src/core/codegen/document-loader.ts
+/**
+* Load GraphQL documents from files
+*/
+async function loadGraphQLDocuments(patterns) {
+	try {
+		return await loadDocuments(patterns, { loaders: [new GraphQLFileLoader()] });
+	} catch (e) {
+		if ((e.message || "").includes("Unable to find any GraphQL type definitions for the following pointers:")) return [];
+		throw e;
+	}
+}
+
+//#endregion
+export { loadGraphQLDocuments };

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

@@ -0,0 +1,8 @@
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./client.mjs";
+import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./server.mjs";
+import { validateNoDuplicateTypes } from "./validation.mjs";
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes };

package/dist/core/codegen/index.mjs

@@ -0,0 +1,9 @@
+import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./client.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./server.mjs";
+import { validateNoDuplicateTypes } from "./validation.mjs";
+
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes };

package/dist/{utils/codegen-plugin.d.mts → core/codegen/plugin.d.mts}

@@ -1,7 +1,7 @@
-import { GraphQLSchema } from "graphql";
 import { Source } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
 
-//#region src/utils/codegen-plugin.d.ts
+//#region src/core/codegen/plugin.d.ts
 
 /**
  * Plugin to add prepend comments to generated files

package/dist/{utils/codegen-plugin.mjs → core/codegen/plugin.mjs}

@@ -1,4 +1,4 @@
-//#region src/utils/codegen-plugin.ts
+//#region src/core/codegen/plugin.ts
 /**
 * Plugin to add prepend comments to generated files
 * Used by both server and client codegen

package/dist/core/codegen/runtime.d.mts

@@ -0,0 +1,20 @@
+import { ScannedResolver } from "../types/scanning.mjs";
+import "../types/index.mjs";
+
+//#region src/core/codegen/runtime.d.ts
+
+/**
+ * Generate resolver module code
+ * Outputs Nitro-compatible format with { resolver: ... } wrapper
+ */
+declare function generateResolverModule(resolvers: ScannedResolver[], baseDir: string): string;
+/**
+ * Generate schema module code
+ */
+declare function generateSchemaModule(schemaString: string): string;
+/**
+ * Generate runtime index module
+ */
+declare function generateRuntimeIndex(): string;
+//#endregion
+export { generateResolverModule, generateRuntimeIndex, generateSchemaModule };

package/dist/core/codegen/runtime.mjs

@@ -0,0 +1,60 @@
+import { relative } from "pathe";
+
+//#region src/core/codegen/runtime.ts
+/**
+* Generate resolver module code
+* Outputs Nitro-compatible format with { resolver: ... } wrapper
+*/
+function generateResolverModule(resolvers, baseDir) {
+	if (!resolvers.length) return `// Auto-generated by nitro-graphql - no resolvers found
+export const resolvers = []
+`;
+	const imports = [];
+	const resolverEntries = [];
+	const reexports = [];
+	for (const resolver of resolvers) {
+		const relativePath = relative(baseDir, resolver.specifier).replace(/\.ts$/, "");
+		const exportNames = resolver.imports.map((i) => i.name);
+		if (exportNames.length > 0) {
+			imports.push(`import { ${exportNames.join(", ")} } from '${relativePath}'`);
+			for (const name of exportNames) resolverEntries.push(`  { resolver: ${name} }`);
+			reexports.push(`export { ${exportNames.join(", ")} } from '${relativePath}'`);
+		}
+	}
+	return `// Auto-generated by nitro-graphql - do not edit
+${imports.join("\n")}
+
+export const resolvers = [
+${resolverEntries.join(",\n")},
+]
+
+// Re-exports for tree-shaking
+${reexports.join("\n")}
+`;
+}
+/**
+* Generate schema module code
+*/
+function generateSchemaModule(schemaString) {
+	return `// Auto-generated by nitro-graphql - do not edit
+export const schemaString = \`
+${schemaString.replace(/`/g, "\\`").replace(/\$/g, "\\$")}
+\`
+
+// Pre-parsed for convenience
+import { parse } from 'graphql'
+export const typeDefs = parse(schemaString)
+`;
+}
+/**
+* Generate runtime index module
+*/
+function generateRuntimeIndex() {
+	return `// Auto-generated by nitro-graphql - do not edit
+export { resolvers } from './resolvers'
+export { schemaString, typeDefs } from './schema'
+`;
+}
+
+//#endregion
+export { generateResolverModule, generateRuntimeIndex, generateSchemaModule };

package/dist/core/codegen/schema-loader.d.mts

@@ -0,0 +1,28 @@
+import { ExternalServiceCodegenConfig } from "../types/codegen.mjs";
+import { GraphQLSchema } from "graphql";
+import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
+
+//#region src/core/codegen/schema-loader.d.ts
+
+/**
+ * Type definition pointer for GraphQL schemas
+ */
+type GraphQLTypeDefPointer = UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[];
+/**
+ * Options for loading GraphQL schemas
+ */
+type GraphQLLoadSchemaOptions = Partial<LoadSchemaOptions>;
+/**
+ * Load GraphQL schema synchronously
+ */
+declare function graphQLLoadSchemaSync(schemaPointers: GraphQLTypeDefPointer, data?: GraphQLLoadSchemaOptions): GraphQLSchema | undefined;
+/**
+ * Load schema from external GraphQL service
+ */
+declare function loadExternalSchema(service: ExternalServiceCodegenConfig, buildDir?: string): Promise<GraphQLSchema | undefined>;
+/**
+ * Download and save schema from external service
+ */
+declare function downloadAndSaveSchema(service: ExternalServiceCodegenConfig, buildDir: string): Promise<string | undefined>;
+//#endregion
+export { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema };