@geekmidas/cli 1.2.2 → 1.2.3

package/src/workspace/client-generator.ts

@@ -1,34 +1,20 @@
-import { createHash } from 'node:crypto';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, join, relative } from 'node:path';
-import { EndpointGenerator } from '../generators/EndpointGenerator.js';
-import { OpenApiTsGenerator } from '../generators/OpenApiTsGenerator.js';
 import type { NormalizedWorkspace } from './types.js';
 
 const logger = console;
 
 /**
- * Result of generating a client for a frontend app.
+ * Result of copying a client to a frontend app.
  */
-export interface ClientGenerationResult {
+export interface ClientCopyResult {
 	frontendApp: string;
 	backendApp: string;
 	outputPath: string;
 	endpointCount: number;
-	generated: boolean;
-	reason?: string;
-}
-
-/**
- * Cache of OpenAPI spec hashes to detect changes.
- */
-const specHashCache = new Map<string, string>();
-
-/**
- * Calculate hash of content for change detection.
- */
-function hashContent(content: string): string {
-	return createHash('sha256').update(content).digest('hex').slice(0, 16);
+	success: boolean;
+	error?: string;
 }
 
 /**
@@ -54,128 +40,162 @@ export function getFirstRoute(
 }
 
 /**
- * Generate OpenAPI spec for a backend app.
- * Returns the spec content and endpoint count.
+ * Check if a file path matches endpoint patterns that could affect OpenAPI schema.
+ * Returns true for changes that should trigger client regeneration.
  */
-export async function generateBackendOpenApi(
-	workspace: NormalizedWorkspace,
-	appName: string,
-): Promise<{ content: string; endpointCount: number } | null> {
-	const app = workspace.apps[appName];
-	if (!app || app.type !== 'backend' || !app.routes) {
-		return null;
+export function shouldRegenerateClient(
+	filePath: string,
+	routesPattern: string,
+): boolean {
+	// Normalize path separators
+	const normalizedPath = filePath.replace(/\\/g, '/');
+	const normalizedPattern = routesPattern.replace(/\\/g, '/');
+
+	// Check if the file matches the routes pattern
+	// This is a simple check - the file should be within the routes directory
+	const patternDir = normalizedPattern.split('*')[0] || '';
+
+	if (!normalizedPath.includes(patternDir.replace('./', ''))) {
+		return false;
 	}
 
-	const appPath = join(workspace.root, app.path);
-	const routesPatterns = normalizeRoutes(app.routes);
+	// Check file extension - only TypeScript endpoint files
+	if (!normalizedPath.endsWith('.ts') && !normalizedPath.endsWith('.tsx')) {
+		return false;
+	}
 
-	if (routesPatterns.length === 0) {
-		return null;
+	return true;
+}
+
+/**
+ * Get backend apps that a frontend depends on.
+ */
+export function getBackendDependencies(
+	workspace: NormalizedWorkspace,
+	frontendAppName: string,
+): string[] {
+	const frontendApp = workspace.apps[frontendAppName];
+	if (!frontendApp || frontendApp.type !== 'frontend') {
+		return [];
 	}
 
-	// Load endpoints from all routes patterns
-	const endpointGenerator = new EndpointGenerator();
-	const allLoadedEndpoints = [];
+	return frontendApp.dependencies.filter((dep) => {
+		const depApp = workspace.apps[dep];
+		return depApp?.type === 'backend' && depApp.routes;
+	});
+}
 
-	for (const pattern of routesPatterns) {
-		const fullPattern = join(appPath, pattern);
-		const loaded = await endpointGenerator.load(fullPattern);
-		allLoadedEndpoints.push(...loaded);
+/**
+ * Get frontend apps that depend on a backend app.
+ */
+export function getDependentFrontends(
+	workspace: NormalizedWorkspace,
+	backendAppName: string,
+): string[] {
+	const dependentApps: string[] = [];
+
+	for (const [appName, app] of Object.entries(workspace.apps)) {
+		if (app.type === 'frontend' && app.dependencies.includes(backendAppName)) {
+			dependentApps.push(appName);
+		}
 	}
 
-	const loadedEndpoints = allLoadedEndpoints;
+	return dependentApps;
+}
 
-	if (loadedEndpoints.length === 0) {
+/**
+ * Get the path to a backend's OpenAPI spec file.
+ */
+export function getBackendOpenApiPath(
+	workspace: NormalizedWorkspace,
+	backendAppName: string,
+): string | null {
+	const app = workspace.apps[backendAppName];
+	if (!app || app.type !== 'backend') {
 		return null;
 	}
 
-	const endpoints = loadedEndpoints.map(({ construct }) => construct);
-
-	const tsGenerator = new OpenApiTsGenerator();
-	const content = await tsGenerator.generate(endpoints, {
-		title: `${appName} API`,
-		version: '1.0.0',
-		description: `Auto-generated API client for ${appName}`,
-	});
+	return join(workspace.root, app.path, '.gkm', 'openapi.ts');
+}
 
-	return { content, endpointCount: loadedEndpoints.length };
+/**
+ * Count endpoints in an OpenAPI spec content.
+ */
+function countEndpoints(content: string): number {
+	const endpointMatches = content.match(
+		/'(GET|POST|PUT|PATCH|DELETE)\s+\/[^']+'/g,
+	);
+	return endpointMatches?.length ?? 0;
 }
 
 /**
- * Generate client for a frontend app from its backend dependencies.
- * Only regenerates if the OpenAPI spec has changed.
+ * Copy the OpenAPI client from a backend to all dependent frontend apps.
+ * Called when the backend's .gkm/openapi.ts file changes.
  */
-export async function generateClientForFrontend(
+export async function copyClientToFrontends(
 	workspace: NormalizedWorkspace,
-	frontendAppName: string,
-	options: { force?: boolean } = {},
-): Promise<ClientGenerationResult[]> {
-	const results: ClientGenerationResult[] = [];
-	const frontendApp = workspace.apps[frontendAppName];
+	backendAppName: string,
+	options: { silent?: boolean } = {},
+): Promise<ClientCopyResult[]> {
+	const log = options.silent ? () => {} : logger.log.bind(logger);
+	const results: ClientCopyResult[] = [];
 
-	if (!frontendApp || frontendApp.type !== 'frontend') {
+	const backendApp = workspace.apps[backendAppName];
+	if (!backendApp || backendApp.type !== 'backend') {
 		return results;
 	}
 
-	const dependencies = frontendApp.dependencies || [];
-	const backendDeps = dependencies.filter((dep) => {
-		const depApp = workspace.apps[dep];
-		return depApp?.type === 'backend' && depApp.routes;
-	});
+	// Get the backend's OpenAPI spec
+	const openApiPath = join(
+		workspace.root,
+		backendApp.path,
+		'.gkm',
+		'openapi.ts',
+	);
 
-	if (backendDeps.length === 0) {
+	if (!existsSync(openApiPath)) {
 		return results;
 	}
 
-	// Determine output directory
-	const clientOutput = frontendApp.client?.output || 'src/api';
-	const frontendPath = join(workspace.root, frontendApp.path);
-	const outputDir = join(frontendPath, clientOutput);
+	const content = await readFile(openApiPath, 'utf-8');
+	const endpointCount = countEndpoints(content);
+
+	// Get all frontends that depend on this backend
+	const dependentFrontends = getDependentFrontends(workspace, backendAppName);
 
-	for (const backendAppName of backendDeps) {
-		const result: ClientGenerationResult = {
+	for (const frontendAppName of dependentFrontends) {
+		const frontendApp = workspace.apps[frontendAppName];
+		if (!frontendApp || frontendApp.type !== 'frontend') {
+			continue;
+		}
+
+		// Check if frontend has client output configured
+		const clientOutput = frontendApp.client?.output;
+		if (!clientOutput) {
+			continue;
+		}
+
+		const result: ClientCopyResult = {
 			frontendApp: frontendAppName,
 			backendApp: backendAppName,
 			outputPath: '',
-			endpointCount: 0,
-			generated: false,
+			endpointCount,
+			success: false,
 		};
 
 		try {
-			// Generate OpenAPI spec for backend
-			const spec = await generateBackendOpenApi(workspace, backendAppName);
-
-			if (!spec) {
-				result.reason = 'No endpoints found in backend';
-				results.push(result);
-				continue;
-			}
-
-			result.endpointCount = spec.endpointCount;
-
-			// Check if spec has changed (unless force)
-			const cacheKey = `${backendAppName}:${frontendAppName}`;
-			const newHash = hashContent(spec.content);
-			const oldHash = specHashCache.get(cacheKey);
-
-			if (!options.force && oldHash === newHash) {
-				result.reason = 'No schema changes detected';
-				results.push(result);
-				continue;
-			}
-
-			// Generate client file
+			const frontendPath = join(workspace.root, frontendApp.path);
+			const outputDir = join(frontendPath, clientOutput);
 			await mkdir(outputDir, { recursive: true });
 
-			// For single dependency, use openapi.ts; for multiple, use {backend}-api.ts
-			const fileName =
-				backendDeps.length === 1 ? 'openapi.ts' : `${backendAppName}-api.ts`;
+			// Use backend app name as filename
+			const fileName = `${backendAppName}.ts`;
 			const outputPath = join(outputDir, fileName);
 
 			// Add header comment with backend reference
 			const backendRelPath = relative(
 				dirname(outputPath),
-				join(workspace.root, workspace.apps[backendAppName]!.path),
+				join(workspace.root, backendApp.path),
 			);
 
 			const clientContent = `/**
@@ -185,123 +205,43 @@ export async function generateClientForFrontend(
  * DO NOT EDIT - This file is automatically regenerated when backend schemas change.
  */
 
-${spec.content}
+${content}
 `;
 
 			await writeFile(outputPath, clientContent);
 
-			// Update cache
-			specHashCache.set(cacheKey, newHash);
-
 			result.outputPath = outputPath;
-			result.generated = true;
-			results.push(result);
+			result.success = true;
+
+			log(
+				`📦 Copied client to ${frontendAppName} from ${backendAppName} (${endpointCount} endpoints)`,
+			);
 		} catch (error) {
-			result.reason = `Error: ${(error as Error).message}`;
-			results.push(result);
+			result.error = (error as Error).message;
 		}
+
+		results.push(result);
 	}
 
 	return results;
 }
 
 /**
- * Generate clients for all frontend apps in the workspace.
+ * Copy clients from all backends to their dependent frontends.
+ * Useful for initial setup or force refresh.
  */
-export async function generateAllClients(
+export async function copyAllClients(
 	workspace: NormalizedWorkspace,
-	options: { force?: boolean; silent?: boolean } = {},
-): Promise<ClientGenerationResult[]> {
-	const log = options.silent ? () => {} : logger.log.bind(logger);
-	const allResults: ClientGenerationResult[] = [];
+	options: { silent?: boolean } = {},
+): Promise<ClientCopyResult[]> {
+	const allResults: ClientCopyResult[] = [];
 
 	for (const [appName, app] of Object.entries(workspace.apps)) {
-		if (app.type === 'frontend' && app.dependencies.length > 0) {
-			const results = await generateClientForFrontend(workspace, appName, {
-				force: options.force,
-			});
-
-			for (const result of results) {
-				if (result.generated) {
-					log(
-						`📦 Generated client for ${result.frontendApp} from ${result.backendApp} (${result.endpointCount} endpoints)`,
-					);
-				}
-				allResults.push(result);
-			}
+		if (app.type === 'backend' && app.routes) {
+			const results = await copyClientToFrontends(workspace, appName, options);
+			allResults.push(...results);
 		}
 	}
 
 	return allResults;
 }
-
-/**
- * Check if a file path matches endpoint patterns that could affect OpenAPI schema.
- * Returns true for changes that should trigger client regeneration.
- */
-export function shouldRegenerateClient(
-	filePath: string,
-	routesPattern: string,
-): boolean {
-	// Normalize path separators
-	const normalizedPath = filePath.replace(/\\/g, '/');
-	const normalizedPattern = routesPattern.replace(/\\/g, '/');
-
-	// Check if the file matches the routes pattern
-	// This is a simple check - the file should be within the routes directory
-	const patternDir = normalizedPattern.split('*')[0] || '';
-
-	if (!normalizedPath.includes(patternDir.replace('./', ''))) {
-		return false;
-	}
-
-	// Check file extension - only TypeScript endpoint files
-	if (!normalizedPath.endsWith('.ts') && !normalizedPath.endsWith('.tsx')) {
-		return false;
-	}
-
-	return true;
-}
-
-/**
- * Get backend apps that a frontend depends on.
- */
-export function getBackendDependencies(
-	workspace: NormalizedWorkspace,
-	frontendAppName: string,
-): string[] {
-	const frontendApp = workspace.apps[frontendAppName];
-	if (!frontendApp || frontendApp.type !== 'frontend') {
-		return [];
-	}
-
-	return frontendApp.dependencies.filter((dep) => {
-		const depApp = workspace.apps[dep];
-		return depApp?.type === 'backend' && depApp.routes;
-	});
-}
-
-/**
- * Get frontend apps that depend on a backend app.
- */
-export function getDependentFrontends(
-	workspace: NormalizedWorkspace,
-	backendAppName: string,
-): string[] {
-	const dependentApps: string[] = [];
-
-	for (const [appName, app] of Object.entries(workspace.apps)) {
-		if (app.type === 'frontend' && app.dependencies.includes(backendAppName)) {
-			dependentApps.push(appName);
-		}
-	}
-
-	return dependentApps;
-}
-
-/**
- * Clear the spec hash cache (useful for testing).
- */
-export function clearSpecHashCache(): void {
-	specHashCache.clear();
-}