@geekmidas/cli 1.9.1 → 1.10.1

package/dist/{openapi-BYlyAbH3.mjs → openapi-DenF-okj.mjs}

@@ -1,11 +1,18 @@
-import { loadWorkspaceConfig } from "./config-DxASSNjr.mjs";
+import { loadWorkspaceConfig } from "./config-jsRYHOHU.mjs";
+import { existsSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import fg from "fast-glob";
 import kebabCase from "lodash.kebabcase";
 import { Endpoint } from "@geekmidas/constructs/endpoints";
 import { StandardSchemaJsonSchema, getSchemaMetadata } from "@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) {
@@ -13,8 +20,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 = fg.stream(globPatterns, {
 			cwd,
 			absolute: true
@@ -24,6 +36,7 @@ var ConstructGenerator = class {
 			const file = f.toString();
 			const importPath = bustCache ? `${file}?t=${Date.now()}` : file;
 			const module = await import(importPath);
+			const partition = partitionFn ? partitionFn(file) : void 0;
 			for (const [key, construct] of Object.entries(module)) if (this.isConstruct(construct)) constructs.push({
 				key,
 				name: kebabCase(key),
@@ -31,10 +44,11 @@ var ConstructGenerator = class {
 				path: {
 					absolute: file,
 					relative: 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;
@@ -630,7 +644,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") {
@@ -642,7 +656,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 				handler: 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 = join(outputDir, "routes");
 			await mkdir(routesDir, { recursive: true });
@@ -658,7 +672,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);
@@ -672,7 +686,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;
 	}
@@ -761,7 +775,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 = dirname(endpointsPath);
 		const endpointsDir = join(outputDir, "endpoints");
 		await mkdir(join(endpointsDir, "minimal"), { recursive: true });
@@ -778,11 +792,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 = join(endpointsDir, filename);
@@ -791,7 +805,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 join(endpointsDir, "index.ts");
 	}
 	async generateAppFile(outputDir, context) {
@@ -1556,7 +1570,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';
 
@@ -1588,11 +1602,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
@@ -1670,6 +1684,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 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 = 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,
+			success: false
+		};
+		try {
+			const frontendPath = join(workspace.root, frontendApp.path);
+			const outputDir = join(frontendPath, clientOutput);
+			await mkdir(outputDir, { recursive: true });
+			const fileName = `${backendAppName}.ts`;
+			const outputPath = join(outputDir, fileName);
+			const backendRelPath = relative(dirname(outputPath), 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 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
 /**
@@ -1699,13 +1815,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);
@@ -1718,34 +1834,34 @@ async function generateOpenApi(config, options = {}) {
 		description: openApiConfig.description
 	});
 	await 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 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 = join(workspaceRoot, app.path);
-				const routes = Array.isArray(app.routes) ? app.routes : [app.routes];
+				const routes = normalizeRoutes(app.routes);
 				const routesGlob = routes.map((r) => join(appPath, r));
 				const gkmConfig = {
 					routes: routesGlob,
@@ -1758,7 +1874,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);
@@ -1769,7 +1885,7 @@ async function openapiCommand(options = {}) {
 							const { readFile: readFile$1 } = await import("node:fs/promises");
 							const content = await readFile$1(result.outputPath, "utf-8");
 							await writeFile(clientOutputPath, content);
-							logger.log(`   → [${frontendName}] ${frontendApp.client.output}/openapi.ts`);
+							logger$1.log(`   → [${frontendName}] ${frontendApp.client.output}/openapi.ts`);
 						}
 					}
 				}
@@ -1781,5 +1897,5 @@ async function openapiCommand(options = {}) {
 }
 
 //#endregion
-export { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig };
-//# sourceMappingURL=openapi-BYlyAbH3.mjs.map
+export { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, copyAllClients, copyClientToFrontends, generateOpenApi, getBackendOpenApiPath, isPartitionedRoutes, normalizeRoutes, openapiCommand, resolveOpenApiConfig };
+//# sourceMappingURL=openapi-DenF-okj.mjs.map