@geekmidas/cli 0.9.0 → 0.12.0

package/dist/{openapi-CHhTPief.cjs → openapi-Bt_1FDpT.cjs}

@@ -1,8 +1,7 @@
 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 require_config = require('./config-AmInkU7k.cjs');
 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"));
 const lodash_kebabcase = require_chunk.__toESM(require("lodash.kebabcase"));
 const __geekmidas_constructs_endpoints = require_chunk.__toESM(require("@geekmidas/constructs/endpoints"));
@@ -31,7 +30,7 @@ var ConstructGenerator = class {
 				construct,
 				path: {
 					absolute: file,
-					relative: (0, path.relative)(process.cwd(), file)
+					relative: (0, node_path.relative)(process.cwd(), file)
 				}
 			});
 		} catch (error) {
@@ -42,6 +41,586 @@ var ConstructGenerator = class {
 	}
 };
 
+//#endregion
+//#region src/build/endpoint-analyzer.ts
+/**
+* Analyze an endpoint to extract its features
+*/
+function analyzeEndpointFeatures(endpoint) {
+	return {
+		hasAuth: !!endpoint.authorizer,
+		hasServices: endpoint.services.length > 0,
+		hasDatabase: !!endpoint.databaseService,
+		hasBodyValidation: !!endpoint.input?.body,
+		hasQueryValidation: !!endpoint.input?.query,
+		hasParamValidation: !!endpoint.input?.params,
+		hasAudits: (endpoint.audits?.length ?? 0) > 0,
+		hasEvents: (endpoint.events?.length ?? 0) > 0,
+		hasRateLimit: !!endpoint.rateLimit,
+		hasRls: !!endpoint.rlsConfig && !endpoint.rlsBypass,
+		hasOutputValidation: !!endpoint.outputSchema
+	};
+}
+/**
+* Determine the optimization tier for an endpoint based on its features
+*/
+function determineEndpointTier(features) {
+	const { hasAuth, hasServices, hasDatabase, hasAudits, hasEvents, hasRateLimit, hasRls } = features;
+	if (!hasAuth && !hasServices && !hasDatabase && !hasAudits && !hasEvents && !hasRateLimit && !hasRls) return "minimal";
+	if (hasAudits || hasRls || hasRateLimit) return "full";
+	return "standard";
+}
+/**
+* Perform complete analysis of an endpoint
+*/
+function analyzeEndpoint(endpoint, exportName) {
+	const features = analyzeEndpointFeatures(endpoint);
+	const tier = determineEndpointTier(features);
+	return {
+		route: endpoint.route,
+		method: endpoint.method,
+		exportName,
+		features,
+		tier,
+		serviceNames: endpoint.services.map((s) => s.serviceName),
+		databaseServiceName: endpoint.databaseService?.serviceName
+	};
+}
+/**
+* Generate a summary of endpoint analysis for logging
+*/
+function summarizeAnalysis(analyses) {
+	const byTier = {
+		minimal: 0,
+		standard: 0,
+		full: 0
+	};
+	const byFeature = {
+		hasAuth: 0,
+		hasServices: 0,
+		hasDatabase: 0,
+		hasBodyValidation: 0,
+		hasQueryValidation: 0,
+		hasParamValidation: 0,
+		hasAudits: 0,
+		hasEvents: 0,
+		hasRateLimit: 0,
+		hasRls: 0,
+		hasOutputValidation: 0
+	};
+	for (const analysis of analyses) {
+		byTier[analysis.tier]++;
+		for (const [feature, enabled] of Object.entries(analysis.features)) if (enabled) byFeature[feature]++;
+	}
+	return {
+		total: analyses.length,
+		byTier,
+		byFeature
+	};
+}
+
+//#endregion
+//#region src/build/handler-templates.ts
+/**
+* Generate validator references for an endpoint
+*/
+function generateValidators(exportName, features) {
+	const validators = [];
+	if (features.hasBodyValidation) validators.push(`validateBody(${exportName})`);
+	if (features.hasQueryValidation) validators.push(`validateQuery(${exportName})`);
+	if (features.hasParamValidation) validators.push(`validateParams(${exportName})`);
+	return validators.length > 0 ? `\n    ${validators.join(",\n    ")},` : "";
+}
+/**
+* Generate a minimal handler (near-raw-Hono performance)
+*
+* Used for: Health checks, public endpoints with no services
+*/
+function generateMinimalHandler(analysis) {
+	const { exportName, features } = analysis;
+	const method = analysis.method.toLowerCase();
+	const validators = generateValidators(exportName, features);
+	const hasValidators = validators.length > 0;
+	if (!hasValidators && !features.hasOutputValidation) return `
+  // Minimal handler: ${analysis.route} (${analysis.method})
+  app.${method}('${analysis.route}', async (c) => {
+    const result = await ${exportName}.handler(
+      {
+        services: {},
+        logger,
+        body: undefined,
+        query: undefined,
+        params: undefined,
+        session: undefined,
+        header: Endpoint.createHeaders(c.req.header()),
+        cookie: Endpoint.createCookies(c.req.header().cookie),
+        auditor: undefined,
+        db: undefined,
+      } as any,
+      { getMetadata: () => ({}) } as any,
+    );
+    return c.json(result, ${exportName}.status as any);
+  });`;
+	return `
+  // Minimal handler with validation: ${analysis.route} (${analysis.method})
+  app.${method}('${analysis.route}',${validators}
+    async (c) => {
+      const result = await ${exportName}.handler(
+        {
+          services: {},
+          logger,
+          body: ${features.hasBodyValidation ? "(c.req.valid as any)('json')" : "undefined"},
+          query: ${features.hasQueryValidation ? "(c.req.valid as any)('query')" : "undefined"},
+          params: ${features.hasParamValidation ? "(c.req.valid as any)('param')" : "undefined"},
+          session: undefined,
+          header: Endpoint.createHeaders(c.req.header()),
+          cookie: Endpoint.createCookies(c.req.header().cookie),
+          auditor: undefined,
+          db: undefined,
+        } as any,
+        { getMetadata: () => ({}) } as any,
+      );
+      ${features.hasOutputValidation ? `const output = await ${exportName}.parseOutput(result);
+      return c.json(output, ${exportName}.status as any);` : `return c.json(result, ${exportName}.status as any);`}
+    }
+  );`;
+}
+/**
+* Generate a standard handler (auth and/or services)
+*
+* Used for: Authenticated endpoints, endpoints with services
+*/
+function generateStandardHandler(analysis) {
+	const { exportName, features } = analysis;
+	const method = analysis.method.toLowerCase();
+	const validators = generateValidators(exportName, features);
+	let serviceResolution = "";
+	if (features.hasServices || features.hasDatabase) serviceResolution = `
+      const services = await serviceDiscovery.register(${exportName}.services);
+      ${features.hasDatabase ? `const db = ${exportName}.databaseService
+        ? (await serviceDiscovery.register([${exportName}.databaseService]) as any)[${exportName}.databaseService.serviceName]
+        : undefined;` : "const db = undefined;"}`;
+	else serviceResolution = `
+      const services = {};
+      const db = undefined;`;
+	let authCode = "";
+	if (features.hasAuth) authCode = `
+      // Authentication
+      const session = await ${exportName}.getSession({
+        services,
+        logger,
+        header,
+        cookie,
+        ...(db !== undefined && { db }),
+      } as any);
+
+      const isAuthorized = await ${exportName}.authorize({
+        header,
+        cookie,
+        services,
+        logger,
+        session,
+      } as any);
+
+      if (!isAuthorized) {
+        return c.json({ error: 'Unauthorized' }, 401);
+      }`;
+	let eventCode = "";
+	if (features.hasEvents) eventCode = `
+      // Publish events on success
+      if (Endpoint.isSuccessStatus(${exportName}.status)) {
+        await (publishConstructEvents as any)(
+          ${exportName},
+          result,
+          serviceDiscovery,
+          logger,
+        );
+      }`;
+	return `
+  // Standard handler: ${analysis.route} (${analysis.method})
+  app.${method}('${analysis.route}',${validators}
+    async (c) => {
+      const headerValues = c.req.header();
+      const header = Endpoint.createHeaders(headerValues);
+      const cookie = Endpoint.createCookies(headerValues.cookie);
+${serviceResolution}
+${authCode}
+
+      const responseBuilder = new ResponseBuilder();
+      const result = await ${exportName}.handler(
+        {
+          services,
+          logger,
+          body: ${features.hasBodyValidation ? "(c.req.valid as any)('json')" : "undefined"},
+          query: ${features.hasQueryValidation ? "(c.req.valid as any)('query')" : "undefined"},
+          params: ${features.hasParamValidation ? "(c.req.valid as any)('param')" : "undefined"},
+          session: ${features.hasAuth ? "session" : "undefined"},
+          header,
+          cookie,
+          auditor: undefined,
+          db,
+        } as any,
+        responseBuilder,
+      );
+
+      let data = result;
+      let metadata = responseBuilder.getMetadata();
+
+      if (Endpoint.hasMetadata(result)) {
+        data = result.data;
+        metadata = result.metadata;
+      }
+
+      ${features.hasOutputValidation ? `const output = ${exportName}.outputSchema
+        ? await ${exportName}.parseOutput(data)
+        : data;` : "const output = data;"}
+${eventCode}
+
+      const status = (metadata.status ?? ${exportName}.status) as any;
+      return c.json(output, status);
+    }
+  );`;
+}
+/**
+* Generate validators.ts - Shared validator middleware factories
+*/
+function generateValidatorsFile(analyses) {
+	const needsBody = analyses.some((a) => a.features.hasBodyValidation);
+	const needsQuery = analyses.some((a) => a.features.hasQueryValidation);
+	const needsParams = analyses.some((a) => a.features.hasParamValidation);
+	if (!needsBody && !needsQuery && !needsParams) return `// No validators needed for this build\nexport {};\n`;
+	const exports$1 = [];
+	const factories = [];
+	if (needsBody) {
+		exports$1.push("validateBody");
+		factories.push(`
+export const validateBody = (endpoint: any) =>
+  validator('json', async (value, c) => {
+    if (!endpoint.input?.body) return undefined;
+    const parsed = await Endpoint.validate(endpoint.input.body, value);
+    if (parsed.issues) return c.json(parsed.issues, 422);
+    return parsed.value;
+  });`);
+	}
+	if (needsQuery) {
+		exports$1.push("validateQuery");
+		factories.push(`
+export const validateQuery = (endpoint: any) =>
+  validator('query', async (_, c) => {
+    if (!endpoint.input?.query) return undefined;
+    const rawQuery = Object.fromEntries(new URL(c.req.url).searchParams);
+    const parsed = await Endpoint.validate(endpoint.input.query, rawQuery);
+    if (parsed.issues) return c.json(parsed.issues, 422);
+    return parsed.value;
+  });`);
+	}
+	if (needsParams) {
+		exports$1.push("validateParams");
+		factories.push(`
+export const validateParams = (endpoint: any) =>
+  validator('param', async (params, c) => {
+    if (!endpoint.input?.params) return undefined;
+    const parsed = await Endpoint.validate(endpoint.input.params, params);
+    if (parsed.issues) return c.json(parsed.issues, 422);
+    return parsed.value;
+  });`);
+	}
+	return `/**
+ * Generated validator middleware factories
+ * Shared across all endpoint tiers that need validation
+ */
+import { validator } from 'hono/validator';
+import { Endpoint } from '@geekmidas/constructs/endpoints';
+${factories.join("\n")}
+`;
+}
+/**
+* Generate a standalone minimal endpoint file
+*/
+function generateMinimalEndpointFile(analysis, endpointImport) {
+	const { exportName, features } = analysis;
+	const needsValidators = features.hasBodyValidation || features.hasQueryValidation || features.hasParamValidation;
+	const validatorImport = needsValidators ? generateValidatorImportsForEndpoint(analysis) : "";
+	const handler = generateMinimalHandler(analysis);
+	return `/**
+ * Minimal endpoint: ${analysis.route} (${analysis.method})
+ * Near-raw-Hono performance
+ */
+import type { Hono } from 'hono';
+import type { Logger } from '@geekmidas/logger';
+import { Endpoint } from '@geekmidas/constructs/endpoints';
+${validatorImport}
+import { ${exportName} } from '${endpointImport.importPath}';
+
+export function setup${capitalize(exportName)}(
+  app: Hono,
+  logger: Logger,
+): void {
+${handler}
+}
+`;
+}
+/**
+* Generate a standalone standard endpoint file
+*/
+function generateStandardEndpointFile(analysis, endpointImport) {
+	const { exportName, features } = analysis;
+	const needsValidators = features.hasBodyValidation || features.hasQueryValidation || features.hasParamValidation;
+	const validatorImport = needsValidators ? generateValidatorImportsForEndpoint(analysis) : "";
+	const eventsImport = features.hasEvents ? `import { publishConstructEvents } from '@geekmidas/constructs/endpoints';` : "";
+	const handler = generateStandardHandler(analysis);
+	return `/**
+ * Standard endpoint: ${analysis.route} (${analysis.method})
+ * Auth and/or services enabled
+ */
+import type { Hono } from 'hono';
+import type { Logger } from '@geekmidas/logger';
+import type { ServiceDiscovery } from '@geekmidas/services';
+import { Endpoint, ResponseBuilder } from '@geekmidas/constructs/endpoints';
+${eventsImport}
+${validatorImport}
+import { ${exportName} } from '${endpointImport.importPath}';
+
+export function setup${capitalize(exportName)}(
+  app: Hono,
+  serviceDiscovery: ServiceDiscovery<any, any>,
+  logger: Logger,
+): void {
+${handler}
+}
+`;
+}
+/**
+* Generate a standalone full endpoint file
+*/
+function generateFullEndpointFile(analysis, endpointImport) {
+	const { exportName } = analysis;
+	return `/**
+ * Full endpoint: ${analysis.route} (${analysis.method})
+ * Complex features: audits, RLS, rate limiting
+ */
+import type { Hono } from 'hono';
+import type { ServiceDiscovery } from '@geekmidas/services';
+import { HonoEndpoint } from '@geekmidas/constructs/hono';
+import { ${exportName} } from '${endpointImport.importPath}';
+
+export function setup${capitalize(exportName)}(
+  app: Hono,
+  serviceDiscovery: ServiceDiscovery<any, any>,
+  openApiOptions: any,
+): void {
+  HonoEndpoint.addRoutes([${exportName}] as any, serviceDiscovery, app, openApiOptions);
+}
+`;
+}
+/**
+* Generate tier index file that imports and calls all endpoint setup functions
+*/
+function generateTierIndexFile(tier, analyses) {
+	const tierEndpoints = analyses.filter((a) => a.tier === tier);
+	if (tierEndpoints.length === 0) {
+		if (tier === "minimal") return `// No minimal-tier endpoints in this build
+import type { Hono } from 'hono';
+import type { Logger } from '@geekmidas/logger';
+
+export function setupMinimalEndpoints(
+  _app: Hono,
+  _logger: Logger,
+): void {
+  // No minimal endpoints
+}
+`;
+		if (tier === "standard") return `// No standard-tier endpoints in this build
+import type { Hono } from 'hono';
+import type { Logger } from '@geekmidas/logger';
+import type { ServiceDiscovery } from '@geekmidas/services';
+
+export function setupStandardEndpoints(
+  _app: Hono,
+  _serviceDiscovery: ServiceDiscovery<any, any>,
+  _logger: Logger,
+): void {
+  // No standard endpoints
+}
+`;
+		return `// No full-tier endpoints in this build
+import type { Hono } from 'hono';
+import type { ServiceDiscovery } from '@geekmidas/services';
+
+export function setupFullEndpoints(
+  _app: Hono,
+  _serviceDiscovery: ServiceDiscovery<any, any>,
+  _enableOpenApi: boolean,
+): void {
+  // No full endpoints
+}
+`;
+	}
+	const imports = tierEndpoints.map((a) => `import { setup${capitalize(a.exportName)} } from './${a.exportName}.js';`).join("\n");
+	if (tier === "minimal") {
+		const calls$1 = tierEndpoints.map((a) => `  setup${capitalize(a.exportName)}(app, logger);`).join("\n");
+		return `/**
+ * Minimal-tier endpoint index (${tierEndpoints.length} endpoints)
+ * Near-raw-Hono performance
+ */
+import type { Hono } from 'hono';
+import type { Logger } from '@geekmidas/logger';
+${imports}
+
+export function setupMinimalEndpoints(
+  app: Hono,
+  logger: Logger,
+): void {
+${calls$1}
+}
+`;
+	}
+	if (tier === "standard") {
+		const calls$1 = tierEndpoints.map((a) => `  setup${capitalize(a.exportName)}(app, serviceDiscovery, logger);`).join("\n");
+		return `/**
+ * Standard-tier endpoint index (${tierEndpoints.length} endpoints)
+ * Auth and/or services enabled
+ */
+import type { Hono } from 'hono';
+import type { Logger } from '@geekmidas/logger';
+import type { ServiceDiscovery } from '@geekmidas/services';
+${imports}
+
+export function setupStandardEndpoints(
+  app: Hono,
+  serviceDiscovery: ServiceDiscovery<any, any>,
+  logger: Logger,
+): void {
+${calls$1}
+}
+`;
+	}
+	const calls = tierEndpoints.map((a) => `  setup${capitalize(a.exportName)}(app, serviceDiscovery, openApiOptions);`).join("\n");
+	return `/**
+ * Full-tier endpoint index (${tierEndpoints.length} endpoints)
+ * Complex features: audits, RLS, rate limiting
+ */
+import type { Hono } from 'hono';
+import type { ServiceDiscovery } from '@geekmidas/services';
+${imports}
+
+export function setupFullEndpoints(
+  app: Hono,
+  serviceDiscovery: ServiceDiscovery<any, any>,
+  enableOpenApi: boolean,
+): void {
+  const openApiOptions: any = enableOpenApi ? {
+    docsPath: '/__docs',
+    openApiOptions: {
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'Generated API documentation'
+    }
+  } : { docsPath: false };
+
+${calls}
+}
+`;
+}
+/**
+* Generate validator imports for a single endpoint
+*/
+function generateValidatorImportsForEndpoint(analysis) {
+	const imports = [];
+	if (analysis.features.hasBodyValidation) imports.push("validateBody");
+	if (analysis.features.hasQueryValidation) imports.push("validateQuery");
+	if (analysis.features.hasParamValidation) imports.push("validateParams");
+	if (imports.length === 0) return "";
+	return `import { ${imports.join(", ")} } from '../validators.js';`;
+}
+/**
+* Capitalize first letter
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+* Generate all endpoint files with nested folder structure (per-endpoint files)
+*/
+function generateEndpointFilesNested(analyses, endpointImports) {
+	const files = {
+		"validators.ts": generateValidatorsFile(analyses),
+		"minimal/index.ts": generateTierIndexFile("minimal", analyses),
+		"standard/index.ts": generateTierIndexFile("standard", analyses),
+		"full/index.ts": generateTierIndexFile("full", analyses),
+		"index.ts": generateNestedIndexFile(analyses)
+	};
+	for (const analysis of analyses) {
+		const endpointImport = endpointImports.find((i) => i.exportName === analysis.exportName);
+		if (!endpointImport) continue;
+		const fileName = `${analysis.tier}/${analysis.exportName}.ts`;
+		switch (analysis.tier) {
+			case "minimal":
+				files[fileName] = generateMinimalEndpointFile(analysis, endpointImport);
+				break;
+			case "standard":
+				files[fileName] = generateStandardEndpointFile(analysis, endpointImport);
+				break;
+			case "full":
+				files[fileName] = generateFullEndpointFile(analysis, endpointImport);
+				break;
+		}
+	}
+	return files;
+}
+/**
+* Generate index.ts for nested structure
+*/
+function generateNestedIndexFile(analyses) {
+	const minimalCount = analyses.filter((a) => a.tier === "minimal").length;
+	const standardCount = analyses.filter((a) => a.tier === "standard").length;
+	const fullCount = analyses.filter((a) => a.tier === "full").length;
+	return `/**
+ * Generated optimized endpoints
+ *
+ * Build-time optimization tiers:
+ * - minimal: ${minimalCount} endpoints (near-raw-Hono)
+ * - standard: ${standardCount} endpoints (auth/services)
+ * - full: ${fullCount} endpoints (audits/rls/rate-limit)
+ */
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import type { Hono } from 'hono';
+import { ServiceDiscovery } from '@geekmidas/services';
+import { setupMinimalEndpoints } from './minimal/index.js';
+import { setupStandardEndpoints } from './standard/index.js';
+import { setupFullEndpoints } from './full/index.js';
+
+export async function setupEndpoints(
+  app: Hono,
+  envParser: EnvironmentParser<any>,
+  logger: Logger,
+  enableOpenApi: boolean = false,
+): Promise<void> {
+  const serviceDiscovery = ServiceDiscovery.getInstance(envParser);
+
+  // Minimal handlers (${minimalCount} endpoints) - near-raw-Hono performance
+  setupMinimalEndpoints(app, logger);
+
+  // Standard handlers (${standardCount} endpoints) - auth/services
+  setupStandardEndpoints(app, serviceDiscovery, logger);
+
+  // Full handlers (${fullCount} endpoints) - audits/rls/rate-limit
+  setupFullEndpoints(app, serviceDiscovery, enableOpenApi);
+
+  // 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
+    }
+  }
+}
+`;
+}
+
 //#endregion
 //#region src/generators/EndpointGenerator.ts
 var EndpointGenerator = class extends ConstructGenerator {
@@ -67,8 +646,8 @@ var EndpointGenerator = class extends ConstructGenerator {
 		} 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);
+			for (const { key, construct, path } of constructs) {
+				const handlerFile = await this.generateHandlerFile(routesDir, path.relative, key, "aws-apigatewayv2", construct, context);
 				const routeInfo = {
 					path: construct._path,
 					method: construct.method,
@@ -81,8 +660,8 @@ var EndpointGenerator = class extends ConstructGenerator {
 				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);
+		} else for (const { key, construct, path } of constructs) {
+			const handlerFile = await this.generateHandlerFile(outputDir, path.relative, key, provider, construct, context);
 			const routeInfo = {
 				path: construct._path,
 				method: construct.method,
@@ -119,25 +698,26 @@ var EndpointGenerator = class extends ConstructGenerator {
 		await (0, node_fs_promises.writeFile)(handlerPath, content);
 		return handlerPath;
 	}
-	async generateEndpointsFile(outputDir, endpoints, _context) {
+	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);
+		for (const { path, key } of endpoints) {
+			const relativePath = (0, node_path.relative)((0, node_path.dirname)(endpointsPath), path.relative);
 			const importPath = relativePath.replace(/\.ts$/, ".js");
 			if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
-			importsByFile.get(importPath).push(key);
+			importsByFile.get(importPath)?.push(key);
 		}
-		const imports = Array.from(importsByFile.entries()).map(([importPath, exports$1]) => `import { ${exports$1.join(", ")} } from '${importPath}';`).join("\n");
+		const endpointImports = Array.from(importsByFile.entries()).map(([importPath, exports$1]) => `import { ${exports$1.join(", ")} } from '${importPath}';`).join("\n");
 		const allExportNames = endpoints.map(({ key }) => key);
+		if (context.production?.enabled && context.production.optimizedHandlers) return this.generateOptimizedEndpointsFile(endpointsPath, endpoints, endpointImports, allExportNames);
 		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}
+${endpointImports}
 
 const endpoints: Endpoint<any, any, any, any, any, any, any, any, any, any, any, any, any, any>[] = [
   ${allExportNames.join(",\n  ")}
@@ -149,10 +729,7 @@ export async function setupEndpoints(
   logger: Logger,
   enableOpenApi: boolean = true,
 ): Promise<void> {
-  const serviceDiscovery = ServiceDiscovery.getInstance(
-    logger,
-    envParser
-  );
+  const serviceDiscovery = ServiceDiscovery.getInstance(envParser);
 
   // Configure OpenAPI options based on enableOpenApi flag
   const openApiOptions: any = enableOpenApi ? {
@@ -180,7 +757,45 @@ export async function setupEndpoints(
 		await (0, node_fs_promises.writeFile)(endpointsPath, content);
 		return endpointsPath;
 	}
+	/**
+	* Generate optimized endpoints files with nested folder structure (per-endpoint files)
+	*/
+	async generateOptimizedEndpointsFile(endpointsPath, endpoints, _endpointImports, _allExportNames) {
+		const logger = 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 });
+		await (0, node_fs_promises.mkdir)((0, node_path.join)(endpointsDir, "standard"), { recursive: true });
+		await (0, node_fs_promises.mkdir)((0, node_path.join)(endpointsDir, "full"), { recursive: true });
+		const analyses = endpoints.map(({ key, construct }) => analyzeEndpoint(construct, key));
+		const endpointImports = endpoints.map(({ key, path }) => {
+			const tierDir = (0, node_path.join)(endpointsDir, "standard");
+			const relativePath = (0, node_path.relative)(tierDir, path.relative);
+			const importPath = relativePath.replace(/\.ts$/, ".js");
+			return {
+				exportName: key,
+				importPath
+			};
+		});
+		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`);
+		const files = generateEndpointFilesNested(analyses, endpointImports);
+		for (const [filename, content] of Object.entries(files)) {
+			const filePath = (0, node_path.join)(endpointsDir, filename);
+			await (0, node_fs_promises.mkdir)((0, node_path.dirname)(filePath), { recursive: true });
+			await (0, node_fs_promises.writeFile)(filePath, content);
+		}
+		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`);
+		return (0, node_path.join)(endpointsDir, "index.ts");
+	}
 	async generateAppFile(outputDir, context) {
+		if (context.production?.enabled) return this.generateProductionAppFile(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);
@@ -192,15 +807,15 @@ export async function setupEndpoints(
 		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}';
+			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}';
+			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';`;
@@ -229,7 +844,7 @@ import { createStudioApp } from '@geekmidas/studio/server/hono';`;
     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(() => ({
+    honoApp.get('${context.telescope?.path}/ws', upgradeWebSocket(() => ({
       onOpen: (_event: Event, ws: any) => {
         telescope.addWsClient(ws);
       },
@@ -262,16 +877,16 @@ ${telescopeWebSocketSetupCode}
 
   // Mount telescope UI
   const telescopeUI = createUI(telescope);
-  honoApp.route('${context.telescope.path}', telescopeUI);
+  honoApp.route('${context.telescope?.path}', telescopeUI);
 `;
 		else telescopeSetup = `
   // Setup Telescope for debugging/monitoring
-  const telescopeStorage = new InMemoryStorage({ maxEntries: ${context.telescope.maxEntries} });
+  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},
+    path: '${context.telescope?.path}',
+    ignorePatterns: ${JSON.stringify(context.telescope?.ignore)},
+    recordBody: ${context.telescope?.recordBody},
     storage: telescopeStorage,
   });
 ${telescopeWebSocketSetupCode}
@@ -280,13 +895,13 @@ ${telescopeWebSocketSetupCode}
 
   // Mount telescope UI
   const telescopeUI = createUI(telescope);
-  honoApp.route('${context.telescope.path}', telescopeUI);
+  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);
+  honoApp.route('${context.studio?.path}', studioApp);
 `;
 		const content = `/**
  * Generated server application
@@ -415,6 +1030,154 @@ export const handler = adapter.handler;
 export const handler = ${exportName};
 `;
 	}
+	/**
+	* Generate a production-optimized app.ts file
+	* No dev tools (Telescope, Studio, WebSocket), includes health checks and graceful shutdown
+	*/
+	async generateProductionAppFile(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 production = context.production;
+		const healthCheckPath = production.healthCheck;
+		const enableGracefulShutdown = production.gracefulShutdown;
+		const enableOpenApi = production.openapi;
+		const includeSubscribers = production.subscribers === "include";
+		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 subscriberSetup = includeSubscribers ? `
+      // Start subscribers in background
+      await setupSubscribers(envParser, logger).catch((error) => {
+        logger.error({ error }, 'Failed to start subscribers');
+      });
+` : "";
+		const subscriberImport = includeSubscribers ? `import { setupSubscribers } from './subscribers.js';` : "";
+		const gracefulShutdownCode = enableGracefulShutdown ? `
+  // Graceful shutdown handling
+  let isShuttingDown = false;
+
+  const shutdown = async () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    logger.info('Graceful shutdown initiated');
+    // Allow in-flight requests to complete (30s timeout)
+    setTimeout(() => process.exit(0), 30000);
+  };
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+` : "";
+		const endpointsImportPath = production.optimizedHandlers ? "./endpoints/index.js" : "./endpoints.js";
+		const content = `/**
+ * Generated production server application
+ *
+ * This is a production-optimized build without dev tools.
+ * - No Telescope debugging dashboard
+ * - No Studio database browser
+ * - No WebSocket updates
+ * - Includes health checks and graceful shutdown
+ */
+import { Hono } from 'hono';
+import type { Hono as HonoType } from 'hono';
+import { setupEndpoints } from '${endpointsImportPath}';
+${subscriberImport}
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+${hooksImports}
+
+export interface ServerApp {
+  app: HonoType;
+  start: (options?: {
+    port?: number;
+    serve: (app: HonoType, port: number) => void | Promise<void>;
+  }) => Promise<void>;
+}
+
+/**
+ * Create and configure the production Hono application
+ */
+export async function createApp(app?: HonoType): Promise<ServerApp> {
+  const honoApp = app || new Hono();
+
+  // Health check endpoint (always first)
+  honoApp.get('${healthCheckPath}', (c) => c.json({ status: 'ok', timestamp: Date.now() }));
+  honoApp.get('/ready', (c) => c.json({ ready: true }));
+${beforeSetupCall}
+  // Setup HTTP endpoints (OpenAPI: ${enableOpenApi})
+  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 ?? Number(process.env.PORT) ?? 3000;
+${gracefulShutdownCode}${subscriberSetup}
+      logger.info({ port }, 'Starting production server');
+
+      // Start HTTP server using provided serve function
+      await options.serve(honoApp, port);
+
+      logger.info({ port }, 'Production server started');
+    }
+  };
+}
+
+// Default export for convenience
+export default createApp;
+`;
+		await (0, node_fs_promises.writeFile)(appPath, content);
+		await this.generateProductionServerEntry(outputDir);
+		return appPath;
+	}
+	/**
+	* Generate production server.ts entry point
+	*/
+	async generateProductionServerEntry(outputDir) {
+		const serverPath = (0, node_path.join)(outputDir, "server.ts");
+		const content = `#!/usr/bin/env node
+/**
+ * Production server entry point
+ * Generated by 'gkm build --provider server --production'
+ */
+import { serve } from '@hono/node-server';
+import { createApp } from './app.js';
+
+const port = Number(process.env.PORT) || 3000;
+
+const { app, start } = await createApp();
+
+await start({
+  port,
+  serve: (app, port) => serve({ fetch: app.fetch, port }),
+});
+`;
+		await (0, node_fs_promises.writeFile)(serverPath, content);
+	}
 };
 
 //#endregion
@@ -700,25 +1463,25 @@ var OpenApiTsGenerator = class {
 		if (info.input?.body) {
 			const bodyName = await this.getSchemaName(info.input.body, `${baseName}Input`);
 			parts.push(`requestBody: {
-      content: {
-        'application/json': ${bodyName};
-      };
-    }`);
+        content: {
+          'application/json': ${bodyName};
+        };
+      }`);
 		}
 		if (info.input?.query) {
 			const queryName = await this.getSchemaName(info.input.query, `${baseName}Query`);
 			parts.push(`parameters: {
-      query: ${queryName};
-    }`);
+        query: ${queryName};
+      }`);
 		}
 		const outputName = info.output ? await this.getSchemaName(info.output, `${baseName}Output`) : "unknown";
 		parts.push(`responses: {
-      200: {
-        content: {
-          'application/json': ${outputName};
+        200: {
+          content: {
+            'application/json': ${outputName};
+          };
         };
-      };
-    }`);
+      }`);
 		return `{\n      ${parts.join(";\n      ")};\n    }`;
 	}
 	buildModule(params) {
@@ -1011,4 +1774,4 @@ Object.defineProperty(exports, 'resolveOpenApiConfig', {
     return resolveOpenApiConfig;
   }
 });
-//# sourceMappingURL=openapi-CHhTPief.cjs.map
+//# sourceMappingURL=openapi-Bt_1FDpT.cjs.map