@geekmidas/cli 0.48.0 → 0.49.0

package/src/build/__tests__/handler-templates.spec.ts

@@ -1,7 +1,13 @@
 import { describe, expect, it } from 'vitest';
 import type { EndpointAnalysis, EndpointFeatures } from '../endpoint-analyzer';
 import {
+	generateEndpointFilesByTier,
+	generateEndpointFilesNested,
+	generateMinimalHandler,
+	generateOptimizedEndpointsFile,
 	generateOptimizedImports,
+	generateOptimizedSetupFunction,
+	generateStandardHandler,
 	generateValidatorFactories,
 } from '../handler-templates';
 
@@ -269,4 +275,945 @@ describe('handler-templates', () => {
 			expect(result).not.toContain('validateParams');
 		});
 	});
+
+	describe('generateMinimalHandler', () => {
+		it('should generate inline handler for truly minimal endpoints', () => {
+			const analysis = createAnalysis({
+				route: '/health',
+				method: 'GET',
+				exportName: 'healthEndpoint',
+				tier: 'minimal',
+			});
+
+			const result = generateMinimalHandler(analysis);
+
+			expect(result).toContain("app.get('/health'");
+			expect(result).toContain('healthEndpoint.handler');
+			expect(result).toContain('Minimal handler: /health (GET)');
+			expect(result).toContain('c.json(result');
+		});
+
+		it('should generate handler with body validation', () => {
+			const analysis = createAnalysis({
+				route: '/users',
+				method: 'POST',
+				exportName: 'createUserEndpoint',
+				tier: 'minimal',
+				features: createFeatures({ hasBodyValidation: true }),
+			});
+
+			const result = generateMinimalHandler(analysis);
+
+			expect(result).toContain("app.post('/users'");
+			expect(result).toContain('Minimal handler with validation');
+			expect(result).toContain("(c.req.valid as any)('json')");
+		});
+
+		it('should generate handler with query validation', () => {
+			const analysis = createAnalysis({
+				route: '/search',
+				method: 'GET',
+				exportName: 'searchEndpoint',
+				tier: 'minimal',
+				features: createFeatures({ hasQueryValidation: true }),
+			});
+
+			const result = generateMinimalHandler(analysis);
+
+			expect(result).toContain("(c.req.valid as any)('query')");
+		});
+
+		it('should generate handler with param validation', () => {
+			const analysis = createAnalysis({
+				route: '/users/:id',
+				method: 'GET',
+				exportName: 'getUserEndpoint',
+				tier: 'minimal',
+				features: createFeatures({ hasParamValidation: true }),
+			});
+
+			const result = generateMinimalHandler(analysis);
+
+			expect(result).toContain("(c.req.valid as any)('param')");
+		});
+
+		it('should generate handler with output validation', () => {
+			const analysis = createAnalysis({
+				route: '/data',
+				method: 'GET',
+				exportName: 'dataEndpoint',
+				tier: 'minimal',
+				features: createFeatures({ hasOutputValidation: true }),
+			});
+
+			const result = generateMinimalHandler(analysis);
+
+			expect(result).toContain('parseOutput(result)');
+		});
+
+		it('should generate handler with all validation types', () => {
+			const analysis = createAnalysis({
+				route: '/items/:id',
+				method: 'PUT',
+				exportName: 'updateItemEndpoint',
+				tier: 'minimal',
+				features: createFeatures({
+					hasBodyValidation: true,
+					hasQueryValidation: true,
+					hasParamValidation: true,
+					hasOutputValidation: true,
+				}),
+			});
+
+			const result = generateMinimalHandler(analysis);
+
+			expect(result).toContain("(c.req.valid as any)('json')");
+			expect(result).toContain("(c.req.valid as any)('query')");
+			expect(result).toContain("(c.req.valid as any)('param')");
+			expect(result).toContain('parseOutput(result)');
+		});
+	});
+
+	describe('generateStandardHandler', () => {
+		it('should generate handler with services', () => {
+			const analysis = createAnalysis({
+				route: '/api/data',
+				method: 'GET',
+				exportName: 'dataEndpoint',
+				tier: 'standard',
+				features: createFeatures({ hasServices: true }),
+			});
+
+			const result = generateStandardHandler(analysis);
+
+			expect(result).toContain('Standard handler: /api/data (GET)');
+			expect(result).toContain('serviceDiscovery.register');
+			expect(result).toContain('ResponseBuilder');
+		});
+
+		it('should generate handler with database', () => {
+			const analysis = createAnalysis({
+				route: '/api/users',
+				method: 'GET',
+				exportName: 'usersEndpoint',
+				tier: 'standard',
+				features: createFeatures({ hasDatabase: true }),
+			});
+
+			const result = generateStandardHandler(analysis);
+
+			expect(result).toContain('databaseService');
+			expect(result).toContain('serviceDiscovery.register');
+		});
+
+		it('should generate handler with authentication', () => {
+			const analysis = createAnalysis({
+				route: '/api/profile',
+				method: 'GET',
+				exportName: 'profileEndpoint',
+				tier: 'standard',
+				features: createFeatures({ hasAuth: true }),
+			});
+
+			const result = generateStandardHandler(analysis);
+
+			expect(result).toContain('// Authentication');
+			expect(result).toContain('getSession');
+			expect(result).toContain('authorize');
+			expect(result).toContain('Unauthorized');
+		});
+
+		it('should generate handler with events', () => {
+			const analysis = createAnalysis({
+				route: '/api/orders',
+				method: 'POST',
+				exportName: 'createOrderEndpoint',
+				tier: 'standard',
+				features: createFeatures({ hasEvents: true }),
+			});
+
+			const result = generateStandardHandler(analysis);
+
+			expect(result).toContain('publishConstructEvents');
+			expect(result).toContain('isSuccessStatus');
+		});
+
+		it('should generate handler without services when not needed', () => {
+			const analysis = createAnalysis({
+				route: '/api/simple',
+				method: 'GET',
+				exportName: 'simpleEndpoint',
+				tier: 'standard',
+				features: createFeatures({ hasAuth: true }),
+			});
+
+			const result = generateStandardHandler(analysis);
+
+			expect(result).toContain('const services = {};');
+			expect(result).toContain('const db = undefined;');
+		});
+
+		it('should generate handler with body validation', () => {
+			const analysis = createAnalysis({
+				route: '/api/items',
+				method: 'POST',
+				exportName: 'createItemEndpoint',
+				tier: 'standard',
+				features: createFeatures({
+					hasServices: true,
+					hasBodyValidation: true,
+				}),
+			});
+
+			const result = generateStandardHandler(analysis);
+
+			expect(result).toContain("(c.req.valid as any)('json')");
+		});
+
+		it('should generate handler with all features', () => {
+			const analysis = createAnalysis({
+				route: '/api/complex/:id',
+				method: 'PUT',
+				exportName: 'complexEndpoint',
+				tier: 'standard',
+				features: createFeatures({
+					hasAuth: true,
+					hasServices: true,
+					hasDatabase: true,
+					hasBodyValidation: true,
+					hasQueryValidation: true,
+					hasParamValidation: true,
+					hasEvents: true,
+				}),
+			});
+
+			const result = generateStandardHandler(analysis);
+
+			expect(result).toContain('getSession');
+			expect(result).toContain('serviceDiscovery.register');
+			expect(result).toContain('databaseService');
+			expect(result).toContain("(c.req.valid as any)('json')");
+			expect(result).toContain("(c.req.valid as any)('query')");
+			expect(result).toContain("(c.req.valid as any)('param')");
+			expect(result).toContain('publishConstructEvents');
+		});
+
+		it('should generate handler with output validation', () => {
+			const analysis = createAnalysis({
+				route: '/api/data',
+				method: 'GET',
+				exportName: 'dataEndpoint',
+				tier: 'standard',
+				features: createFeatures({
+					hasServices: true,
+					hasOutputValidation: true,
+				}),
+			});
+
+			const result = generateStandardHandler(analysis);
+
+			expect(result).toContain('outputSchema');
+			expect(result).toContain('parseOutput(data)');
+		});
+	});
+
+	describe('generateOptimizedSetupFunction', () => {
+		it('should generate setup function with only minimal endpoints', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const result = generateOptimizedSetupFunction(analyses, ['healthEndpoint']);
+
+			expect(result).toContain('export async function setupEndpoints');
+			expect(result).toContain('Minimal handlers (1 endpoints)');
+			expect(result).toContain('Standard handlers (0 endpoints)');
+			expect(result).toContain("app.get('/health'");
+			expect(result).not.toContain('HonoEndpoint.addRoutes');
+		});
+
+		it('should generate setup function with full endpoints', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/audit',
+					method: 'POST',
+					exportName: 'auditEndpoint',
+					tier: 'full',
+					features: createFeatures({ hasAudits: true }),
+				}),
+			];
+
+			const result = generateOptimizedSetupFunction(analyses, ['auditEndpoint']);
+
+			expect(result).toContain('import { HonoEndpoint }');
+			expect(result).toContain('HonoEndpoint.addRoutes');
+			expect(result).toContain('auditEndpoint');
+			expect(result).toContain('openApiOptions');
+		});
+
+		it('should generate setup function with mixed tiers', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+				createAnalysis({
+					route: '/api/users',
+					method: 'GET',
+					exportName: 'usersEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true }),
+				}),
+				createAnalysis({
+					route: '/api/audit',
+					method: 'POST',
+					exportName: 'auditEndpoint',
+					tier: 'full',
+					features: createFeatures({ hasAudits: true }),
+				}),
+			];
+
+			const result = generateOptimizedSetupFunction(analyses, [
+				'healthEndpoint',
+				'usersEndpoint',
+				'auditEndpoint',
+			]);
+
+			expect(result).toContain('Minimal handlers (1 endpoints)');
+			expect(result).toContain('Standard handlers (1 endpoints)');
+			expect(result).toContain("app.get('/health'");
+			expect(result).toContain("app.get('/api/users'");
+			expect(result).toContain('HonoEndpoint.addRoutes');
+		});
+
+		it('should add swagger UI setup when enableOpenApi', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const result = generateOptimizedSetupFunction(analyses, ['healthEndpoint']);
+
+			expect(result).toContain('if (enableOpenApi)');
+			expect(result).toContain('swaggerUI');
+			expect(result).toContain('/__docs/ui');
+		});
+	});
+
+	describe('generateOptimizedEndpointsFile', () => {
+		it('should generate complete file with all sections', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+				createAnalysis({
+					route: '/api/users',
+					method: 'POST',
+					exportName: 'createUserEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true, hasBodyValidation: true }),
+				}),
+			];
+
+			const endpointImports = `import { healthEndpoint } from './endpoints/health';\nimport { createUserEndpoint } from './endpoints/users';`;
+
+			const result = generateOptimizedEndpointsFile(
+				analyses,
+				endpointImports,
+				['healthEndpoint', 'createUserEndpoint'],
+			);
+
+			expect(result).toContain('Generated optimized endpoints file');
+			expect(result).toContain('minimal: 1 endpoints');
+			expect(result).toContain('standard: 1 endpoints');
+			expect(result).toContain('full: 0 endpoints');
+			expect(result).toContain("import type { EnvironmentParser }");
+			expect(result).toContain("import { healthEndpoint }");
+			expect(result).toContain("import { createUserEndpoint }");
+			expect(result).toContain('validateBody');
+			expect(result).toContain('export async function setupEndpoints');
+		});
+
+		it('should not generate validator factories when not needed', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const result = generateOptimizedEndpointsFile(
+				analyses,
+				"import { healthEndpoint } from './endpoints/health';",
+				['healthEndpoint'],
+			);
+
+			expect(result).not.toContain('validateBody');
+			expect(result).not.toContain('validateQuery');
+			expect(result).not.toContain('validateParams');
+		});
+	});
+
+	describe('generateEndpointFilesByTier', () => {
+		it('should generate all required files', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files).toHaveProperty('validators.ts');
+			expect(files).toHaveProperty('minimal.ts');
+			expect(files).toHaveProperty('standard.ts');
+			expect(files).toHaveProperty('full.ts');
+			expect(files).toHaveProperty('index.ts');
+		});
+
+		it('should generate validators file with needed validators', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/users',
+					method: 'POST',
+					exportName: 'createUserEndpoint',
+					tier: 'minimal',
+					features: createFeatures({ hasBodyValidation: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'createUserEndpoint', importPath: '../endpoints/users' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['validators.ts']).toContain('export const validateBody');
+			expect(files['validators.ts']).toContain("validator('json'");
+		});
+
+		it('should generate empty validators file when no validation needed', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['validators.ts']).toContain('No validators needed');
+			expect(files['validators.ts']).toContain('export {}');
+		});
+
+		it('should generate minimal file with handlers', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['minimal.ts']).toContain('Minimal-tier endpoint handlers');
+			expect(files['minimal.ts']).toContain('1 endpoints');
+			expect(files['minimal.ts']).toContain('export function setupMinimalEndpoints');
+			expect(files['minimal.ts']).toContain("import { healthEndpoint }");
+			expect(files['minimal.ts']).toContain("app.get('/health'");
+		});
+
+		it('should generate empty minimal file when no minimal endpoints', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/users',
+					method: 'GET',
+					exportName: 'usersEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'usersEndpoint', importPath: '../endpoints/users' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['minimal.ts']).toContain('No minimal-tier endpoints');
+			expect(files['minimal.ts']).toContain('_app: Hono');
+		});
+
+		it('should generate standard file with handlers', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/users',
+					method: 'GET',
+					exportName: 'usersEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'usersEndpoint', importPath: '../endpoints/users' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['standard.ts']).toContain('Standard-tier endpoint handlers');
+			expect(files['standard.ts']).toContain('1 endpoints');
+			expect(files['standard.ts']).toContain('export function setupStandardEndpoints');
+			expect(files['standard.ts']).toContain("import { usersEndpoint }");
+		});
+
+		it('should generate standard file with events import when needed', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/orders',
+					method: 'POST',
+					exportName: 'createOrderEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasEvents: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'createOrderEndpoint', importPath: '../endpoints/orders' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['standard.ts']).toContain('import { publishConstructEvents }');
+		});
+
+		it('should generate full file with HonoEndpoint', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/audit',
+					method: 'POST',
+					exportName: 'auditEndpoint',
+					tier: 'full',
+					features: createFeatures({ hasAudits: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'auditEndpoint', importPath: '../endpoints/audit' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['full.ts']).toContain('Full-tier endpoint handlers');
+			expect(files['full.ts']).toContain('import { HonoEndpoint }');
+			expect(files['full.ts']).toContain('HonoEndpoint.addRoutes');
+			expect(files['full.ts']).toContain("import { auditEndpoint }");
+		});
+
+		it('should generate empty full file when no full endpoints', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['full.ts']).toContain('No full-tier endpoints');
+		});
+
+		it('should generate index file with correct counts', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+				createAnalysis({
+					route: '/api/users',
+					method: 'GET',
+					exportName: 'usersEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true }),
+				}),
+				createAnalysis({
+					route: '/api/audit',
+					method: 'POST',
+					exportName: 'auditEndpoint',
+					tier: 'full',
+					features: createFeatures({ hasAudits: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../endpoints/health' },
+				{ exportName: 'usersEndpoint', importPath: '../endpoints/users' },
+				{ exportName: 'auditEndpoint', importPath: '../endpoints/audit' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['index.ts']).toContain('minimal: 1 endpoints');
+			expect(files['index.ts']).toContain('standard: 1 endpoints');
+			expect(files['index.ts']).toContain('full: 1 endpoints');
+			expect(files['index.ts']).toContain("import { setupMinimalEndpoints }");
+			expect(files['index.ts']).toContain("import { setupStandardEndpoints }");
+			expect(files['index.ts']).toContain("import { setupFullEndpoints }");
+			expect(files['index.ts']).toContain('export async function setupEndpoints');
+		});
+
+		it('should include validator imports in minimal file when needed', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/users',
+					method: 'POST',
+					exportName: 'createUserEndpoint',
+					tier: 'minimal',
+					features: createFeatures({ hasBodyValidation: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'createUserEndpoint', importPath: '../endpoints/users' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['minimal.ts']).toContain("import { validateBody } from './validators.js'");
+		});
+
+		it('should include validator imports in standard file when needed', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/users',
+					method: 'POST',
+					exportName: 'createUserEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true, hasBodyValidation: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'createUserEndpoint', importPath: '../endpoints/users' },
+			];
+
+			const files = generateEndpointFilesByTier(analyses, endpointImports);
+
+			expect(files['standard.ts']).toContain("import { validateBody } from './validators.js'");
+		});
+	});
+
+	describe('generateEndpointFilesNested', () => {
+		it('should generate base files', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files).toHaveProperty('validators.ts');
+			expect(files).toHaveProperty('minimal/index.ts');
+			expect(files).toHaveProperty('standard/index.ts');
+			expect(files).toHaveProperty('full/index.ts');
+			expect(files).toHaveProperty('index.ts');
+		});
+
+		it('should generate individual endpoint files for minimal tier', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files).toHaveProperty('minimal/healthEndpoint.ts');
+			expect(files['minimal/healthEndpoint.ts']).toContain('Minimal endpoint: /health (GET)');
+			expect(files['minimal/healthEndpoint.ts']).toContain('export function setupHealthEndpoint');
+			expect(files['minimal/healthEndpoint.ts']).toContain("import { healthEndpoint }");
+		});
+
+		it('should generate individual endpoint files for standard tier', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/users',
+					method: 'GET',
+					exportName: 'usersEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'usersEndpoint', importPath: '../../endpoints/users' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files).toHaveProperty('standard/usersEndpoint.ts');
+			expect(files['standard/usersEndpoint.ts']).toContain('Standard endpoint: /api/users (GET)');
+			expect(files['standard/usersEndpoint.ts']).toContain('export function setupUsersEndpoint');
+			expect(files['standard/usersEndpoint.ts']).toContain("import { usersEndpoint }");
+		});
+
+		it('should generate individual endpoint files for full tier', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/audit',
+					method: 'POST',
+					exportName: 'auditEndpoint',
+					tier: 'full',
+					features: createFeatures({ hasAudits: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'auditEndpoint', importPath: '../../endpoints/audit' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files).toHaveProperty('full/auditEndpoint.ts');
+			expect(files['full/auditEndpoint.ts']).toContain('Full endpoint: /api/audit (POST)');
+			expect(files['full/auditEndpoint.ts']).toContain('export function setupAuditEndpoint');
+			expect(files['full/auditEndpoint.ts']).toContain('import { HonoEndpoint }');
+		});
+
+		it('should generate tier index files that import individual endpoints', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+				createAnalysis({
+					route: '/ready',
+					method: 'GET',
+					exportName: 'readyEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../../endpoints/health' },
+				{ exportName: 'readyEndpoint', importPath: '../../endpoints/ready' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files['minimal/index.ts']).toContain("import { setupHealthEndpoint } from './healthEndpoint.js'");
+			expect(files['minimal/index.ts']).toContain("import { setupReadyEndpoint } from './readyEndpoint.js'");
+			expect(files['minimal/index.ts']).toContain('setupHealthEndpoint(app, logger)');
+			expect(files['minimal/index.ts']).toContain('setupReadyEndpoint(app, logger)');
+		});
+
+		it('should generate empty tier index for tiers with no endpoints', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files['standard/index.ts']).toContain('No standard-tier endpoints');
+			expect(files['full/index.ts']).toContain('No full-tier endpoints');
+		});
+
+		it('should generate nested index file with correct imports', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files['index.ts']).toContain("import { setupMinimalEndpoints } from './minimal/index.js'");
+			expect(files['index.ts']).toContain("import { setupStandardEndpoints } from './standard/index.js'");
+			expect(files['index.ts']).toContain("import { setupFullEndpoints } from './full/index.js'");
+		});
+
+		it('should include validator imports in individual endpoint files when needed', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/users',
+					method: 'POST',
+					exportName: 'createUserEndpoint',
+					tier: 'minimal',
+					features: createFeatures({ hasBodyValidation: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'createUserEndpoint', importPath: '../../endpoints/users' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files['minimal/createUserEndpoint.ts']).toContain("import { validateBody } from '../validators.js'");
+		});
+
+		it('should include events import in standard endpoint files when needed', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/orders',
+					method: 'POST',
+					exportName: 'createOrderEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasEvents: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'createOrderEndpoint', importPath: '../../endpoints/orders' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files['standard/createOrderEndpoint.ts']).toContain('import { publishConstructEvents }');
+		});
+
+		it('should skip endpoints without matching imports', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/health',
+					method: 'GET',
+					exportName: 'healthEndpoint',
+					tier: 'minimal',
+				}),
+				createAnalysis({
+					route: '/unknown',
+					method: 'GET',
+					exportName: 'unknownEndpoint',
+					tier: 'minimal',
+				}),
+			];
+
+			// Only provide import for healthEndpoint
+			const endpointImports = [
+				{ exportName: 'healthEndpoint', importPath: '../../endpoints/health' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files).toHaveProperty('minimal/healthEndpoint.ts');
+			expect(files).not.toHaveProperty('minimal/unknownEndpoint.ts');
+		});
+
+		it('should generate standard tier index with correct function calls', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/users',
+					method: 'GET',
+					exportName: 'usersEndpoint',
+					tier: 'standard',
+					features: createFeatures({ hasAuth: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'usersEndpoint', importPath: '../../endpoints/users' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files['standard/index.ts']).toContain('setupUsersEndpoint(app, serviceDiscovery, logger)');
+		});
+
+		it('should generate full tier index with correct function calls', () => {
+			const analyses = [
+				createAnalysis({
+					route: '/api/audit',
+					method: 'POST',
+					exportName: 'auditEndpoint',
+					tier: 'full',
+					features: createFeatures({ hasAudits: true }),
+				}),
+			];
+
+			const endpointImports = [
+				{ exportName: 'auditEndpoint', importPath: '../../endpoints/audit' },
+			];
+
+			const files = generateEndpointFilesNested(analyses, endpointImports);
+
+			expect(files['full/index.ts']).toContain('setupAuditEndpoint(app, serviceDiscovery, openApiOptions)');
+			expect(files['full/index.ts']).toContain('const openApiOptions');
+		});
+	});
 });