// Layered Architecture Example

// Presentation Layer - Controller
const userController = {
  getUser: async (req: Request, res: Response) => {
    const user = await userService.findById(req.params.id);
    return res.json(UserDTO.fromEntity(user));
  },
  
  createUser: async (req: Request, res: Response) => {
    const user = await userService.create(req.body);
    return res.status(201).json(UserDTO.fromEntity(user));
  }
};

// Business Layer - Service
const userService = {
  findById: async (id: string) => {
    const user = await userRepository.findById(id);
    if (!user) throw new NotFoundError('User not found');
    return user;
  },
  
  create: async (data: CreateUserInput) => {
    const existing = await userRepository.findByEmail(data.email);
    if (existing) throw new ConflictError('Email already exists');
    
    const hashedPassword = await hashPassword(data.password);
    return userRepository.create({ ...data, password: hashedPassword });
  }
};

// Persistence Layer - Repository
const userRepository = {
  findById: (id: string) => db.user.findUnique({ where: { id } }),
  findByEmail: (email: string) => db.user.findUnique({ where: { email } }),
  create: (data: UserCreateData) => db.user.create({ data })
};

// Modular Monolith Structure
// src/
// ├── modules/
// │   ├── user/
// │   │   ├── user.module.ts
// │   │   ├── user.controller.ts
// │   │   ├── user.service.ts
// │   │   ├── user.repository.ts
// │   │   └── user.events.ts
// │   ├── order/
// │   │   ├── order.module.ts
// │   │   └── ...
// │   └── product/
// │       └── ...
// └── shared/
//     ├── events/
//     ├── types/
//     └── utils/

// User Module - Encapsulated with public API
// modules/user/user.module.ts
import { userController } from './user.controller';
import { userService } from './user.service';
import { UserCreatedEvent } from './user.events';

export const UserModule = {
  // Public API - only these are accessible from other modules
  controllers: userController,
  
  // Queries other modules can use
  queries: {
    findById: userService.findById,
    findByEmail: userService.findByEmail,
  },
  
  // Commands other modules can use
  commands: {
    create: userService.create,
    updateProfile: userService.updateProfile,
  },
  
  // Events this module emits
  events: {
    UserCreated: UserCreatedEvent,
  }
};

// Order Module using User Module
// modules/order/order.service.ts
import { UserModule } from '../user/user.module';
import { eventBus } from '../../shared/events';

const orderService = {
  create: async (userId: string, items: OrderItem[]) => {
    // Use User module's public API
    const user = await UserModule.queries.findById(userId);
    if (!user) throw new NotFoundError('User not found');
    
    const order = await orderRepository.create({
      userId,
      items,
      total: calculateTotal(items)
    });
    
    // Emit event for other modules
    await eventBus.publish(new OrderCreatedEvent(order));
    
    return order;
  }
};

// MVC Pattern Example (Backend)

// Model - Business logic and data
interface User {
  id: string;
  email: string;
  name: string;
  createdAt: Date;
}

const UserModel = {
  validate: (data: Partial<User>) => {
    if (!data.email?.includes('@')) {
      throw new ValidationError('Invalid email');
    }
    return true;
  },
  
  toJSON: (user: User) => ({
    id: user.id,
    email: user.email,
    name: user.name
  })
};

// Controller - Handles requests
const UserController = {
  index: async (req: Request, res: Response) => {
    const users = await userRepository.findAll();
    return res.render('users/index', { users: users.map(UserModel.toJSON) });
  },
  
  create: async (req: Request, res: Response) => {
    UserModel.validate(req.body);
    const user = await userRepository.create(req.body);
    return res.redirect(`/users/${user.id}`);
  }
};

// View - Template (e.g., EJS, Handlebars, or React)
// views/users/index.ejs
// <ul>
//   <% users.forEach(user => { %>
//     <li><%= user.name %> - <%= user.email %></li>
//   <% }) %>
// </ul>