@geekmidas/cli 1.9.1 → 1.10.1

package/dist/{openapi-CnvwSRDU.cjs → openapi-BYxAWwok.cjs}

@@ -1,5 +1,6 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_config = require('./config-6JHOwLCx.cjs');
+const require_config = require('./config-D3ORuiUs.cjs');
+const node_fs = require_chunk.__toESM(require("node:fs"));
 const node_path = require_chunk.__toESM(require("node:path"));
 const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
 const fast_glob = require_chunk.__toESM(require("fast-glob"));
@@ -7,6 +8,12 @@ const lodash_kebabcase = require_chunk.__toESM(require("lodash.kebabcase"));
 const __geekmidas_constructs_endpoints = require_chunk.__toESM(require("@geekmidas/constructs/endpoints"));
 const __geekmidas_schema_conversion = require_chunk.__toESM(require("@geekmidas/schema/conversion"));
 
+//#region src/types.ts
+function isPartitionedRoutes(routes) {
+	return typeof routes === "object" && routes !== null && !Array.isArray(routes) && "paths" in routes;
+}
+
+//#endregion
 //#region src/generators/Generator.ts
 var ConstructGenerator = class {
 	static async build(context, outputDir, generator, patterns, options) {
@@ -14,8 +21,13 @@ var ConstructGenerator = class {
 		return generator.build(context, constructs, outputDir, options);
 	}
 	async load(patterns, cwd = process.cwd(), bustCache = false) {
-		const logger = console;
-		const globPatterns = Array.isArray(patterns) ? patterns : patterns ? [patterns] : [];
+		const logger$1 = console;
+		let globPatterns;
+		let partitionFn;
+		if (isPartitionedRoutes(patterns)) {
+			globPatterns = Array.isArray(patterns.paths) ? patterns.paths : [patterns.paths];
+			partitionFn = patterns.partition;
+		} else globPatterns = Array.isArray(patterns) ? patterns : patterns ? [patterns] : [];
 		const files = fast_glob.default.stream(globPatterns, {
 			cwd,
 			absolute: true
@@ -25,6 +37,7 @@ var ConstructGenerator = class {
 			const file = f.toString();
 			const importPath = bustCache ? `${file}?t=${Date.now()}` : file;
 			const module$1 = await import(importPath);
+			const partition = partitionFn ? partitionFn(file) : void 0;
 			for (const [key, construct] of Object.entries(module$1)) if (this.isConstruct(construct)) constructs.push({
 				key,
 				name: (0, lodash_kebabcase.default)(key),
@@ -32,10 +45,11 @@ var ConstructGenerator = class {
 				path: {
 					absolute: file,
 					relative: (0, node_path.relative)(process.cwd(), file)
-				}
+				},
+				partition
 			});
 		} catch (error) {
-			logger.warn(`Failed to load ${f}:`, error.message);
+			logger$1.warn(`Failed to load ${f}:`, error.message);
 			throw new Error("Failed to load constructs. Please check the logs for details.");
 		}
 		return constructs;
@@ -631,7 +645,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 	async build(context, constructs, outputDir, options) {
 		const provider = options?.provider || "aws-apigatewayv2";
 		const enableOpenApi = options?.enableOpenApi || false;
-		const logger = console;
+		const logger$1 = console;
 		const routes = [];
 		if (constructs.length === 0) return routes;
 		if (provider === "server") {
@@ -643,7 +657,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 				handler: (0, node_path.relative)(process.cwd(), appFile),
 				authorizer: "none"
 			});
-			logger.log(`Generated server with ${constructs.length} endpoints${enableOpenApi ? " (OpenAPI enabled)" : ""}`);
+			logger$1.log(`Generated server with ${constructs.length} endpoints${enableOpenApi ? " (OpenAPI enabled)" : ""}`);
 		} else if (provider === "aws-lambda") {
 			const routesDir = (0, node_path.join)(outputDir, "routes");
 			await (0, node_fs_promises.mkdir)(routesDir, { recursive: true });
@@ -659,7 +673,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 					authorizer: construct.authorizer?.name ?? "none"
 				};
 				routes.push(routeInfo);
-				logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
+				logger$1.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
 			}
 		} else for (const { key, construct, path } of constructs) {
 			const handlerFile = await this.generateHandlerFile(outputDir, path.relative, key, provider, construct, context);
@@ -673,7 +687,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 				authorizer: construct.authorizer?.name ?? "none"
 			};
 			routes.push(routeInfo);
-			logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
+			logger$1.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
 		}
 		return routes;
 	}
@@ -762,7 +776,7 @@ export async function setupEndpoints(
 	* Generate optimized endpoints files with nested folder structure (per-endpoint files)
 	*/
 	async generateOptimizedEndpointsFile(endpointsPath, endpoints, _endpointImports, _allExportNames) {
-		const logger = console;
+		const logger$1 = console;
 		const outputDir = (0, node_path.dirname)(endpointsPath);
 		const endpointsDir = (0, node_path.join)(outputDir, "endpoints");
 		await (0, node_fs_promises.mkdir)((0, node_path.join)(endpointsDir, "minimal"), { recursive: true });
@@ -779,11 +793,11 @@ export async function setupEndpoints(
 			};
 		});
 		const summary = summarizeAnalysis(analyses);
-		logger.log(`\n📊 Endpoint Analysis:`);
-		logger.log(`   Total: ${summary.total} endpoints`);
-		logger.log(`   - Minimal (near-raw-Hono): ${summary.byTier.minimal} endpoints`);
-		logger.log(`   - Standard (auth/services): ${summary.byTier.standard} endpoints`);
-		logger.log(`   - Full (audits/rls/rate-limit): ${summary.byTier.full} endpoints`);
+		logger$1.log(`\n📊 Endpoint Analysis:`);
+		logger$1.log(`   Total: ${summary.total} endpoints`);
+		logger$1.log(`   - Minimal (near-raw-Hono): ${summary.byTier.minimal} endpoints`);
+		logger$1.log(`   - Standard (auth/services): ${summary.byTier.standard} endpoints`);
+		logger$1.log(`   - Full (audits/rls/rate-limit): ${summary.byTier.full} endpoints`);
 		const files = generateEndpointFilesNested(analyses, endpointImports);
 		for (const [filename, content] of Object.entries(files)) {
 			const filePath = (0, node_path.join)(endpointsDir, filename);
@@ -792,7 +806,7 @@ export async function setupEndpoints(
 		}
 		const endpointFiles = Object.keys(files).filter((f) => !f.endsWith("index.ts") && !f.endsWith("validators.ts")).length;
 		const indexFiles = Object.keys(files).filter((f) => f.endsWith("index.ts")).length;
-		logger.log(`   Generated ${endpointFiles} endpoint files + ${indexFiles} index files + validators.ts`);
+		logger$1.log(`   Generated ${endpointFiles} endpoint files + ${indexFiles} index files + validators.ts`);
 		return (0, node_path.join)(endpointsDir, "index.ts");
 	}
 	async generateAppFile(outputDir, context) {
@@ -1557,7 +1571,7 @@ export function createApi(options: CreateApiOptions) {
 // API Client Factory
 // ============================================================
 
-import { TypedFetcher, type FetcherOptions } from '@geekmidas/client/fetcher';
+import { createTypedFetcher, type FetcherOptions } from '@geekmidas/client/fetcher';
 import { createEndpointHooks } from '@geekmidas/client/endpoint-hooks';
 import type { QueryClient } from '@tanstack/react-query';
 
@@ -1589,11 +1603,11 @@ export interface CreateApiOptions extends Omit<FetcherOptions, 'baseURL'> {
  */
 export function createApi(options: CreateApiOptions) {
   const { queryClient, ...fetcherOptions } = options;
-  const fetcher = new TypedFetcher<paths>(fetcherOptions);
+  const request = createTypedFetcher<paths>(fetcherOptions);
 
-  const hooks = createEndpointHooks<paths>(fetcher.request.bind(fetcher), { queryClient });
+  const hooks = createEndpointHooks<paths>(request, { queryClient });
 
-  return Object.assign(fetcher.request.bind(fetcher), hooks);
+  return Object.assign(request, hooks);
 }
 `;
 		return `// Auto-generated by @geekmidas/cli - DO NOT EDIT
@@ -1671,6 +1685,108 @@ ${createApiSection}
 	}
 };
 
+//#endregion
+//#region src/workspace/client-generator.ts
+const logger = console;
+/**
+* Normalize routes to an array of patterns.
+* Handles string, string[], and PartitionedRoutes (extracts paths).
+* @internal Exported for use in dev command
+*/
+function normalizeRoutes(routes) {
+	if (!routes) return [];
+	if (isPartitionedRoutes(routes)) return Array.isArray(routes.paths) ? routes.paths : [routes.paths];
+	return Array.isArray(routes) ? routes : [routes];
+}
+/**
+* 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;
+}
+/**
+* Get the path to a backend's OpenAPI spec file.
+*/
+function getBackendOpenApiPath(workspace, backendAppName) {
+	const app = workspace.apps[backendAppName];
+	if (!app || app.type !== "backend") return null;
+	return (0, node_path.join)(workspace.root, app.path, ".gkm", "openapi.ts");
+}
+/**
+* Count endpoints in an OpenAPI spec content.
+*/
+function countEndpoints(content) {
+	const endpointMatches = content.match(/'(GET|POST|PUT|PATCH|DELETE)\s+\/[^']+'/g);
+	return endpointMatches?.length ?? 0;
+}
+/**
+* Copy the OpenAPI client from a backend to all dependent frontend apps.
+* Called when the backend's .gkm/openapi.ts file changes.
+*/
+async function copyClientToFrontends(workspace, backendAppName, options = {}) {
+	const log = options.silent ? () => {} : logger.log.bind(logger);
+	const results = [];
+	const backendApp = workspace.apps[backendAppName];
+	if (!backendApp || backendApp.type !== "backend") return results;
+	const openApiPath = (0, node_path.join)(workspace.root, backendApp.path, ".gkm", "openapi.ts");
+	if (!(0, node_fs.existsSync)(openApiPath)) return results;
+	const content = await (0, node_fs_promises.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,
+			success: false
+		};
+		try {
+			const frontendPath = (0, node_path.join)(workspace.root, frontendApp.path);
+			const outputDir = (0, node_path.join)(frontendPath, clientOutput);
+			await (0, node_fs_promises.mkdir)(outputDir, { recursive: true });
+			const fileName = `${backendAppName}.ts`;
+			const outputPath = (0, node_path.join)(outputDir, fileName);
+			const backendRelPath = (0, node_path.relative)((0, node_path.dirname)(outputPath), (0, node_path.join)(workspace.root, backendApp.path));
+			const clientContent = `/**
+ * Auto-generated API client for ${backendAppName}
+ * Generated from: ${backendRelPath}
+ *
+ * DO NOT EDIT - This file is automatically regenerated when backend schemas change.
+ */
+
+${content}
+`;
+			await (0, node_fs_promises.writeFile)(outputPath, clientContent);
+			result.outputPath = outputPath;
+			result.success = true;
+			log(`📦 Copied client to ${frontendAppName} from ${backendAppName} (${endpointCount} endpoints)`);
+		} catch (error) {
+			result.error = error.message;
+		}
+		results.push(result);
+	}
+	return results;
+}
+/**
+* Copy clients from all backends to their dependent frontends.
+* Useful for initial setup or force refresh.
+*/
+async function copyAllClients(workspace, options = {}) {
+	const allResults = [];
+	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;
+}
+
 //#endregion
 //#region src/openapi.ts
 /**
@@ -1700,13 +1816,13 @@ function resolveOpenApiConfig(config) {
 * @returns Object with output path and endpoint count, or null if disabled
 */
 async function generateOpenApi(config, options = {}) {
-	const logger = options.silent ? { log: () => {} } : console;
+	const logger$1 = options.silent ? { log: () => {} } : console;
 	const openApiConfig = resolveOpenApiConfig(config);
 	if (!openApiConfig.enabled) return null;
 	const endpointGenerator = new EndpointGenerator();
 	const loadedEndpoints = await endpointGenerator.load(config.routes, void 0, options.bustCache);
 	if (loadedEndpoints.length === 0) {
-		logger.log("No valid endpoints found for OpenAPI generation");
+		logger$1.log("No valid endpoints found for OpenAPI generation");
 		return null;
 	}
 	const endpoints = loadedEndpoints.map(({ construct }) => construct);
@@ -1719,34 +1835,34 @@ async function generateOpenApi(config, options = {}) {
 		description: openApiConfig.description
 	});
 	await (0, node_fs_promises.writeFile)(outputPath, tsContent);
-	logger.log(`📄 OpenAPI client generated: ${OPENAPI_OUTPUT_PATH}`);
+	logger$1.log(`📄 OpenAPI client generated: ${OPENAPI_OUTPUT_PATH}`);
 	return {
 		outputPath,
 		endpointCount: loadedEndpoints.length
 	};
 }
 async function openapiCommand(options = {}) {
-	const logger = console;
+	const logger$1 = console;
 	try {
 		const loadedConfig = await require_config.loadWorkspaceConfig(options.cwd);
 		if (loadedConfig.type === "single") {
 			const config = loadedConfig.raw;
 			if (!config.openapi) config.openapi = { enabled: true };
 			const result = await generateOpenApi(config);
-			if (result) logger.log(`Found ${result.endpointCount} endpoints`);
+			if (result) logger$1.log(`Found ${result.endpointCount} endpoints`);
 		} else {
 			const { workspace } = loadedConfig;
 			const workspaceRoot = options.cwd || process.cwd();
 			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");
+				logger$1.log("No backend apps with OpenAPI enabled found");
 				return;
 			}
 			const frontendApps = Object.entries(workspace.apps).filter(([_, app]) => app.type === "frontend" && app.client?.output);
 			for (const [appName, app] of backendApps) {
 				if (app.type !== "backend" || !app.routes) continue;
 				const appPath = (0, node_path.join)(workspaceRoot, app.path);
-				const routes = Array.isArray(app.routes) ? app.routes : [app.routes];
+				const routes = normalizeRoutes(app.routes);
 				const routesGlob = routes.map((r) => (0, node_path.join)(appPath, r));
 				const gkmConfig = {
 					routes: routesGlob,
@@ -1759,7 +1875,7 @@ async function openapiCommand(options = {}) {
 				const result = await generateOpenApi(gkmConfig, { silent: true });
 				process.chdir(originalCwd);
 				if (result) {
-					logger.log(`📄 [${appName}] Generated OpenAPI (${result.endpointCount} endpoints)`);
+					logger$1.log(`📄 [${appName}] Generated OpenAPI (${result.endpointCount} endpoints)`);
 					for (const [frontendName, frontendApp] of frontendApps) {
 						if (frontendApp.type !== "frontend") continue;
 						const dependsOnBackend = !frontendApp.dependencies || frontendApp.dependencies.includes(appName);
@@ -1767,10 +1883,10 @@ async function openapiCommand(options = {}) {
 							const frontendPath = (0, node_path.join)(workspaceRoot, frontendApp.path);
 							const clientOutputPath = (0, node_path.join)(frontendPath, frontendApp.client.output, "openapi.ts");
 							await (0, node_fs_promises.mkdir)((0, node_path.dirname)(clientOutputPath), { recursive: true });
-							const { readFile } = await import("node:fs/promises");
-							const content = await readFile(result.outputPath, "utf-8");
+							const { readFile: readFile$1 } = await import("node:fs/promises");
+							const content = await readFile$1(result.outputPath, "utf-8");
 							await (0, node_fs_promises.writeFile)(clientOutputPath, content);
-							logger.log(`   → [${frontendName}] ${frontendApp.client.output}/openapi.ts`);
+							logger$1.log(`   → [${frontendName}] ${frontendApp.client.output}/openapi.ts`);
 						}
 					}
 				}
@@ -1800,12 +1916,42 @@ Object.defineProperty(exports, 'OPENAPI_OUTPUT_PATH', {
     return OPENAPI_OUTPUT_PATH;
   }
 });
+Object.defineProperty(exports, 'copyAllClients', {
+  enumerable: true,
+  get: function () {
+    return copyAllClients;
+  }
+});
+Object.defineProperty(exports, 'copyClientToFrontends', {
+  enumerable: true,
+  get: function () {
+    return copyClientToFrontends;
+  }
+});
 Object.defineProperty(exports, 'generateOpenApi', {
   enumerable: true,
   get: function () {
     return generateOpenApi;
   }
 });
+Object.defineProperty(exports, 'getBackendOpenApiPath', {
+  enumerable: true,
+  get: function () {
+    return getBackendOpenApiPath;
+  }
+});
+Object.defineProperty(exports, 'isPartitionedRoutes', {
+  enumerable: true,
+  get: function () {
+    return isPartitionedRoutes;
+  }
+});
+Object.defineProperty(exports, 'normalizeRoutes', {
+  enumerable: true,
+  get: function () {
+    return normalizeRoutes;
+  }
+});
 Object.defineProperty(exports, 'openapiCommand', {
   enumerable: true,
   get: function () {
@@ -1818,4 +1964,4 @@ Object.defineProperty(exports, 'resolveOpenApiConfig', {
     return resolveOpenApiConfig;
   }
 });
-//# sourceMappingURL=openapi-CnvwSRDU.cjs.map
+//# sourceMappingURL=openapi-BYxAWwok.cjs.map