@geekmidas/cli 9.0.2 → 10.0.0-alpha.0

package/src/openapi-react-query.ts

@@ -1,288 +0,0 @@
-#!/usr/bin/env -S npx tsx
-
-import { exec } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { promisify } from 'node:util';
-
-const execAsync = promisify(exec);
-
-interface ReactQueryOptions {
-	input?: string;
-	output?: string;
-	name?: string;
-}
-
-interface OpenAPISpec {
-	openapi: string;
-	info?: {
-		title?: string;
-		version?: string;
-	};
-	paths: Record<string, Record<string, any>>;
-}
-
-export async function generateReactQueryCommand(
-	options: ReactQueryOptions = {},
-): Promise<void> {
-	const logger = console;
-
-	try {
-		// Read OpenAPI spec
-		const inputPath = options.input || join(process.cwd(), 'openapi.json');
-
-		if (!existsSync(inputPath)) {
-			throw new Error(
-				`OpenAPI spec not found at ${inputPath}. Run 'npx @geekmidas/cli openapi' first.`,
-			);
-		}
-
-		const specContent = await readFile(inputPath, 'utf-8');
-		const spec: OpenAPISpec = JSON.parse(specContent);
-
-		// Generate TypeScript types from OpenAPI spec
-		const outputDir = dirname(
-			options.output || join(process.cwd(), 'src', 'api', 'hooks.ts'),
-		);
-		const typesPath = join(outputDir, 'openapi-types.d.ts');
-
-		logger.log('Generating TypeScript types from OpenAPI spec...');
-
-		try {
-			// Use npx to run openapi-typescript
-			await execAsync(
-				`npx openapi-typescript "${inputPath}" -o "${typesPath}"`,
-				{ cwd: process.cwd() },
-			);
-			logger.log(`TypeScript types generated: ${typesPath}`);
-		} catch (_error) {
-			logger.warn(
-				'Could not generate types with openapi-typescript. Install it for better type inference.',
-			);
-			logger.warn('Run: npm install -D openapi-typescript');
-
-			// Generate basic types file
-			await mkdir(dirname(typesPath), { recursive: true });
-			await writeFile(
-				typesPath,
-				`// Auto-generated placeholder types
-export interface paths {
-  [path: string]: {
-    [method: string]: {
-      operationId?: string;
-      parameters?: any;
-      requestBody?: any;
-      responses?: any;
-    };
-  };
-}
-`,
-			);
-		}
-
-		// Extract operation info
-		const operations = extractOperations(spec);
-
-		// Generate TypeScript code
-		const code = generateReactQueryCode(
-			spec,
-			operations,
-			options.name || 'API',
-		);
-
-		// Write output
-		const outputPath =
-			options.output || join(process.cwd(), 'src', 'api', 'hooks.ts');
-		await mkdir(dirname(outputPath), { recursive: true });
-		await writeFile(outputPath, code);
-
-		logger.log(`React Query hooks generated: ${outputPath}`);
-		logger.log(`Generated ${operations.length} hooks`);
-	} catch (error) {
-		throw new Error(
-			`React Query generation failed: ${(error as Error).message}`,
-		);
-	}
-}
-
-interface OperationInfo {
-	operationId: string;
-	path: string;
-	method: string;
-	endpoint: string; // Full endpoint like 'GET /users/{id}'
-	parameters?: Array<{ name: string; in: string; required?: boolean }>;
-	requestBody?: boolean;
-	responseType?: string;
-}
-
-function extractOperations(spec: OpenAPISpec): OperationInfo[] {
-	const operations: OperationInfo[] = [];
-
-	Object.entries(spec.paths).forEach(([path, methods]) => {
-		Object.entries(methods).forEach(([method, operation]) => {
-			if (operation.operationId) {
-				operations.push({
-					operationId: operation.operationId,
-					path,
-					method: method.toUpperCase(),
-					endpoint: `${method.toUpperCase()} ${path}`,
-					parameters: operation.parameters,
-					requestBody: !!operation.requestBody,
-					responseType: extractResponseType(operation),
-				});
-			}
-		});
-	});
-
-	return operations;
-}
-
-function extractResponseType(operation: any): string {
-	const responses = operation.responses;
-	if (!responses) return 'unknown';
-
-	const successResponse = responses['200'] || responses['201'];
-	if (!successResponse?.content?.['application/json']?.schema) {
-		return 'unknown';
-	}
-
-	// Basic type inference from schema
-	const schema = successResponse.content['application/json'].schema;
-	return schemaToTypeString(schema);
-}
-
-function schemaToTypeString(schema: any): string {
-	if (!schema) return 'unknown';
-
-	switch (schema.type) {
-		case 'string':
-			return 'string';
-		case 'number':
-		case 'integer':
-			return 'number';
-		case 'boolean':
-			return 'boolean';
-		case 'array':
-			return `Array<${schemaToTypeString(schema.items)}>`;
-		case 'object':
-			if (schema.properties) {
-				const props = Object.entries(schema.properties)
-					.map(
-						([key, value]: [string, any]) =>
-							`${key}: ${schemaToTypeString(value)}`,
-					)
-					.join('; ');
-				return `{ ${props} }`;
-			}
-			return 'Record<string, unknown>';
-		default:
-			return 'unknown';
-	}
-}
-
-function generateReactQueryCode(
-	_spec: OpenAPISpec,
-	operations: OperationInfo[],
-	apiName: string,
-): string {
-	const imports = `import { createTypedQueryClient } from '@geekmidas/client';
-import type { paths } from './openapi-types';
-
-// Create typed query client
-export const ${apiName.toLowerCase()} = createTypedQueryClient<paths>({
-  baseURL: process.env.NEXT_PUBLIC_API_URL || '/api',
-});
-
-// Export individual hooks for better DX
-`;
-
-	const queryHooks = operations
-		.filter((op) => op.method === 'GET')
-		.map((op) => generateQueryHook(op, apiName))
-		.join('\n\n');
-
-	const mutationHooks = operations
-		.filter((op) => op.method !== 'GET')
-		.map((op) => generateMutationHook(op, apiName))
-		.join('\n\n');
-
-	const typeExports = generateTypeExports(operations);
-
-	return `${imports}
-// Query Hooks
-${queryHooks}
-
-// Mutation Hooks
-${mutationHooks}
-
-// Type exports for convenience
-${typeExports}
-
-// Re-export the api for advanced usage
-export { ${apiName.toLowerCase()} };
-`;
-}
-
-function generateQueryHook(op: OperationInfo, apiName: string): string {
-	const hookName = `use${capitalize(op.operationId)}`;
-	const endpoint = op.endpoint;
-	const hasParams = op.parameters?.some((p) => p.in === 'path');
-	const hasQuery = op.parameters?.some((p) => p.in === 'query');
-
-	// Generate properly typed hook
-	let params = '';
-	let args = '';
-
-	if (hasParams || hasQuery) {
-		const paramParts: string[] = [];
-		if (hasParams) {
-			const pathParams =
-				op.parameters?.filter((p) => p.in === 'path').map((p) => p.name) || [];
-			paramParts.push(
-				`params: { ${pathParams.map((p) => `${p}: string`).join('; ')} }`,
-			);
-		}
-		if (hasQuery) {
-			paramParts.push(`query?: Record<string, any>`);
-		}
-		params = `config: { ${paramParts.join('; ')} }, `;
-		args = ', config';
-	}
-
-	return `export const ${hookName} = (
-  ${params}options?: Parameters<typeof ${apiName.toLowerCase()}.useQuery>[2]
-) => {
-  return ${apiName.toLowerCase()}.useQuery('${endpoint}' as any${args}, options);
-};`;
-}
-
-function generateMutationHook(op: OperationInfo, apiName: string): string {
-	const hookName = `use${capitalize(op.operationId)}`;
-	const endpoint = op.endpoint;
-
-	return `export const ${hookName} = (
-  options?: Parameters<typeof ${apiName.toLowerCase()}.useMutation>[1]
-) => {
-  return ${apiName.toLowerCase()}.useMutation('${endpoint}' as any, options);
-};`;
-}
-
-function generateTypeExports(operations: OperationInfo[]): string {
-	const exports = operations.map((op) => {
-		const typeName = capitalize(op.operationId);
-		const isQuery = op.method === 'GET';
-
-		if (isQuery) {
-			return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['data']>>;`;
-		} else {
-			return `export type ${typeName}Response = Awaited<ReturnType<ReturnType<typeof use${typeName}>['mutateAsync']>>;`;
-		}
-	});
-
-	return exports.join('\n');
-}
-
-function capitalize(str: string): string {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}

package/src/openapi.ts

@@ -1,259 +0,0 @@
-#!/usr/bin/env -S npx tsx
-
-import { spawn } from 'node:child_process';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { loadWorkspaceConfig } from './config.js';
-import { EndpointGenerator } from './generators/EndpointGenerator.js';
-import { OpenApiTsGenerator } from './generators/OpenApiTsGenerator.js';
-import type { GkmConfig, OpenApiConfig } from './types.js';
-import { normalizeRoutes } from './workspace/client-generator.js';
-import type { NormalizedAppConfig } from './workspace/types.js';
-
-interface OpenAPIOptions {
-	cwd?: string;
-	/**
-	 * Workspace mode: generate for a single named backend app. When set,
-	 * generation runs in-process against the current CWD. When unset,
-	 * workspace mode spawns one subprocess per backend app so each gets a
-	 * fresh tsx that loads the app's own tsconfig (path aliases included).
-	 */
-	app?: string;
-}
-
-/**
- * Default output path for generated OpenAPI client (used for single-app configs)
- */
-export const OPENAPI_OUTPUT_PATH = './.gkm/openapi.ts';
-
-/**
- * Resolve OpenAPI config from GkmConfig
- */
-export function resolveOpenApiConfig(
-	config: GkmConfig,
-): OpenApiConfig & { enabled: boolean } {
-	if (config.openapi === false) {
-		return { enabled: false };
-	}
-
-	if (config.openapi === true || config.openapi === undefined) {
-		// Enable by default when not explicitly set (undefined) or explicitly true
-		return {
-			enabled: true,
-			title: 'API Documentation',
-			version: '1.0.0',
-			description: 'Auto-generated API documentation from endpoints',
-		};
-	}
-
-	return {
-		enabled: config.openapi.enabled !== false,
-		title: config.openapi.title || 'API Documentation',
-		version: config.openapi.version || '1.0.0',
-		description:
-			config.openapi.description ||
-			'Auto-generated API documentation from endpoints',
-	};
-}
-
-/**
- * Generate OpenAPI spec from endpoints
- * @returns Object with output path and endpoint count, or null if disabled
- */
-export async function generateOpenApi(
-	config: GkmConfig,
-	options: { silent?: boolean; bustCache?: boolean } = {},
-): Promise<{ outputPath: string; endpointCount: number } | null> {
-	const logger = options.silent ? { log: () => {} } : console;
-	const openApiConfig = resolveOpenApiConfig(config);
-
-	if (!openApiConfig.enabled) {
-		return null;
-	}
-
-	const endpointGenerator = new EndpointGenerator();
-	const loadedEndpoints = await endpointGenerator.load(
-		config.routes,
-		undefined,
-		options.bustCache,
-	);
-
-	if (loadedEndpoints.length === 0) {
-		logger.log('No valid endpoints found for OpenAPI generation');
-		return null;
-	}
-
-	const endpoints = loadedEndpoints.map(({ construct }) => construct);
-	const outputPath = join(process.cwd(), OPENAPI_OUTPUT_PATH);
-
-	await mkdir(dirname(outputPath), { recursive: true });
-
-	const tsGenerator = new OpenApiTsGenerator();
-	const tsContent = await tsGenerator.generate(endpoints, {
-		title: openApiConfig.title!,
-		version: openApiConfig.version!,
-		description: openApiConfig.description!,
-	});
-
-	await writeFile(outputPath, tsContent);
-	logger.log(`📄 OpenAPI client generated: ${OPENAPI_OUTPUT_PATH}`);
-
-	return { outputPath, endpointCount: loadedEndpoints.length };
-}
-
-export async function openapiCommand(
-	options: OpenAPIOptions = {},
-): Promise<void> {
-	const logger = console;
-
-	try {
-		const loadedConfig = await loadWorkspaceConfig(options.cwd);
-
-		if (loadedConfig.type === 'single') {
-			// Single-app config - use existing behavior
-			const config = loadedConfig.raw as GkmConfig;
-
-			// Enable openapi if not configured
-			if (!config.openapi) {
-				config.openapi = { enabled: true };
-			}
-
-			const result = await generateOpenApi(config);
-
-			if (result) {
-				logger.log(`Found ${result.endpointCount} endpoints`);
-			}
-		} else {
-			// Workspace config - generate for each backend app
-			const { workspace } = loadedConfig;
-			// Always derive the workspace root from the loaded config rather than
-			// CWD. Subprocesses run with CWD set to an app directory, and falling
-			// back to CWD there causes `join(workspaceRoot, app.path)` to point at
-			// a non-existent nested path (e.g. `apps/api/apps/api`).
-			const workspaceRoot = workspace.root;
-
-			// Find backend apps with openapi enabled
-			const backendApps = Object.entries(workspace.apps).filter(
-				([_, app]) =>
-					app.type === 'backend' &&
-					(app.openapi === true ||
-						(typeof app.openapi === 'object' && app.openapi.enabled !== false)),
-			);
-
-			if (backendApps.length === 0) {
-				logger.log('No backend apps with OpenAPI enabled found');
-				return;
-			}
-
-			// Single-app mode: generate in-process. The caller is expected to
-			// have CWD set to the app's directory (e.g., when invoked as a
-			// subprocess), so tsx picks up the app's tsconfig path aliases.
-			if (options.app) {
-				const entry = backendApps.find(([name]) => name === options.app);
-				if (!entry) {
-					throw new Error(
-						`App "${options.app}" not found or has OpenAPI disabled`,
-					);
-				}
-				const [appName, app] = entry;
-				const result = await generateOpenApiForApp(workspaceRoot, appName, app);
-				if (result) {
-					logger.log(
-						`📄 [${appName}] Generated OpenAPI (${result.endpointCount} endpoints)`,
-					);
-				}
-				return;
-			}
-
-			// Multi-app mode: spawn a subprocess per backend app. Each
-			// subprocess starts with CWD at the app's directory so that
-			// tsx's tsconfig discovery picks up the app's `paths` aliases
-			// (e.g., `~/*`) instead of the workspace root's tsconfig.
-			for (const [appName, app] of backendApps) {
-				if (app.type !== 'backend' || !app.routes) continue;
-				const appPath = join(workspaceRoot, app.path);
-				await runOpenApiInSubprocess(appPath, appName);
-			}
-		}
-	} catch (error) {
-		throw new Error(`OpenAPI generation failed: ${(error as Error).message}`);
-	}
-}
-
-/**
- * Generate OpenAPI for a single named app within a workspace.
- * Runs in-process. The caller is responsible for ensuring `process.cwd()`
- * is the app's directory so tsx loads the app's tsconfig path aliases.
- */
-async function generateOpenApiForApp(
-	workspaceRoot: string,
-	_appName: string,
-	app: NormalizedAppConfig,
-): Promise<{ outputPath: string; endpointCount: number } | null> {
-	if (app.type !== 'backend' || !app.routes) {
-		return null;
-	}
-
-	const appPath = join(workspaceRoot, app.path);
-	const routes = normalizeRoutes(app.routes);
-	const routesGlob = routes.map((r) => join(appPath, r));
-
-	const gkmConfig: GkmConfig = {
-		routes: routesGlob,
-		envParser: app.envParser || '',
-		logger: app.logger || '',
-		openapi: app.openapi,
-	};
-
-	return generateOpenApi(gkmConfig, { silent: true });
-}
-
-/**
- * Resolve the gkm bin path. Tests can override via `GKM_BIN_PATH` env var
- * to avoid depending on the built dist.
- */
-function resolveGkmBinPath(): string {
-	if (process.env.GKM_BIN_PATH) {
-		return process.env.GKM_BIN_PATH;
-	}
-	return fileURLToPath(new URL('../bin/gkm.mjs', import.meta.url));
-}
-
-/**
- * Spawn a subprocess that runs `gkm openapi --app <name>` with `cwd` set to
- * the app's directory. Inherits `NODE_OPTIONS` (which already contains
- * `--import tsx`), so the child gets a fresh tsx instance whose tsconfig
- * discovery picks up the app's tsconfig path aliases.
- */
-async function runOpenApiInSubprocess(
-	appCwd: string,
-	appName: string,
-): Promise<void> {
-	const binPath = resolveGkmBinPath();
-
-	await new Promise<void>((resolve, reject) => {
-		const child = spawn(
-			process.execPath,
-			[binPath, 'openapi', '--app', appName],
-			{
-				cwd: appCwd,
-				stdio: 'inherit',
-				env: process.env,
-			},
-		);
-
-		child.on('error', reject);
-		child.on('close', (code) => {
-			if (code === 0) {
-				resolve();
-			} else {
-				reject(
-					new Error(
-						`OpenAPI generation for app "${appName}" exited with code ${code}`,
-					),
-				);
-			}
-		});
-	});
-}