@geekmidas/cli 0.10.0 → 0.12.0

package/dist/{openapi-CZLI4QTr.mjs → openapi-BfFlOBCG.mjs}

@@ -1,7 +1,6 @@
-import { loadConfig } from "./config-BrkUalUh.mjs";
-import { relative } from "path";
+import { loadConfig } from "./config-DYULeEv8.mjs";
+import { dirname, join, relative } from "node:path";
 import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join as join$1, relative as relative$1 } from "node:path";
 import fg from "fast-glob";
 import kebabCase from "lodash.kebabcase";
 import { Endpoint } from "@geekmidas/constructs/endpoints";
@@ -41,6 +40,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 = [];
+	const factories = [];
+	if (needsBody) {
+		exports.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.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.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 {
@@ -59,19 +638,19 @@ var EndpointGenerator = class extends ConstructGenerator {
 			routes.push({
 				path: "*",
 				method: "ALL",
-				handler: relative$1(process.cwd(), appFile),
+				handler: relative(process.cwd(), appFile),
 				authorizer: "none"
 			});
 			logger.log(`Generated server with ${constructs.length} endpoints${enableOpenApi ? " (OpenAPI enabled)" : ""}`);
 		} else if (provider === "aws-lambda") {
-			const routesDir = join$1(outputDir, "routes");
+			const routesDir = join(outputDir, "routes");
 			await mkdir(routesDir, { recursive: true });
 			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,
-					handler: relative$1(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
+					handler: relative(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
 					timeout: construct.timeout,
 					memorySize: construct.memorySize,
 					environment: await construct.getEnvironment(),
@@ -85,7 +664,7 @@ var EndpointGenerator = class extends ConstructGenerator {
 			const routeInfo = {
 				path: construct._path,
 				method: construct.method,
-				handler: relative$1(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
+				handler: relative(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
 				timeout: construct.timeout,
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment(),
@@ -98,10 +677,10 @@ var EndpointGenerator = class extends ConstructGenerator {
 	}
 	async generateHandlerFile(outputDir, sourceFile, exportName, provider, _endpoint, context) {
 		const handlerFileName = `${exportName}.ts`;
-		const handlerPath = join$1(outputDir, handlerFileName);
-		const relativePath = relative$1(dirname(handlerPath), sourceFile);
+		const handlerPath = join(outputDir, handlerFileName);
+		const relativePath = relative(dirname(handlerPath), sourceFile);
 		const importPath = relativePath.replace(/\.ts$/, ".js");
-		const relativeEnvParserPath = relative$1(dirname(handlerPath), context.envParserPath);
+		const relativeEnvParserPath = relative(dirname(handlerPath), context.envParserPath);
 		let content;
 		switch (provider) {
 			case "aws-apigatewayv1":
@@ -118,25 +697,26 @@ var EndpointGenerator = class extends ConstructGenerator {
 		await writeFile(handlerPath, content);
 		return handlerPath;
 	}
-	async generateEndpointsFile(outputDir, endpoints, _context) {
+	async generateEndpointsFile(outputDir, endpoints, context) {
 		const endpointsFileName = "endpoints.ts";
-		const endpointsPath = join$1(outputDir, endpointsFileName);
+		const endpointsPath = join(outputDir, endpointsFileName);
 		const importsByFile = /* @__PURE__ */ new Map();
 		for (const { path, key } of endpoints) {
-			const relativePath = relative$1(dirname(endpointsPath), path.relative);
+			const relativePath = relative(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]) => `import { ${exports.join(", ")} } from '${importPath}';`).join("\n");
+		const endpointImports = Array.from(importsByFile.entries()).map(([importPath, exports]) => `import { ${exports.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  ")}
@@ -148,10 +728,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 ? {
@@ -179,11 +756,49 @@ export async function setupEndpoints(
 		await 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 = dirname(endpointsPath);
+		const endpointsDir = join(outputDir, "endpoints");
+		await mkdir(join(endpointsDir, "minimal"), { recursive: true });
+		await mkdir(join(endpointsDir, "standard"), { recursive: true });
+		await mkdir(join(endpointsDir, "full"), { recursive: true });
+		const analyses = endpoints.map(({ key, construct }) => analyzeEndpoint(construct, key));
+		const endpointImports = endpoints.map(({ key, path }) => {
+			const tierDir = join(endpointsDir, "standard");
+			const relativePath = 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 = join(endpointsDir, filename);
+			await mkdir(dirname(filePath), { recursive: true });
+			await 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 join(endpointsDir, "index.ts");
+	}
 	async generateAppFile(outputDir, context) {
+		if (context.production?.enabled) return this.generateProductionAppFile(outputDir, context);
 		const appFileName = "app.ts";
-		const appPath = join$1(outputDir, appFileName);
-		const relativeLoggerPath = relative$1(dirname(appPath), context.loggerPath);
-		const relativeEnvParserPath = relative$1(dirname(appPath), context.envParserPath);
+		const appPath = join(outputDir, appFileName);
+		const relativeLoggerPath = relative(dirname(appPath), context.loggerPath);
+		const relativeEnvParserPath = relative(dirname(appPath), context.envParserPath);
 		const telescopeEnabled = context.telescope?.enabled;
 		const telescopeWebSocketEnabled = context.telescope?.websocket;
 		const usesExternalTelescope = !!context.telescope?.telescopePath;
@@ -191,15 +806,15 @@ export async function setupEndpoints(
 		const usesExternalStudio = !!context.studio?.studioPath;
 		let telescopeImports = "";
 		if (telescopeEnabled) if (usesExternalTelescope) {
-			const relativeTelescopePath = relative$1(dirname(appPath), context.telescope.telescopePath);
-			telescopeImports = `import ${context.telescope.telescopeImportPattern} from '${relativeTelescopePath}';
+			const relativeTelescopePath = relative(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 = relative$1(dirname(appPath), context.studio.studioPath);
-			studioImports = `import ${context.studio.studioImportPattern} from '${relativeStudioPath}';
+			const relativeStudioPath = relative(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';`;
@@ -207,7 +822,7 @@ import { createStudioApp } from '@geekmidas/studio/server/hono';`;
 		let beforeSetupCall = "";
 		let afterSetupCall = "";
 		if (context.hooks?.serverHooksPath) {
-			const relativeHooksPath = relative$1(dirname(appPath), context.hooks.serverHooksPath);
+			const relativeHooksPath = relative(dirname(appPath), context.hooks.serverHooksPath);
 			hooksImports = `import * as serverHooks from '${relativeHooksPath}';`;
 			beforeSetupCall = `
   // Call beforeSetup hook if defined
@@ -228,7 +843,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);
       },
@@ -261,16 +876,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}
@@ -279,13 +894,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
@@ -414,6 +1029,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 = join(outputDir, appFileName);
+		const relativeLoggerPath = relative(dirname(appPath), context.loggerPath);
+		const relativeEnvParserPath = relative(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 = relative(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 writeFile(appPath, content);
+		await this.generateProductionServerEntry(outputDir);
+		return appPath;
+	}
+	/**
+	* Generate production server.ts entry point
+	*/
+	async generateProductionServerEntry(outputDir) {
+		const serverPath = 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 writeFile(serverPath, content);
+	}
 };
 
 //#endregion
@@ -946,7 +1709,7 @@ async function generateOpenApi(config, options = {}) {
 		return null;
 	}
 	const endpoints = loadedEndpoints.map(({ construct }) => construct);
-	const outputPath = join$1(process.cwd(), OPENAPI_OUTPUT_PATH);
+	const outputPath = join(process.cwd(), OPENAPI_OUTPUT_PATH);
 	await mkdir(dirname(outputPath), { recursive: true });
 	const tsGenerator = new OpenApiTsGenerator();
 	const tsContent = await tsGenerator.generate(endpoints, {
@@ -975,4 +1738,4 @@ async function openapiCommand(options = {}) {
 
 //#endregion
 export { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, openapiCommand, resolveOpenApiConfig };
-//# sourceMappingURL=openapi-CZLI4QTr.mjs.map
+//# sourceMappingURL=openapi-BfFlOBCG.mjs.map