// Input: "user-profile" or "UserProfile" or "user_profile"
// Generates consistent names across all files:
{
  camelCase: "userProfile",      // Variables, methods
  pascalCase: "UserProfile",     // Classes, interfaces  
  kebabCase: "user-profile",     // URLs, file names
  snakeCase: "user_profile",     // Database columns
  pluralPascalCase: "UserProfiles" // Collections
}

// Generated: src/domain/user/entities/User.entity.ts
export class User {
  constructor(
    private readonly id: UserId,
    private readonly email: Email,
    private name: string
  ) {}

  changeName(newName: string): void {
    this.name = newName;
    // Domain events, validation, etc.
  }
}

// Generated: src/presentation/user/controllers/UserController.ts
export class UserController {
  async createUser(req: Request, res: Response): Promise<void> {
    const createUserUseCase = container.get(CreateUserUseCase);
    const result = await createUserUseCase.execute(req.body);
    res.status(201).json(result);
  }
}

// Generated: src/infrastructure/types.ts
export const TYPES = {
  // Domain Services
  UserDomainService: Symbol.for('UserDomainService'),
  
  // Application Services
  UserApplicationService: Symbol.for('UserApplicationService'),
  
  // Use Cases
  CreateUserUseCase: Symbol.for('CreateUserUseCase'),
  GetUserUseCase: Symbol.for('GetUserUseCase'),
  UpdateUserUseCase: Symbol.for('UpdateUserUseCase'),
  DeleteUserUseCase: Symbol.for('DeleteUserUseCase'),
  
  // Repositories
  UserRepository: Symbol.for('UserRepository'),
  
  // Infrastructure
  Database: Symbol.for('Database'),
  EventBus: Symbol.for('EventBus'),
  Cache: Symbol.for('Cache'),
  Logger: Symbol.for('Logger'),
  
  // Controllers
  UserController: Symbol.for('UserController')
};

// Interface definitions for infrastructure services
export interface ILogger {
  info(message: string, meta?: any): void;
  error(message: string, error?: Error): void;
  warn(message: string, meta?: any): void;
  debug(message: string, meta?: any): void;
}

export interface IEventBus {
  publish(event: any): Promise<void>;
  subscribe(eventType: string, handler: (event: any) => Promise<void>): void;
}

export interface ICache {
  get<T>(key: string): Promise<T | null>;
  set(key: string, value: any, ttl?: number): Promise<void>;
  del(key: string): Promise<void>;
}

// Generated: src/infrastructure/repositories/user.repository.ts
import { injectable } from 'inversify';
import { IUserRepository } from '../../domain/user/repositories/user.repository.interface';
import { User } from '../../domain/user/entities/user.entity';

@injectable()
export class UserRepository implements IUserRepository {
  private users: Map<string, User> = new Map();

  async findById(id: string): Promise<User | null> {
    return this.users.get(id) || null;
  }

  async findAll(): Promise<User[]> {
    return Array.from(this.users.values());
  }

  async save(user: User): Promise<void> {
    this.users.set(user.id, user);
  }

  async update(user: User): Promise<void> {
    if (this.users.has(user.id)) {
      this.users.set(user.id, user);
    } else {
      throw new Error('User not found');
    }
  }

  async delete(id: string): Promise<void> {
    if (!this.users.delete(id)) {
      throw new Error('User not found');
    }
  }
}

// Generated: src/infrastructure/container.ts
import 'reflect-metadata';
import { Container } from 'inversify';
import { TYPES, ILogger, IEventBus, ICache } from './types';

// Domain
import { UserDomainService } from '../domain/user/services/user-domain.service';

// Application
import { UserApplicationService } from '../application/services/user-application.service';
import { CreateUserUseCase } from '../application/use-cases/user/create-user.use-case';
import { GetUserUseCase } from '../application/use-cases/user/get-user.use-case';

// Infrastructure
import { UserRepository } from '../infrastructure/repositories/user.repository';
import { IUserRepository } from '../domain/user/repositories/user.repository.interface';
import { WinstonLogger } from '../infrastructure/logger/winston.logger';

// Presentation
import { UserController } from '../presentation/http/controllers/user.controller';

const container = new Container();

// Infrastructure Services
container.bind<ILogger>(TYPES.Logger).to(WinstonLogger).inSingletonScope();
container.bind<IEventBus>(TYPES.EventBus).to(InMemoryEventBus).inSingletonScope();
container.bind<ICache>(TYPES.Cache).to(InMemoryCache).inSingletonScope();

// Repositories
container.bind<IUserRepository>(TYPES.UserRepository).to(UserRepository);

// Domain Services
container.bind<UserDomainService>(TYPES.UserDomainService).to(UserDomainService);

// Application Services
container.bind<UserApplicationService>(TYPES.UserApplicationService).to(UserApplicationService);

// Use Cases
container.bind<CreateUserUseCase>(TYPES.CreateUserUseCase).to(CreateUserUseCase);
container.bind<GetUserUseCase>(TYPES.GetUserUseCase).to(GetUserUseCase);

// Controllers
container.bind<UserController>(TYPES.UserController).to(UserController);

export { container };

// Generated: src/presentation/http/controllers/user.controller.ts
import { injectable, inject } from 'inversify';
import { Request, Response } from 'express';
import { TYPES } from '../../../infrastructure/types';
import { UserApplicationService } from '../../../application/services/user-application.service';

@injectable()
export class UserController {
  constructor(
    @inject(TYPES.UserApplicationService) 
    private userApplicationService: UserApplicationService
  ) {}

  createUser = async (req: Request, res: Response): Promise<void> => {
    try {
      const createUserDto = req.body;
      const user = await this.userApplicationService.createUser({
        name: createUserDto.name
      });

      res.status(201).json({
        success: true,
        data: user,
        message: 'User created successfully'
      });
    } catch (error) {
      res.status(400).json({
        success: false,
        error: error instanceof Error ? error.message : 'Unknown error'
      });
    }
  };
}

// Generated: src/presentation/http/route-registry.ts
import { Router } from 'express';

export interface RouteConfig {
  path: string;
  router: Router;
  name: string;
  description?: string;
}

export class RouteRegistry {
  private static routes: RouteConfig[] = [];

  static register(config: RouteConfig): void {
    // Check if route already exists
    const existingIndex = this.routes.findIndex(route => route.path === config.path);
    
    if (existingIndex >= 0) {
      // Update existing route
      this.routes[existingIndex] = config;
      console.log(`🔄 Updated route: ${config.path} (${config.name})`);
    } else {
      // Add new route
      this.routes.push(config);
      console.log(`➕ Registered route: ${config.path} (${config.name})`);
    }
  }

  static getRoutes(): RouteConfig[] {
    return [...this.routes];
  }

  static unregister(path: string): boolean {
    const index = this.routes.findIndex(route => route.path === path);
    if (index >= 0) {
      this.routes.splice(index, 1);
      return true;
    }
    return false;
  }
}

// Generated: src/presentation/http/app.ts
import 'reflect-metadata';
import express from 'express';
import cors from 'cors';
import helmet from 'helmet';
import compression from 'compression';
import { container } from '../../infrastructure/container';
import { TYPES, ILogger } from '../../infrastructure/types';
import { RouteRegistry } from './route-registry';
import { errorHandler } from './middleware/error-handler.middleware';

const app = express();
const logger = container.get<ILogger>(TYPES.Logger);

// Security middleware
app.use(helmet());
app.use(cors());
app.use(compression());

// Body parsing middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Request logging middleware
app.use((req, res, next) => {
  logger.info(`${req.method} ${req.path}`, { 
    ip: req.ip,
    userAgent: req.get('User-Agent')
  });
  next();
});

// API Routes - Auto-registered from RouteRegistry
const routes = RouteRegistry.getRoutes();
routes.forEach(route => {
  app.use('/api', route.router);  // Note: routes are prefixed with /api
  logger.info(`Registered route: /api${route.path}`);
});

// Error handling middleware (must be last)
app.use(errorHandler);

export { app };

// Generated: src/presentation/http/routes/user.routes.ts
import { Router } from 'express';
import { container } from '../../../infrastructure/container';
import { TYPES } from '../../../infrastructure/types';
import { UserController } from '../controllers/user.controller';
import { validationMiddleware } from '../middleware/validation.middleware';
import { CreateUserDto, UpdateUserDto } from '../dto/user.dto';

const router = Router();
const userController = container.get<UserController>(TYPES.UserController);

// Routes
router.post('/users', 
  validationMiddleware(CreateUserDto),
  userController.createUser
);

router.get('/users', userController.getAllUsers);
router.get('/users/:id', userController.getUserById);
router.put('/users/:id', 
  validationMiddleware(UpdateUserDto),
  userController.updateUser
);
router.delete('/users/:id', userController.deleteUser);

export default router;

// Generated: src/presentation/http/routes/index.ts
import { RouteRegistry } from '../route-registry';
import userRoutes from './user.routes';

// Register User routes
RouteRegistry.register({
  path: '/users',
  router: userRoutes,
  name: 'User Routes',
  description: 'User management endpoints'
});

export { RouteRegistry };

// Success Response
{
  "success": true,
  "data": { /* response data */ },
  "message": "Operation completed successfully"
}

// Error Response  
{
  "success": false,
  "error": "Error message describing what went wrong"
}

// User domain endpoints (example)
POST   /api/users           # Create new user
GET    /api/users           # Get all users
GET    /api/users/:id       # Get user by ID  
PUT    /api/users/:id       # Update user
DELETE /api/users/:id       # Delete user

GET /health
Response: {
  "status": "OK",
  "timestamp": "2024-01-15T10:30:00Z",
  "service": "your-project-name"
}

GET /
Response: {
  "message": "Welcome to your-project-name!",
  "version": "1.0.0",
  "documentation": "/api-docs"
}

// Generated: src/domain/common/errors/DomainError.ts
export abstract class DomainError extends Error {
  abstract readonly code: string;
  abstract readonly statusCode: number;
}

export class ValidationError extends DomainError {
  readonly code = 'VALIDATION_ERROR';
  readonly statusCode = 400;
  
  constructor(message: string, public readonly field?: string) {
    super(message);
  }
}

export class NotFoundError extends DomainError {
  readonly code = 'NOT_FOUND';
  readonly statusCode = 404;
}

// Generated: src/presentation/middleware/errorHandler.ts
import { Request, Response, NextFunction } from 'express';
import { DomainError } from '../../domain/common/errors/DomainError';

export function errorHandler(
  error: Error,
  req: Request,
  res: Response,
  next: NextFunction
): void {
  if (error instanceof DomainError) {
    res.status(error.statusCode).json({
      success: false,
      error: {
        code: error.code,
        message: error.message
      }
    });
    return;
  }

  // Unexpected errors
  res.status(500).json({
    success: false,
    error: {
      code: 'INTERNAL_ERROR',
      message: 'An unexpected error occurred'
    }
  });
}

// Generated: test/domain/user/entities/User.entity.test.ts
import { User } from '../../../../src/domain/user/entities/User.entity';
import { Email } from '../../../../src/domain/user/value-objects/Email.vo';

describe('User Entity', () => {
  it('should create a user with valid data', () => {
    const email = Email.create('john@example.com');
    const user = new User('123', email, 'John Doe');
    
    expect(user.getId()).toBe('123');
    expect(user.getEmail().getValue()).toBe('john@example.com');
    expect(user.getName()).toBe('John Doe');
  });

  it('should change user name', () => {
    const email = Email.create('john@example.com');
    const user = new User('123', email, 'John Doe');
    
    user.changeName('Jane Doe');
    
    expect(user.getName()).toBe('Jane Doe');
  });
});

// Generated: test/presentation/user/controllers/UserController.test.ts
import request from 'supertest';
import { app } from '../../../../src/server';

describe('UserController', () => {
  it('should create a user', async () => {
    const userData = {
      email: 'test@example.com',
      name: 'Test User'
    };

    const response = await request(app)
      .post('/api/users')
      .send(userData)
      .expect(201);

    expect(response.body.success).toBe(true);
    expect(response.body.data.email).toBe(userData.email);
  });

  it('should validate required fields', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({})
      .expect(400);

    expect(response.body.success).toBe(false);
    expect(response.body.error.code).toBe('VALIDATION_ERROR');
  });
});

// User domain example
GET    /api/users           # Get all users
GET    /api/users/:id       # Get user by ID  
POST   /api/users           # Create new user
PUT    /api/users/:id       # Update user
DELETE /api/users/:id       # Delete user

// With query parameters
GET    /api/users?page=1&limit=10&sort=createdAt:desc
GET    /api/users?search=john&status=active

// Success Response
{
  "success": true,
  "data": { /* response data */ },
  "message": "Operation completed successfully",
  "timestamp": "2024-01-15T10:30:00Z"
}

// Error Response  
{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR", 
    "message": "Invalid input data",
    "details": [
      {
        "field": "email",
        "message": "Email is required"
      }
    ]
  },
  "timestamp": "2024-01-15T10:30:00Z"
}