@geekmidas/cli 1.2.2 → 1.2.3

package/dist/index.mjs

@@ -2,7 +2,7 @@
 import { __require, getAppBuildOrder, getDependencyEnvVars, getDeployTargetError, isDeployTargetSupported } from "./workspace-CASoZOjs.mjs";
 import { getAppNameFromCwd, loadAppConfig, loadConfig, loadWorkspaceConfig, parseModuleConfig } from "./config-BQ4a36Rq.mjs";
 import { getCredentialsPath, getDokployCredentials, getDokployRegistryId, getDokployToken, removeDokployCredentials, storeDokployCredentials, storeDokployRegistryId } from "./credentials-DT1dSxIx.mjs";
-import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, OpenApiTsGenerator, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-BZ4Qik9w.mjs";
+import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-NthphEWK.mjs";
 import { getKeyPath, maskPassword, readStageSecrets, secretsExist, setCustomSecret, toEmbeddableSecrets, writeStageSecrets } from "./storage-BMW6yLu3.mjs";
 import { DokployApi } from "./dokploy-api-7k3t7_zd.mjs";
 import { encryptSecrets } from "./encryption-JtMsiGNp.mjs";
@@ -23,7 +23,7 @@ import fg from "fast-glob";
 import { Cron } from "@geekmidas/constructs/crons";
 import { Function } from "@geekmidas/constructs/functions";
 import { Subscriber } from "@geekmidas/constructs/subscribers";
-import { createHash, randomBytes } from "node:crypto";
+import { randomBytes } from "node:crypto";
 import { Client } from "pg";
 import { lookup } from "node:dns/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -31,7 +31,7 @@ import prompts from "prompts";
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "1.2.1";
+var version = "1.2.2";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -627,99 +627,61 @@ export async function setupSubscribers(
 //#region src/workspace/client-generator.ts
 const logger$10 = console;
 /**
-* Cache of OpenAPI spec hashes to detect changes.
-*/
-const specHashCache = /* @__PURE__ */ new Map();
-/**
-* Calculate hash of content for change detection.
+* Get frontend apps that depend on a backend app.
 */
-function hashContent(content) {
-	return createHash("sha256").update(content).digest("hex").slice(0, 16);
+function getDependentFrontends(workspace, backendAppName) {
+	const dependentApps = [];
+	for (const [appName, app] of Object.entries(workspace.apps)) if (app.type === "frontend" && app.dependencies.includes(backendAppName)) dependentApps.push(appName);
+	return dependentApps;
 }
 /**
-* Normalize routes to an array of patterns.
-* @internal Exported for use in dev command
+* Get the path to a backend's OpenAPI spec file.
 */
-function normalizeRoutes(routes) {
-	if (!routes) return [];
-	return Array.isArray(routes) ? routes : [routes];
+function getBackendOpenApiPath(workspace, backendAppName) {
+	const app = workspace.apps[backendAppName];
+	if (!app || app.type !== "backend") return null;
+	return join(workspace.root, app.path, ".gkm", "openapi.ts");
 }
 /**
-* Generate OpenAPI spec for a backend app.
-* Returns the spec content and endpoint count.
+* Count endpoints in an OpenAPI spec content.
 */
-async function generateBackendOpenApi(workspace, appName) {
-	const app = workspace.apps[appName];
-	if (!app || app.type !== "backend" || !app.routes) return null;
-	const appPath = join(workspace.root, app.path);
-	const routesPatterns = normalizeRoutes(app.routes);
-	if (routesPatterns.length === 0) return null;
-	const endpointGenerator = new EndpointGenerator();
-	const allLoadedEndpoints = [];
-	for (const pattern of routesPatterns) {
-		const fullPattern = join(appPath, pattern);
-		const loaded = await endpointGenerator.load(fullPattern);
-		allLoadedEndpoints.push(...loaded);
-	}
-	const loadedEndpoints = allLoadedEndpoints;
-	if (loadedEndpoints.length === 0) 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 {
-		content,
-		endpointCount: loadedEndpoints.length
-	};
+function countEndpoints(content) {
+	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.
 */
-async function generateClientForFrontend(workspace, frontendAppName, options = {}) {
+async function copyClientToFrontends(workspace, backendAppName, options = {}) {
+	const log = options.silent ? () => {} : logger$10.log.bind(logger$10);
 	const results = [];
-	const frontendApp = workspace.apps[frontendAppName];
-	if (!frontendApp || frontendApp.type !== "frontend") return results;
-	const dependencies$1 = frontendApp.dependencies || [];
-	const backendDeps = dependencies$1.filter((dep) => {
-		const depApp = workspace.apps[dep];
-		return depApp?.type === "backend" && depApp.routes;
-	});
-	if (backendDeps.length === 0) return results;
-	const clientOutput = frontendApp.client?.output || "src/api";
-	const frontendPath = join(workspace.root, frontendApp.path);
-	const outputDir = join(frontendPath, clientOutput);
-	for (const backendAppName of backendDeps) {
+	const backendApp = workspace.apps[backendAppName];
+	if (!backendApp || backendApp.type !== "backend") return results;
+	const openApiPath = join(workspace.root, backendApp.path, ".gkm", "openapi.ts");
+	if (!existsSync(openApiPath)) return results;
+	const content = await readFile(openApiPath, "utf-8");
+	const endpointCount = countEndpoints(content);
+	const dependentFrontends = getDependentFrontends(workspace, backendAppName);
+	for (const frontendAppName of dependentFrontends) {
+		const frontendApp = workspace.apps[frontendAppName];
+		if (!frontendApp || frontendApp.type !== "frontend") continue;
+		const clientOutput = frontendApp.client?.output;
+		if (!clientOutput) continue;
 		const result = {
 			frontendApp: frontendAppName,
 			backendApp: backendAppName,
 			outputPath: "",
-			endpointCount: 0,
-			generated: false
+			endpointCount,
+			success: false
 		};
 		try {
-			const spec = await generateBackendOpenApi(workspace, backendAppName);
-			if (!spec) {
-				result.reason = "No endpoints found in backend";
-				results.push(result);
-				continue;
-			}
-			result.endpointCount = spec.endpointCount;
-			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;
-			}
+			const frontendPath = join(workspace.root, frontendApp.path);
+			const outputDir = join(frontendPath, clientOutput);
 			await mkdir(outputDir, { recursive: true });
-			const fileName = backendDeps.length === 1 ? "openapi.ts" : `${backendAppName}-api.ts`;
+			const fileName = `${backendAppName}.ts`;
 			const outputPath = join(outputDir, fileName);
-			const backendRelPath = relative(dirname(outputPath), join(workspace.root, workspace.apps[backendAppName].path));
+			const backendRelPath = relative(dirname(outputPath), join(workspace.root, backendApp.path));
 			const clientContent = `/**
  * Auto-generated API client for ${backendAppName}
  * Generated from: ${backendRelPath}
@@ -727,43 +689,31 @@ async function generateClientForFrontend(workspace, frontendAppName, options = {
  * DO NOT EDIT - This file is automatically regenerated when backend schemas change.
  */
 
-${spec.content}
+${content}
 `;
 			await writeFile(outputPath, clientContent);
-			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.message}`;
-			results.push(result);
+			result.error = 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.
 */
-async function generateAllClients(workspace, options = {}) {
-	const log = options.silent ? () => {} : logger$10.log.bind(logger$10);
+async function copyAllClients(workspace, options = {}) {
 	const allResults = [];
-	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);
-		}
+	for (const [appName, app] of Object.entries(workspace.apps)) if (app.type === "backend" && app.routes) {
+		const results = await copyClientToFrontends(workspace, appName, options);
+		allResults.push(...results);
 	}
 	return allResults;
 }
-/**
-* Get frontend apps that depend on a backend app.
-*/
-function getDependentFrontends(workspace, backendAppName) {
-	const dependentApps = [];
-	for (const [appName, app] of Object.entries(workspace.apps)) if (app.type === "frontend" && app.dependencies.includes(backendAppName)) dependentApps.push(appName);
-	return dependentApps;
-}
 
 //#endregion
 //#region src/dev/index.ts
@@ -1263,10 +1213,10 @@ async function workspaceDevCommand(workspace, options) {
 		if (hasErrors) throw new Error("Frontend app validation failed. Fix the issues above and try again.");
 		logger$9.log("✅ Frontend apps validated");
 	}
-	if (frontendApps.length > 0) {
-		const clientResults = await generateAllClients(workspace, { force: true });
-		const generatedCount = clientResults.filter((r) => r.generated).length;
-		if (generatedCount > 0) logger$9.log(`\n📦 Generated ${generatedCount} API client(s)`);
+	if (frontendApps.length > 0 && backendApps.length > 0) {
+		const clientResults = await copyAllClients(workspace);
+		const copiedCount = clientResults.filter((r) => r.success).length;
+		if (copiedCount > 0) logger$9.log(`\n📦 Copied ${copiedCount} API client(s)`);
 	}
 	await startWorkspaceServices(workspace);
 	const secretsEnv = await loadDevSecrets(workspace);
@@ -1327,65 +1277,42 @@ async function workspaceDevCommand(workspace, options) {
 		stdio: "inherit",
 		env: turboEnv
 	});
-	let endpointWatcher = null;
+	let openApiWatcher = null;
 	if (frontendApps.length > 0 && backendApps.length > 0) {
-		const watchPatterns = [];
-		const backendRouteMap = /* @__PURE__ */ new Map();
-		for (const [appName, app] of backendApps) {
-			const routePatterns = normalizeRoutes(app.routes);
-			for (const routePattern of routePatterns) {
-				const fullPattern = join(workspace.root, app.path, routePattern);
-				watchPatterns.push(fullPattern);
-				const patternKey = join(app.path, routePattern);
-				const existing = backendRouteMap.get(patternKey) || [];
-				backendRouteMap.set(patternKey, [...existing, appName]);
-			}
+		const openApiPaths = [];
+		for (const [appName] of backendApps) {
+			const openApiPath = getBackendOpenApiPath(workspace, appName);
+			if (openApiPath) openApiPaths.push({
+				path: openApiPath,
+				appName
+			});
 		}
-		if (watchPatterns.length > 0) {
-			const resolvedFiles = await fg(watchPatterns, {
-				cwd: workspace.root,
-				absolute: true,
-				onlyFiles: true
+		if (openApiPaths.length > 0) {
+			logger$9.log(`\n👀 Watching ${openApiPaths.length} backend OpenAPI spec(s) for changes`);
+			const pathToApp = new Map(openApiPaths.map((p) => [p.path, p.appName]));
+			openApiWatcher = chokidar.watch(openApiPaths.map((p) => p.path), {
+				persistent: true,
+				ignoreInitial: true,
+				depth: 0
 			});
-			if (resolvedFiles.length > 0) {
-				logger$9.log(`\n👀 Watching ${resolvedFiles.length} endpoint file(s) for schema changes`);
-				endpointWatcher = chokidar.watch(resolvedFiles, {
-					ignored: /(^|[/\\])\../,
-					persistent: true,
-					ignoreInitial: true
-				});
-				let regenerateTimeout = null;
-				endpointWatcher.on("change", async (changedPath) => {
-					if (regenerateTimeout) clearTimeout(regenerateTimeout);
-					regenerateTimeout = setTimeout(async () => {
-						const changedBackends = [];
-						for (const [appName, app] of backendApps) {
-							const routePatterns = normalizeRoutes(app.routes);
-							for (const routePattern of routePatterns) {
-								const routesDir = join(workspace.root, app.path, routePattern.split("*")[0] || "");
-								if (changedPath.startsWith(routesDir.replace(/\/$/, ""))) {
-									changedBackends.push(appName);
-									break;
-								}
-							}
-						}
-						if (changedBackends.length === 0) return;
-						const affectedFrontends = /* @__PURE__ */ new Set();
-						for (const backend of changedBackends) {
-							const dependents = getDependentFrontends(workspace, backend);
-							for (const frontend of dependents) affectedFrontends.add(frontend);
-						}
-						if (affectedFrontends.size === 0) return;
-						logger$9.log(`\n🔄 Detected schema change in ${changedBackends.join(", ")}`);
-						for (const frontend of affectedFrontends) try {
-							const results = await generateClientForFrontend(workspace, frontend);
-							for (const result of results) if (result.generated) logger$9.log(`   📦 Regenerated client for ${result.frontendApp} (${result.endpointCount} endpoints)`);
-						} catch (error) {
-							logger$9.error(`   ❌ Failed to regenerate client for ${frontend}: ${error.message}`);
-						}
-					}, 500);
-				});
-			}
+			let copyTimeout = null;
+			const handleChange = async (changedPath) => {
+				if (copyTimeout) clearTimeout(copyTimeout);
+				copyTimeout = setTimeout(async () => {
+					const backendAppName = pathToApp.get(changedPath);
+					if (!backendAppName) return;
+					logger$9.log(`\n🔄 OpenAPI spec changed for ${backendAppName}`);
+					try {
+						const results = await copyClientToFrontends(workspace, backendAppName, { silent: true });
+						for (const result of results) if (result.success) logger$9.log(`   📦 Copied client to ${result.frontendApp} (${result.endpointCount} endpoints)`);
+						else if (result.error) logger$9.error(`   ❌ Failed to copy client to ${result.frontendApp}: ${result.error}`);
+					} catch (error) {
+						logger$9.error(`   ❌ Failed to copy clients: ${error.message}`);
+					}
+				}, 200);
+			};
+			openApiWatcher.on("change", handleChange);
+			openApiWatcher.on("add", handleChange);
 		}
 	}
 	let isShuttingDown = false;
@@ -1393,7 +1320,7 @@ async function workspaceDevCommand(workspace, options) {
 		if (isShuttingDown) return;
 		isShuttingDown = true;
 		logger$9.log("\n🛑 Shutting down workspace...");
-		if (endpointWatcher) endpointWatcher.close().catch(() => {});
+		if (openApiWatcher) openApiWatcher.close().catch(() => {});
 		if (turboProcess.pid) try {
 			process.kill(-turboProcess.pid, "SIGTERM");
 		} catch {
@@ -1411,7 +1338,7 @@ async function workspaceDevCommand(workspace, options) {
 			reject(error);
 		});
 		turboProcess.on("exit", (code) => {
-			if (endpointWatcher) endpointWatcher.close().catch(() => {});
+			if (openApiWatcher) openApiWatcher.close().catch(() => {});
 			if (code !== null && code !== 0) reject(new Error(`Turbo exited with code ${code}`));
 			else resolve$1();
 		});