@geekmidas/cli 0.6.2 → 0.8.0

package/dist/openapi-CHhTPief.cjs

@@ -0,0 +1,1014 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_config = require('./config-CFls09Ey.cjs');
+const path = require_chunk.__toESM(require("path"));
+const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
+const node_path = require_chunk.__toESM(require("node:path"));
+const fast_glob = require_chunk.__toESM(require("fast-glob"));
+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/generators/Generator.ts
+var ConstructGenerator = class {
+	static async build(context, outputDir, generator, patterns, options) {
+		const constructs = await generator.load(patterns);
+		return generator.build(context, constructs, outputDir, options);
+	}
+	async load(patterns, cwd = process.cwd()) {
+		const logger = console;
+		const globPatterns = Array.isArray(patterns) ? patterns : patterns ? [patterns] : [];
+		const files = fast_glob.default.stream(globPatterns, {
+			cwd,
+			absolute: true
+		});
+		const constructs = [];
+		for await (const f of files) try {
+			const file = f.toString();
+			const module$1 = await import(file);
+			for (const [key, construct] of Object.entries(module$1)) if (this.isConstruct(construct)) constructs.push({
+				key,
+				name: (0, lodash_kebabcase.default)(key),
+				construct,
+				path: {
+					absolute: file,
+					relative: (0, path.relative)(process.cwd(), file)
+				}
+			});
+		} catch (error) {
+			logger.warn(`Failed to load ${f}:`, error.message);
+			throw new Error("Failed to load constructs. Please check the logs for details.");
+		}
+		return constructs;
+	}
+};
+
+//#endregion
+//#region src/generators/EndpointGenerator.ts
+var EndpointGenerator = class extends ConstructGenerator {
+	isConstruct(value) {
+		return __geekmidas_constructs_endpoints.Endpoint.isEndpoint(value);
+	}
+	async build(context, constructs, outputDir, options) {
+		const provider = options?.provider || "aws-apigatewayv2";
+		const enableOpenApi = options?.enableOpenApi || false;
+		const logger = console;
+		const routes = [];
+		if (constructs.length === 0) return routes;
+		if (provider === "server") {
+			await this.generateEndpointsFile(outputDir, constructs, context);
+			const appFile = await this.generateAppFile(outputDir, context);
+			routes.push({
+				path: "*",
+				method: "ALL",
+				handler: (0, node_path.relative)(process.cwd(), appFile),
+				authorizer: "none"
+			});
+			logger.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 });
+			for (const { key, construct, path: path$1 } of constructs) {
+				const handlerFile = await this.generateHandlerFile(routesDir, path$1.relative, key, "aws-apigatewayv2", construct, context);
+				const routeInfo = {
+					path: construct._path,
+					method: construct.method,
+					handler: (0, node_path.relative)(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
+					timeout: construct.timeout,
+					memorySize: construct.memorySize,
+					environment: await construct.getEnvironment(),
+					authorizer: construct.authorizer?.name ?? "none"
+				};
+				routes.push(routeInfo);
+				logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
+			}
+		} else for (const { key, construct, path: path$1 } of constructs) {
+			const handlerFile = await this.generateHandlerFile(outputDir, path$1.relative, key, provider, construct, context);
+			const routeInfo = {
+				path: construct._path,
+				method: construct.method,
+				handler: (0, node_path.relative)(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
+				timeout: construct.timeout,
+				memorySize: construct.memorySize,
+				environment: await construct.getEnvironment(),
+				authorizer: construct.authorizer?.name ?? "none"
+			};
+			routes.push(routeInfo);
+			logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
+		}
+		return routes;
+	}
+	async generateHandlerFile(outputDir, sourceFile, exportName, provider, _endpoint, context) {
+		const handlerFileName = `${exportName}.ts`;
+		const handlerPath = (0, node_path.join)(outputDir, handlerFileName);
+		const relativePath = (0, node_path.relative)((0, node_path.dirname)(handlerPath), sourceFile);
+		const importPath = relativePath.replace(/\.ts$/, ".js");
+		const relativeEnvParserPath = (0, node_path.relative)((0, node_path.dirname)(handlerPath), context.envParserPath);
+		let content;
+		switch (provider) {
+			case "aws-apigatewayv1":
+				content = this.generateAWSApiGatewayV1Handler(importPath, exportName, relativeEnvParserPath, context.envParserImportPattern);
+				break;
+			case "aws-apigatewayv2":
+				content = this.generateAWSApiGatewayV2Handler(importPath, exportName, relativeEnvParserPath, context.envParserImportPattern);
+				break;
+			case "server":
+				content = this.generateServerHandler(importPath, exportName);
+				break;
+			default: throw new Error(`Unsupported provider: ${provider}`);
+		}
+		await (0, node_fs_promises.writeFile)(handlerPath, content);
+		return handlerPath;
+	}
+	async generateEndpointsFile(outputDir, endpoints, _context) {
+		const endpointsFileName = "endpoints.ts";
+		const endpointsPath = (0, node_path.join)(outputDir, endpointsFileName);
+		const importsByFile = /* @__PURE__ */ new Map();
+		for (const { path: path$1, key } of endpoints) {
+			const relativePath = (0, node_path.relative)((0, node_path.dirname)(endpointsPath), path$1.relative);
+			const importPath = relativePath.replace(/\.ts$/, ".js");
+			if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
+			importsByFile.get(importPath).push(key);
+		}
+		const imports = Array.from(importsByFile.entries()).map(([importPath, exports$1]) => `import { ${exports$1.join(", ")} } from '${importPath}';`).join("\n");
+		const allExportNames = endpoints.map(({ key }) => key);
+		const content = `import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import { HonoEndpoint } from '@geekmidas/constructs/hono';
+import { Endpoint } from '@geekmidas/constructs/endpoints';
+import { ServiceDiscovery } from '@geekmidas/services';
+import type { Hono } from 'hono';
+${imports}
+
+const endpoints: Endpoint<any, any, any, any, any, any, any, any, any, any, any, any, any, any>[] = [
+  ${allExportNames.join(",\n  ")}
+];
+
+export async function setupEndpoints(
+  app: Hono,
+  envParser: EnvironmentParser<any>,
+  logger: Logger,
+  enableOpenApi: boolean = true,
+): Promise<void> {
+  const serviceDiscovery = ServiceDiscovery.getInstance(
+    logger,
+    envParser
+  );
+
+  // Configure OpenAPI options based on enableOpenApi flag
+  const openApiOptions: any = enableOpenApi ? {
+    docsPath: '/__docs',
+    openApiOptions: {
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'Generated API documentation'
+    }
+  } : { docsPath: false };
+
+  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, app, openApiOptions);
+
+  // Add Swagger UI if OpenAPI is enabled
+  if (enableOpenApi) {
+    try {
+      const { swaggerUI } = await import('@hono/swagger-ui');
+      app.get('/__docs/ui', swaggerUI({ url: '/__docs' }));
+    } catch {
+      // @hono/swagger-ui not installed, skip Swagger UI
+    }
+  }
+}
+`;
+		await (0, node_fs_promises.writeFile)(endpointsPath, content);
+		return endpointsPath;
+	}
+	async generateAppFile(outputDir, context) {
+		const appFileName = "app.ts";
+		const appPath = (0, node_path.join)(outputDir, appFileName);
+		const relativeLoggerPath = (0, node_path.relative)((0, node_path.dirname)(appPath), context.loggerPath);
+		const relativeEnvParserPath = (0, node_path.relative)((0, node_path.dirname)(appPath), context.envParserPath);
+		const telescopeEnabled = context.telescope?.enabled;
+		const telescopeWebSocketEnabled = context.telescope?.websocket;
+		const usesExternalTelescope = !!context.telescope?.telescopePath;
+		const studioEnabled = context.studio?.enabled;
+		const usesExternalStudio = !!context.studio?.studioPath;
+		let telescopeImports = "";
+		if (telescopeEnabled) if (usesExternalTelescope) {
+			const relativeTelescopePath = (0, node_path.relative)((0, node_path.dirname)(appPath), context.telescope.telescopePath);
+			telescopeImports = `import ${context.telescope.telescopeImportPattern} from '${relativeTelescopePath}';
+import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
+		} else telescopeImports = `import { Telescope, InMemoryStorage } from '@geekmidas/telescope';
+import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
+		let studioImports = "";
+		if (studioEnabled) if (usesExternalStudio) {
+			const relativeStudioPath = (0, node_path.relative)((0, node_path.dirname)(appPath), context.studio.studioPath);
+			studioImports = `import ${context.studio.studioImportPattern} from '${relativeStudioPath}';
+import { createStudioApp } from '@geekmidas/studio/server/hono';`;
+		} else studioImports = `// Studio requires a configured instance - use studio config path
+// import { createStudioApp } from '@geekmidas/studio/server/hono';`;
+		let hooksImports = "";
+		let beforeSetupCall = "";
+		let afterSetupCall = "";
+		if (context.hooks?.serverHooksPath) {
+			const relativeHooksPath = (0, node_path.relative)((0, node_path.dirname)(appPath), context.hooks.serverHooksPath);
+			hooksImports = `import * as serverHooks from '${relativeHooksPath}';`;
+			beforeSetupCall = `
+  // Call beforeSetup hook if defined
+  if (typeof serverHooks.beforeSetup === 'function') {
+    await serverHooks.beforeSetup(honoApp, { envParser, logger });
+  }
+`;
+			afterSetupCall = `
+  // Call afterSetup hook if defined
+  if (typeof serverHooks.afterSetup === 'function') {
+    await serverHooks.afterSetup(honoApp, { envParser, logger });
+  }
+`;
+		}
+		const telescopeWebSocketSetupCode = telescopeWebSocketEnabled ? `
+  // Setup WebSocket for real-time telescope updates
+  try {
+    const { createNodeWebSocket } = await import('@hono/node-ws');
+    const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: honoApp });
+    // Add WebSocket route directly to main app (sub-app routes don't support WS upgrade)
+    honoApp.get('${context.telescope.path}/ws', upgradeWebSocket(() => ({
+      onOpen: (_event: Event, ws: any) => {
+        telescope.addWsClient(ws);
+      },
+      onClose: (_event: Event, ws: any) => {
+        telescope.removeWsClient(ws);
+      },
+      onMessage: (event: MessageEvent, ws: any) => {
+        try {
+          const data = JSON.parse(event.data);
+          if (data.type === 'ping') {
+            ws.send(JSON.stringify({ type: 'pong' }));
+          }
+        } catch {
+          // Ignore invalid messages
+        }
+      },
+    })));
+    // Store injectWebSocket for server entry to call after serve()
+    (honoApp as any).__injectWebSocket = injectWebSocket;
+    logger.info('Telescope WebSocket enabled');
+  } catch (e) {
+    logger.warn({ error: e }, 'WebSocket support not available - install @hono/node-ws for real-time updates');
+  }
+` : "";
+		let telescopeSetup = "";
+		if (telescopeEnabled) if (usesExternalTelescope) telescopeSetup = `
+${telescopeWebSocketSetupCode}
+  // Add telescope middleware (before endpoints to capture all requests)
+  honoApp.use('*', createMiddleware(telescope));
+
+  // Mount telescope UI
+  const telescopeUI = createUI(telescope);
+  honoApp.route('${context.telescope.path}', telescopeUI);
+`;
+		else telescopeSetup = `
+  // Setup Telescope for debugging/monitoring
+  const telescopeStorage = new InMemoryStorage({ maxEntries: ${context.telescope.maxEntries} });
+  const telescope = new Telescope({
+    enabled: true,
+    path: '${context.telescope.path}',
+    ignorePatterns: ${JSON.stringify(context.telescope.ignore)},
+    recordBody: ${context.telescope.recordBody},
+    storage: telescopeStorage,
+  });
+${telescopeWebSocketSetupCode}
+  // Add telescope middleware (before endpoints to capture all requests)
+  honoApp.use('*', createMiddleware(telescope));
+
+  // Mount telescope UI
+  const telescopeUI = createUI(telescope);
+  honoApp.route('${context.telescope.path}', telescopeUI);
+`;
+		let studioSetup = "";
+		if (studioEnabled && usesExternalStudio) studioSetup = `
+  // Mount Studio data browser UI
+  const studioApp = createStudioApp(studio);
+  honoApp.route('${context.studio.path}', studioApp);
+`;
+		const content = `/**
+ * Generated server application
+ *
+ * ⚠️  WARNING: This is for LOCAL DEVELOPMENT ONLY
+ * The subscriber polling mechanism is not production-ready.
+ * For production, use AWS Lambda with SQS/SNS event sources.
+ */
+import { Hono } from 'hono';
+import type { Hono as HonoType } from 'hono';
+import { setupEndpoints } from './endpoints.js';
+import { setupSubscribers } from './subscribers.js';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+${telescopeImports}
+${studioImports}
+${hooksImports}
+
+export interface ServerApp {
+  app: HonoType;
+  start: (options?: {
+    port?: number;
+    serve: (app: HonoType, port: number) => void | Promise<void>;
+  }) => Promise<void>;
+}
+
+/**
+ * Create and configure the Hono application
+ *
+ * @param app - Optional Hono app instance to configure (creates new one if not provided)
+ * @param enableOpenApi - Enable OpenAPI documentation (default: true)
+ * @returns Server app with configured Hono app and start function
+ *
+ * @example
+ * // With Bun
+ * import { createApp } from './.gkm/server/app.js';
+ *
+ * const { app, start } = await createApp();
+ *
+ * await start({
+ *   port: 3000,
+ *   serve: (app, port) => {
+ *     Bun.serve({ port, fetch: app.fetch });
+ *   }
+ * });
+ *
+ * @example
+ * // With Node.js (using @hono/node-server)
+ * import { serve } from '@hono/node-server';
+ * import { createApp } from './.gkm/server/app.js';
+ *
+ * const { app, start } = await createApp();
+ *
+ * await start({
+ *   port: 3000,
+ *   serve: (app, port) => {
+ *     serve({ fetch: app.fetch, port });
+ *   }
+ * });
+ */
+export async function createApp(app?: HonoType, enableOpenApi: boolean = true): Promise<ServerApp> {
+  const honoApp = app || new Hono();
+${telescopeSetup}${beforeSetupCall}${studioSetup}
+  // Setup HTTP endpoints
+  await setupEndpoints(honoApp, envParser, logger, enableOpenApi);
+${afterSetupCall}
+
+  return {
+    app: honoApp,
+    async start(options) {
+      if (!options?.serve) {
+        throw new Error(
+          'serve function is required. Pass a serve function for your runtime:\\n' +
+          '  - Bun: (app, port) => Bun.serve({ port, fetch: app.fetch })\\n' +
+          '  - Node: (app, port) => serve({ fetch: app.fetch, port })'
+        );
+      }
+
+      const port = options.port ?? 3000;
+
+      // Start subscribers in background (non-blocking, local development only)
+      await setupSubscribers(envParser, logger).catch((error) => {
+        logger.error({ error }, 'Failed to start subscribers');
+      });
+
+      logger.info({ port }, 'Starting server');
+
+      // Start HTTP server using provided serve function
+      await options.serve(honoApp, port);
+
+      logger.info({ port }, 'Server started');
+    }
+  };
+}
+
+// Default export for convenience
+export default createApp;
+`;
+		await (0, node_fs_promises.writeFile)(appPath, content);
+		return appPath;
+	}
+	generateAWSApiGatewayV1Handler(importPath, exportName, envParserPath, envParserImportPattern) {
+		return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/constructs/aws';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+	}
+	generateAWSApiGatewayV2Handler(importPath, exportName, envParserPath, envParserImportPattern) {
+		return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/constructs/aws';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+	}
+	generateServerHandler(importPath, exportName) {
+		return `import { ${exportName} } from '${importPath}';
+
+// Server handler - implement based on your server framework
+export const handler = ${exportName};
+`;
+	}
+};
+
+//#endregion
+//#region src/generators/OpenApiTsGenerator.ts
+/**
+* Generates TypeScript OpenAPI module from endpoints.
+* Outputs:
+* - securitySchemes: typed security scheme definitions
+* - endpointAuth: runtime map of endpoints to auth requirements
+* - paths: TypeScript interface for type-safe fetcher
+* - schema interfaces: reusable TypeScript types from Zod/Valibot schemas
+*/
+var OpenApiTsGenerator = class {
+	async generate(endpoints, options = {}) {
+		const { title = "API", version = "1.0.0", description } = options;
+		const endpointInfos = await this.extractEndpointInfos(endpoints);
+		const securitySchemes = this.collectSecuritySchemes(endpointInfos);
+		const endpointAuth = this.buildEndpointAuthMap(endpointInfos);
+		const schemaInterfaces = await this.generateSchemaInterfaces(endpointInfos);
+		const pathsInterface = await this.generatePathsInterface(endpointInfos);
+		return this.buildModule({
+			title,
+			version,
+			description,
+			securitySchemes,
+			endpointAuth,
+			schemaInterfaces,
+			pathsInterface
+		});
+	}
+	async extractEndpointInfos(endpoints) {
+		return endpoints.map((ep) => {
+			const route = ep.route.replace(/:(\w+)/g, "{$1}");
+			const method = ep.method.toUpperCase();
+			const securityScheme = ep.authorizer?.securityScheme;
+			return {
+				endpoint: `${method} ${route}`,
+				route,
+				method,
+				authorizerName: ep.authorizer?.name ?? null,
+				authorizerType: ep.authorizer?.type ?? null,
+				securityScheme: securityScheme ?? null,
+				input: ep.input,
+				output: ep.outputSchema,
+				description: ep.description,
+				tags: ep.tags,
+				operationId: ep.operationId
+			};
+		});
+	}
+	collectSecuritySchemes(endpointInfos) {
+		const schemes = /* @__PURE__ */ new Map();
+		for (const info of endpointInfos) if (info.authorizerName && !schemes.has(info.authorizerName)) {
+			const scheme = info.securityScheme ?? (info.authorizerType ? this.mapAuthorizerToSecurityScheme(info.authorizerType, info.authorizerName) : null);
+			if (scheme) schemes.set(info.authorizerName, {
+				name: info.authorizerName,
+				type: scheme.type,
+				scheme
+			});
+		}
+		return Array.from(schemes.values());
+	}
+	mapAuthorizerToSecurityScheme(type, _name) {
+		switch (type.toLowerCase()) {
+			case "jwt":
+			case "bearer": return {
+				type: "http",
+				scheme: "bearer",
+				bearerFormat: "JWT"
+			};
+			case "iam":
+			case "aws-sigv4":
+			case "sigv4": return {
+				type: "apiKey",
+				in: "header",
+				name: "Authorization",
+				"x-amazon-apigateway-authtype": "awsSigv4"
+			};
+			case "apikey":
+			case "api-key": return {
+				type: "apiKey",
+				in: "header",
+				name: "X-API-Key"
+			};
+			case "oauth2": return {
+				type: "oauth2",
+				flows: {}
+			};
+			case "oidc":
+			case "openidconnect": return {
+				type: "openIdConnect",
+				openIdConnectUrl: ""
+			};
+			default: return {
+				type: "http",
+				scheme: "bearer"
+			};
+		}
+	}
+	buildEndpointAuthMap(endpointInfos) {
+		const authMap = {};
+		for (const info of endpointInfos) authMap[info.endpoint] = info.authorizerName;
+		return authMap;
+	}
+	async generateSchemaInterfaces(endpointInfos) {
+		const interfaces = [];
+		const generatedNames = /* @__PURE__ */ new Set();
+		const collectedDefs = /* @__PURE__ */ new Map();
+		for (const info of endpointInfos) {
+			const baseName = this.getSchemaBaseName(info);
+			if (info.input?.body) {
+				const name = await this.getSchemaName(info.input.body, `${baseName}Input`);
+				if (!generatedNames.has(name)) {
+					const schema = await this.schemaToInterfaceWithDefs(info.input.body, name, collectedDefs);
+					if (schema) {
+						interfaces.push(schema);
+						generatedNames.add(name);
+					}
+				}
+			}
+			if (info.input?.params) {
+				const name = await this.getSchemaName(info.input.params, `${baseName}Params`);
+				if (!generatedNames.has(name)) {
+					const schema = await this.schemaToInterfaceWithDefs(info.input.params, name, collectedDefs);
+					if (schema) {
+						interfaces.push(schema);
+						generatedNames.add(name);
+					}
+				}
+			}
+			if (info.input?.query) {
+				const name = await this.getSchemaName(info.input.query, `${baseName}Query`);
+				if (!generatedNames.has(name)) {
+					const schema = await this.schemaToInterfaceWithDefs(info.input.query, name, collectedDefs);
+					if (schema) {
+						interfaces.push(schema);
+						generatedNames.add(name);
+					}
+				}
+			}
+			if (info.output) {
+				const name = await this.getSchemaName(info.output, `${baseName}Output`);
+				if (!generatedNames.has(name)) {
+					const schema = await this.schemaToInterfaceWithDefs(info.output, name, collectedDefs);
+					if (schema) {
+						interfaces.push(schema);
+						generatedNames.add(name);
+					}
+				}
+			}
+		}
+		for (const [defName, defSchema] of collectedDefs) if (!generatedNames.has(defName)) {
+			const interfaceStr = this.jsonSchemaToInterface(defSchema, defName);
+			interfaces.push(interfaceStr);
+			generatedNames.add(defName);
+		}
+		return interfaces.join("\n\n");
+	}
+	/**
+	* Get the name for a schema, using metadata `id` if available,
+	* otherwise falling back to the provided default name.
+	*/
+	async getSchemaName(schema, defaultName) {
+		try {
+			const metadata = await (0, __geekmidas_schema_conversion.getSchemaMetadata)(schema);
+			if (metadata?.id) return this.pascalCase(metadata.id);
+		} catch {}
+		return defaultName;
+	}
+	getSchemaBaseName(info) {
+		if (info.operationId) return this.pascalCase(info.operationId);
+		const routeParts = info.route.replace(/[{}]/g, "").split("/").filter(Boolean).map((part) => this.pascalCase(part));
+		return `${this.pascalCase(info.method.toLowerCase())}${routeParts.join("")}`;
+	}
+	pascalCase(str) {
+		return str.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toUpperCase());
+	}
+	/**
+	* Convert schema to interface while collecting $defs for nested schemas
+	* with .meta({ id: 'X' }).
+	*/
+	async schemaToInterfaceWithDefs(schema, name, collectedDefs) {
+		try {
+			const vendor = schema["~standard"]?.vendor;
+			if (!vendor || !(vendor in __geekmidas_schema_conversion.StandardSchemaJsonSchema)) return null;
+			const toJsonSchema = __geekmidas_schema_conversion.StandardSchemaJsonSchema[vendor];
+			const jsonSchema = await toJsonSchema(schema);
+			if (!jsonSchema) return null;
+			if (jsonSchema.$defs && typeof jsonSchema.$defs === "object") {
+				for (const [defName, defSchema] of Object.entries(jsonSchema.$defs)) if (!collectedDefs.has(defName)) {
+					const { id,...schemaWithoutId } = defSchema;
+					collectedDefs.set(defName, schemaWithoutId);
+				}
+			}
+			const { $defs,...schemaWithoutDefs } = jsonSchema;
+			return this.jsonSchemaToInterface(schemaWithoutDefs, name);
+		} catch {
+			return null;
+		}
+	}
+	jsonSchemaToInterface(schema, name) {
+		if (schema.type !== "object" || !schema.properties) {
+			const typeStr = this.jsonSchemaTypeToTs(schema);
+			return `export type ${name} = ${typeStr};`;
+		}
+		const props = [];
+		const required = new Set(schema.required || []);
+		for (const [propName, propSchema] of Object.entries(schema.properties)) {
+			const isRequired = required.has(propName);
+			const typeStr = this.jsonSchemaTypeToTs(propSchema);
+			const optionalMark = isRequired ? "" : "?";
+			props.push(`  ${propName}${optionalMark}: ${typeStr};`);
+		}
+		return `export interface ${name} {\n${props.join("\n")}\n}`;
+	}
+	jsonSchemaTypeToTs(schema) {
+		if (!schema) return "unknown";
+		if (schema.$ref) {
+			const refName = schema.$ref.split("/").pop() || "unknown";
+			return refName;
+		}
+		if (schema.anyOf) return schema.anyOf.map((s) => this.jsonSchemaTypeToTs(s)).join(" | ");
+		if (schema.oneOf) return schema.oneOf.map((s) => this.jsonSchemaTypeToTs(s)).join(" | ");
+		if (schema.allOf) return schema.allOf.map((s) => this.jsonSchemaTypeToTs(s)).join(" & ");
+		switch (schema.type) {
+			case "string":
+				if (schema.enum) return schema.enum.map((e) => `'${e}'`).join(" | ");
+				return "string";
+			case "number":
+			case "integer": return "number";
+			case "boolean": return "boolean";
+			case "null": return "null";
+			case "array":
+				if (schema.items) return `Array<${this.jsonSchemaTypeToTs(schema.items)}>`;
+				return "Array<unknown>";
+			case "object":
+				if (schema.properties) {
+					const props = [];
+					const required = new Set(schema.required || []);
+					for (const [propName, propSchema] of Object.entries(schema.properties)) {
+						const isRequired = required.has(propName);
+						const typeStr = this.jsonSchemaTypeToTs(propSchema);
+						const optionalMark = isRequired ? "" : "?";
+						props.push(`${propName}${optionalMark}: ${typeStr}`);
+					}
+					return `{ ${props.join("; ")} }`;
+				}
+				if (schema.additionalProperties) {
+					const valueType = this.jsonSchemaTypeToTs(schema.additionalProperties);
+					return `Record<string, ${valueType}>`;
+				}
+				return "Record<string, unknown>";
+			default: return "unknown";
+		}
+	}
+	async generatePathsInterface(endpointInfos) {
+		const pathGroups = /* @__PURE__ */ new Map();
+		for (const info of endpointInfos) {
+			const existing = pathGroups.get(info.route) || [];
+			existing.push(info);
+			pathGroups.set(info.route, existing);
+		}
+		const pathEntries = [];
+		for (const [route, infos] of pathGroups) {
+			const methodEntries = [];
+			for (const info of infos) {
+				const methodDef = await this.generateMethodDefinition(info);
+				methodEntries.push(`    ${info.method.toLowerCase()}: ${methodDef};`);
+			}
+			const firstWithParams = infos.find((i) => i.input?.params);
+			let paramsEntry = "";
+			if (firstWithParams?.input?.params) {
+				const paramsName = await this.getSchemaName(firstWithParams.input.params, `${this.getSchemaBaseName(firstWithParams)}Params`);
+				paramsEntry = `\n    parameters: {\n      path: ${paramsName};\n    };`;
+			}
+			pathEntries.push(`  '${route}': {${paramsEntry}\n${methodEntries.join("\n")}\n  };`);
+		}
+		return `export interface paths {\n${pathEntries.join("\n")}\n}`;
+	}
+	async generateMethodDefinition(info) {
+		const parts = [];
+		const baseName = this.getSchemaBaseName(info);
+		if (info.input?.body) {
+			const bodyName = await this.getSchemaName(info.input.body, `${baseName}Input`);
+			parts.push(`requestBody: {
+      content: {
+        'application/json': ${bodyName};
+      };
+    }`);
+		}
+		if (info.input?.query) {
+			const queryName = await this.getSchemaName(info.input.query, `${baseName}Query`);
+			parts.push(`parameters: {
+      query: ${queryName};
+    }`);
+		}
+		const outputName = info.output ? await this.getSchemaName(info.output, `${baseName}Output`) : "unknown";
+		parts.push(`responses: {
+      200: {
+        content: {
+          'application/json': ${outputName};
+        };
+      };
+    }`);
+		return `{\n      ${parts.join(";\n      ")};\n    }`;
+	}
+	buildModule(params) {
+		const { title, version, description, securitySchemes, endpointAuth, schemaInterfaces, pathsInterface } = params;
+		const securitySchemesObj = securitySchemes.reduce((acc, s) => {
+			acc[s.name] = s.scheme;
+			return acc;
+		}, {});
+		const schemeNames = securitySchemes.map((s) => `'${s.name}'`).join(" | ");
+		const hasSecuritySchemes = schemeNames.length > 0;
+		const createApiSection = hasSecuritySchemes ? `
+// ============================================================
+// API Client Factory
+// ============================================================
+
+import {
+  createAuthAwareFetcher,
+  type AuthStrategy,
+} from '@geekmidas/client/auth-fetcher';
+import { createEndpointHooks } from '@geekmidas/client/endpoint-hooks';
+import type { QueryClient } from '@tanstack/react-query';
+
+/**
+ * Options for creating the API client.
+ */
+export interface CreateApiOptions {
+  /** Base URL for all API requests (required) */
+  baseURL: string;
+  /** Auth strategies for each security scheme used in this API */
+  authStrategies: Record<SecuritySchemeId, AuthStrategy>;
+  /** Optional React Query client instance */
+  queryClient?: QueryClient;
+  /** Optional request interceptor */
+  onRequest?: (config: RequestInit) => RequestInit | Promise<RequestInit>;
+}
+
+/**
+ * Create a type-safe API client with authentication and React Query hooks.
+ *
+ * @example
+ * \`\`\`typescript
+ * const api = createApi({
+ *   baseURL: 'https://api.example.com',
+ *   authStrategies: {
+ *     jwt: { type: 'bearer', tokenProvider },
+ *   },
+ * });
+ *
+ * // Imperative fetch
+ * const user = await api('GET /users/{id}', { params: { id: '123' } });
+ *
+ * // React Query hooks
+ * const { data } = api.useQuery('GET /users/{id}', { params: { id: '123' } });
+ * const mutation = api.useMutation('POST /users');
+ * \`\`\`
+ */
+export function createApi(options: CreateApiOptions) {
+  const fetcher = createAuthAwareFetcher<paths, typeof endpointAuth, typeof securitySchemes>({
+    baseURL: options.baseURL,
+    endpointAuth,
+    securitySchemes,
+    authStrategies: options.authStrategies,
+    onRequest: options.onRequest,
+  });
+
+  const hooks = createEndpointHooks<paths>(fetcher, { queryClient: options.queryClient });
+
+  return Object.assign(fetcher, hooks);
+}
+` : `
+// ============================================================
+// API Client Factory
+// ============================================================
+
+import { TypedFetcher, type FetcherOptions } from '@geekmidas/client/fetcher';
+import { createEndpointHooks } from '@geekmidas/client/endpoint-hooks';
+import type { QueryClient } from '@tanstack/react-query';
+
+/**
+ * Options for creating the API client.
+ */
+export interface CreateApiOptions extends Omit<FetcherOptions, 'baseURL'> {
+  /** Base URL for all API requests (required) */
+  baseURL: string;
+  /** Optional React Query client instance */
+  queryClient?: QueryClient;
+}
+
+/**
+ * Create a type-safe API client with React Query hooks.
+ *
+ * @example
+ * \`\`\`typescript
+ * const api = createApi({
+ *   baseURL: 'https://api.example.com',
+ * });
+ *
+ * // Imperative fetch
+ * const data = await api('GET /health');
+ *
+ * // React Query hooks
+ * const { data } = api.useQuery('GET /health');
+ * \`\`\`
+ */
+export function createApi(options: CreateApiOptions) {
+  const { queryClient, ...fetcherOptions } = options;
+  const fetcher = new TypedFetcher<paths>(fetcherOptions);
+
+  const hooks = createEndpointHooks<paths>(fetcher.request.bind(fetcher), { queryClient });
+
+  return Object.assign(fetcher.request.bind(fetcher), hooks);
+}
+`;
+		return `// Auto-generated by @geekmidas/cli - DO NOT EDIT
+// Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+// ============================================================
+// Security Scheme Type
+// ============================================================
+
+interface SecuritySchemeObject {
+  type: 'apiKey' | 'http' | 'mutualTLS' | 'oauth2' | 'openIdConnect';
+  description?: string;
+  name?: string;
+  in?: 'query' | 'header' | 'cookie';
+  scheme?: string;
+  bearerFormat?: string;
+  flows?: Record<string, unknown>;
+  openIdConnectUrl?: string;
+  [key: string]: unknown;
+}
+
+// ============================================================
+// API Info
+// ============================================================
+
+export const apiInfo = {
+  title: '${title}',
+  version: '${version}',${description ? `\n  description: '${description.replace(/'/g, "\\'")}',` : ""}
+} as const;
+
+// ============================================================
+// Security Schemes
+// ============================================================
+
+/**
+ * Available security schemes for this API.
+ * Maps authorizer names to OpenAPI security scheme definitions.
+ */
+export const securitySchemes = ${JSON.stringify(securitySchemesObj, null, 2).replace(/"([a-zA-Z_$][a-zA-Z0-9_$]*)":/g, "$1:")} as const satisfies Record<string, SecuritySchemeObject>;
+
+export type SecuritySchemeId = ${schemeNames || "never"};
+
+// ============================================================
+// Endpoint Authentication Map
+// ============================================================
+
+/**
+ * Runtime map of endpoints to their required authentication scheme.
+ * \`null\` indicates a public endpoint (no auth required).
+ */
+export const endpointAuth = ${JSON.stringify(endpointAuth, null, 2).replace(/"([^"]+)":/g, "'$1':")} as const satisfies Record<string, SecuritySchemeId | null>;
+
+export type EndpointString = keyof typeof endpointAuth;
+
+export type AuthenticatedEndpoint = {
+  [K in EndpointString]: typeof endpointAuth[K] extends null ? never : K;
+}[EndpointString];
+
+export type PublicEndpoint = {
+  [K in EndpointString]: typeof endpointAuth[K] extends null ? K : never;
+}[EndpointString];
+
+// ============================================================
+// Schema Definitions
+// ============================================================
+
+${schemaInterfaces}
+
+// ============================================================
+// OpenAPI Paths
+// ============================================================
+
+${pathsInterface}
+${createApiSection}
+`;
+	}
+};
+
+//#endregion
+//#region src/openapi.ts
+/**
+* Fixed output path for generated OpenAPI client (not configurable)
+*/
+const OPENAPI_OUTPUT_PATH = "./.gkm/openapi.ts";
+/**
+* Resolve OpenAPI config from GkmConfig
+*/
+function resolveOpenApiConfig(config) {
+	if (config.openapi === false) return { enabled: false };
+	if (config.openapi === true || config.openapi === void 0) return {
+		enabled: config.openapi === 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
+*/
+async function generateOpenApi(config, options = {}) {
+	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);
+	if (loadedEndpoints.length === 0) {
+		logger.log("No valid endpoints found for OpenAPI generation");
+		return null;
+	}
+	const endpoints = loadedEndpoints.map(({ construct }) => construct);
+	const outputPath = (0, node_path.join)(process.cwd(), OPENAPI_OUTPUT_PATH);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(outputPath), { recursive: true });
+	const tsGenerator = new OpenApiTsGenerator();
+	const tsContent = await tsGenerator.generate(endpoints, {
+		title: openApiConfig.title,
+		version: openApiConfig.version,
+		description: openApiConfig.description
+	});
+	await (0, node_fs_promises.writeFile)(outputPath, tsContent);
+	logger.log(`📄 OpenAPI client generated: ${OPENAPI_OUTPUT_PATH}`);
+	return {
+		outputPath,
+		endpointCount: loadedEndpoints.length
+	};
+}
+async function openapiCommand(options = {}) {
+	const logger = console;
+	try {
+		const config = await require_config.loadConfig(options.cwd);
+		if (!config.openapi) config.openapi = { enabled: true };
+		const result = await generateOpenApi(config);
+		if (result) logger.log(`Found ${result.endpointCount} endpoints`);
+	} catch (error) {
+		throw new Error(`OpenAPI generation failed: ${error.message}`);
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'ConstructGenerator', {
+  enumerable: true,
+  get: function () {
+    return ConstructGenerator;
+  }
+});
+Object.defineProperty(exports, 'EndpointGenerator', {
+  enumerable: true,
+  get: function () {
+    return EndpointGenerator;
+  }
+});
+Object.defineProperty(exports, 'OPENAPI_OUTPUT_PATH', {
+  enumerable: true,
+  get: function () {
+    return OPENAPI_OUTPUT_PATH;
+  }
+});
+Object.defineProperty(exports, 'generateOpenApi', {
+  enumerable: true,
+  get: function () {
+    return generateOpenApi;
+  }
+});
+Object.defineProperty(exports, 'openapiCommand', {
+  enumerable: true,
+  get: function () {
+    return openapiCommand;
+  }
+});
+Object.defineProperty(exports, 'resolveOpenApiConfig', {
+  enumerable: true,
+  get: function () {
+    return resolveOpenApiConfig;
+  }
+});
+//# sourceMappingURL=openapi-CHhTPief.cjs.map