Advanced Design Patterns - 1/2

// The nightmare every developer inherits at some point
class UserController {
  async getUserProfile(req: Request, res: Response) {
    // Business logic mixed with data access - RED FLAG #1
    const userId = req.params.id;

    // Direct database queries in controllers - RED FLAG #2
    const userQuery = `
      SELECT u.*, p.avatar_url, p.bio, COUNT(f.id) as follower_count
      FROM users u 
      LEFT JOIN profiles p ON u.id = p.user_id
      LEFT JOIN followers f ON u.id = f.following_id
      WHERE u.id = ? AND u.deleted_at IS NULL
      GROUP BY u.id
    `;

    const user = await db.query(userQuery, [userId]);

    if (!user) {
      return res.status(404).json({ error: "User not found" });
    }

    // More queries scattered throughout - RED FLAG #3
    const postsQuery = `
      SELECT * FROM posts 
      WHERE user_id = ? AND published = true
      ORDER BY created_at DESC LIMIT 10
    `;
    const posts = await db.query(postsQuery, [userId]);

    // Transaction logic mixed with presentation logic - RED FLAG #4
    await db.query("UPDATE users SET last_accessed = NOW() WHERE id = ?", [
      userId,
    ]);

    res.json({ user, posts });
  }

  async updateUserProfile(req: Request, res: Response) {
    const { userId, email, name, bio } = req.body;

    // No transaction handling - RED FLAG #5
    await db.query("UPDATE users SET email = ?, name = ? WHERE id = ?", [
      email,
      name,
      userId,
    ]);

    await db.query("UPDATE profiles SET bio = ? WHERE user_id = ?", [
      bio,
      userId,
    ]);

    // What happens if the second query fails? DATA CORRUPTION!

    res.json({ success: true });
  }

  async deleteUser(req: Request, res: Response) {
    const userId = req.params.id;

    // Complex deletion logic repeated everywhere - RED FLAG #6
    await db.query("DELETE FROM posts WHERE user_id = ?", [userId]);
    await db.query("DELETE FROM comments WHERE user_id = ?", [userId]);
    await db.query(
      "DELETE FROM followers WHERE user_id = ? OR following_id = ?",
      [userId, userId]
    );
    await db.query("DELETE FROM profiles WHERE user_id = ?", [userId]);
    await db.query("DELETE FROM users WHERE id = ?", [userId]);

    // If any of these fail, you've got partial deletions and orphaned data

    res.json({ success: true });
  }
}

// Domain entity with business logic
export class User {
  constructor(
    public readonly id: string,
    public email: string,
    public name: string,
    public createdAt: Date,
    public deletedAt?: Date
  ) {}

  isActive(): boolean {
    return this.deletedAt === null;
  }

  canBeDeleted(): boolean {
    return this.isActive();
  }

  markAsDeleted(): void {
    if (!this.canBeDeleted()) {
      throw new Error("User cannot be deleted in current state");
    }
    this.deletedAt = new Date();
  }

  updateEmail(newEmail: string): void {
    if (!this.isValidEmail(newEmail)) {
      throw new Error("Invalid email format");
    }
    this.email = newEmail;
  }

  private isValidEmail(email: string): boolean {
    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
  }
}

export class UserProfile {
  constructor(
    public readonly userId: string,
    public avatarUrl: string,
    public bio: string,
    public followerCount: number = 0
  ) {}

  updateBio(newBio: string): void {
    if (newBio.length > 500) {
      throw new Error("Bio cannot exceed 500 characters");
    }
    this.bio = newBio;
  }
}

// Repository interface for dependency inversion
export interface IUserRepository {
  findById(id: string): Promise<User | null>;
  findByEmail(email: string): Promise<User | null>;
  save(user: User): Promise<void>;
  delete(user: User): Promise<void>;
  findActiveUsers(limit: number): Promise<User[]>;
}

export interface IUserProfileRepository {
  findByUserId(userId: string): Promise<UserProfile | null>;
  save(profile: UserProfile): Promise<void>;
  delete(profile: UserProfile): Promise<void>;
}

// Concrete repository implementation
export class PostgresUserRepository implements IUserRepository {
  constructor(private db: Database, private unitOfWork: IUnitOfWork) {}

  async findById(id: string): Promise<User | null> {
    const query = `
      SELECT id, email, name, created_at, deleted_at
      FROM users 
      WHERE id = $1
    `;

    const result = await this.db.query(query, [id]);

    if (!result.rows[0]) {
      return null;
    }

    const row = result.rows[0];
    return new User(
      row.id,
      row.email,
      row.name,
      row.created_at,
      row.deleted_at
    );
  }

  async findByEmail(email: string): Promise<User | null> {
    const query = `
      SELECT id, email, name, created_at, deleted_at
      FROM users 
      WHERE email = $1 AND deleted_at IS NULL
    `;

    const result = await this.db.query(query, [email]);
    return result.rows[0] ? this.mapToUser(result.rows[0]) : null;
  }

  async save(user: User): Promise<void> {
    const existingUser = await this.findById(user.id);

    if (existingUser) {
      // Update existing user
      this.unitOfWork.registerDirty(user, async () => {
        const query = `
          UPDATE users 
          SET email = $1, name = $2, deleted_at = $3
          WHERE id = $4
        `;
        await this.db.query(query, [
          user.email,
          user.name,
          user.deletedAt,
          user.id,
        ]);
      });
    } else {
      // Create new user
      this.unitOfWork.registerNew(user, async () => {
        const query = `
          INSERT INTO users (id, email, name, created_at, deleted_at)
          VALUES ($1, $2, $3, $4, $5)
        `;
        await this.db.query(query, [
          user.id,
          user.email,
          user.name,
          user.createdAt,
          user.deletedAt,
        ]);
      });
    }
  }

  async delete(user: User): Promise<void> {
    // Soft delete approach
    user.markAsDeleted();
    await this.save(user);
  }

  async findActiveUsers(limit: number): Promise<User[]> {
    const query = `
      SELECT id, email, name, created_at, deleted_at
      FROM users 
      WHERE deleted_at IS NULL
      ORDER BY created_at DESC
      LIMIT $1
    `;

    const result = await this.db.query(query, [limit]);
    return result.rows.map((row) => this.mapToUser(row));
  }

  private mapToUser(row: any): User {
    return new User(
      row.id,
      row.email,
      row.name,
      row.created_at,
      row.deleted_at
    );
  }
}

// Unit of Work pattern for transaction management
export interface IUnitOfWork {
  registerNew(entity: any, insertAction: () => Promise<void>): void;
  registerDirty(entity: any, updateAction: () => Promise<void>): void;
  registerDeleted(entity: any, deleteAction: () => Promise<void>): void;
  commit(): Promise<void>;
  rollback(): Promise<void>;
}

export class DatabaseUnitOfWork implements IUnitOfWork {
  private newEntities: Map<any, () => Promise<void>> = new Map();
  private dirtyEntities: Map<any, () => Promise<void>> = new Map();
  private deletedEntities: Map<any, () => Promise<void>> = new Map();
  private transaction: DatabaseTransaction | null = null;

  constructor(private db: Database) {}

  registerNew(entity: any, insertAction: () => Promise<void>): void {
    this.newEntities.set(entity, insertAction);
  }

  registerDirty(entity: any, updateAction: () => Promise<void>): void {
    this.dirtyEntities.set(entity, updateAction);
  }

  registerDeleted(entity: any, deleteAction: () => Promise<void>): void {
    this.deletedEntities.set(entity, deleteAction);
  }

  async commit(): Promise<void> {
    if (this.hasChanges()) {
      this.transaction = await this.db.beginTransaction();

      try {
        // Execute all database operations within a single transaction
        await this.executeActions(this.newEntities, "INSERT");
        await this.executeActions(this.dirtyEntities, "UPDATE");
        await this.executeActions(this.deletedEntities, "DELETE");

        await this.transaction.commit();
        this.clearChanges();
      } catch (error) {
        await this.transaction.rollback();
        throw new Error(`Transaction failed: ${error.message}`);
      }
    }
  }

  async rollback(): Promise<void> {
    if (this.transaction) {
      await this.transaction.rollback();
      this.clearChanges();
    }
  }

  private async executeActions(
    actions: Map<any, () => Promise<void>>,
    operation: string
  ): Promise<void> {
    for (const [entity, action] of actions) {
      try {
        await action();
        console.log(
          `${operation} operation completed for entity:`,
          entity.constructor.name
        );
      } catch (error) {
        throw new Error(
          `${operation} failed for ${entity.constructor.name}: ${error.message}`
        );
      }
    }
  }

  private hasChanges(): boolean {
    return (
      this.newEntities.size > 0 ||
      this.dirtyEntities.size > 0 ||
      this.deletedEntities.size > 0
    );
  }

  private clearChanges(): void {
    this.newEntities.clear();
    this.dirtyEntities.clear();
    this.deletedEntities.clear();
  }
}

// Application service that orchestrates business operations
export class UserService {
  constructor(
    private userRepository: IUserRepository,
    private profileRepository: IUserProfileRepository,
    private unitOfWork: IUnitOfWork
  ) {}

  async getUserProfile(userId: string): Promise<UserProfileDto | null> {
    const user = await this.userRepository.findById(userId);
    if (!user || !user.isActive()) {
      return null;
    }

    const profile = await this.profileRepository.findByUserId(userId);

    return {
      user: {
        id: user.id,
        email: user.email,
        name: user.name,
        createdAt: user.createdAt,
      },
      profile: profile
        ? {
            avatarUrl: profile.avatarUrl,
            bio: profile.bio,
            followerCount: profile.followerCount,
          }
        : null,
    };
  }

  async updateUserProfile(
    userId: string,
    updateData: { email?: string; name?: string; bio?: string }
  ): Promise<void> {
    const user = await this.userRepository.findById(userId);
    if (!user || !user.isActive()) {
      throw new Error("User not found or inactive");
    }

    const profile = await this.profileRepository.findByUserId(userId);
    if (!profile) {
      throw new Error("User profile not found");
    }

    // Apply business logic through domain entities
    if (updateData.email) {
      user.updateEmail(updateData.email);
    }
    if (updateData.name) {
      user.name = updateData.name;
    }
    if (updateData.bio) {
      profile.updateBio(updateData.bio);
    }

    // Register changes with Unit of Work
    await this.userRepository.save(user);
    await this.profileRepository.save(profile);

    // Commit all changes in a single transaction
    await this.unitOfWork.commit();
  }

  async deleteUserCompletely(userId: string): Promise<void> {
    const user = await this.userRepository.findById(userId);
    if (!user) {
      throw new Error("User not found");
    }

    if (!user.canBeDeleted()) {
      throw new Error("User cannot be deleted in current state");
    }

    // All related data deletion handled through repositories
    const profile = await this.profileRepository.findByUserId(userId);

    if (profile) {
      await this.profileRepository.delete(profile);
    }

    await this.userRepository.delete(user);

    // Single transaction ensures data consistency
    await this.unitOfWork.commit();
  }
}

// Clean controller that focuses only on HTTP concerns
export class UserController {
  constructor(private userService: UserService) {}

  async getUserProfile(req: Request, res: Response): Promise<void> {
    try {
      const userId = req.params.id;
      const profile = await this.userService.getUserProfile(userId);

      if (!profile) {
        res.status(404).json({ error: "User not found" });
        return;
      }

      res.json(profile);
    } catch (error) {
      res.status(500).json({ error: "Internal server error" });
    }
  }

  async updateUserProfile(req: Request, res: Response): Promise<void> {
    try {
      const userId = req.params.id;
      const updateData = req.body;

      await this.userService.updateUserProfile(userId, updateData);

      res.json({ success: true });
    } catch (error) {
      if (error.message.includes("not found")) {
        res.status(404).json({ error: error.message });
      } else if (error.message.includes("Invalid email")) {
        res.status(400).json({ error: error.message });
      } else {
        res.status(500).json({ error: "Internal server error" });
      }
    }
  }

  async deleteUser(req: Request, res: Response): Promise<void> {
    try {
      const userId = req.params.id;
      await this.userService.deleteUserCompletely(userId);

      res.json({ success: true });
    } catch (error) {
      if (error.message.includes("not found")) {
        res.status(404).json({ error: error.message });
      } else if (error.message.includes("cannot be deleted")) {
        res.status(400).json({ error: error.message });
      } else {
        res.status(500).json({ error: "Internal server error" });
      }
    }
  }
}

// DTO for API responses
interface UserProfileDto {
  user: {
    id: string;
    email: string;
    name: string;
    createdAt: Date;
  };
  profile: {
    avatarUrl: string;
    bio: string;
    followerCount: number;
  } | null;
}

// The tightly coupled nightmare that makes testing impossible
class EmailService {
  private smtpClient: SMTPClient;

  constructor() {
    // Hardcoded dependency - cannot be tested or swapped
    this.smtpClient = new SMTPClient({
      host: "smtp.gmail.com",
      port: 587,
      secure: false,
      auth: {
        user: process.env.EMAIL_USER,
        pass: process.env.EMAIL_PASS,
      },
    });
  }

  async sendEmail(to: string, subject: string, body: string): Promise<void> {
    // Directly coupled to SMTP implementation
    await this.smtpClient.sendMail({
      from: "noreply@company.com",
      to,
      subject,
      html: body,
    });
  }
}

class UserRegistrationService {
  private database: PostgresDatabase;
  private emailService: EmailService;
  private logger: ConsoleLogger;

  constructor() {
    // Multiple hardcoded dependencies - testing requires real database and email service
    this.database = new PostgresDatabase(process.env.DATABASE_URL);
    this.emailService = new EmailService();
    this.logger = new ConsoleLogger();
  }

  async registerUser(userData: CreateUserRequest): Promise<void> {
    this.logger.info("Starting user registration");

    try {
      // Business logic mixed with infrastructure concerns
      const user = await this.database.query(
        "INSERT INTO users (email, name, password_hash) VALUES ($1, $2, $3) RETURNING id",
        [
          userData.email,
          userData.name,
          await bcrypt.hash(userData.password, 10),
        ]
      );

      // Can't test email functionality without actually sending emails
      await this.emailService.sendEmail(
        userData.email,
        "Welcome to Our Platform",
        `<h1>Welcome ${userData.name}!</h1><p>Your account has been created.</p>`
      );

      this.logger.info(`User registered successfully: ${user.id}`);
    } catch (error) {
      this.logger.error("User registration failed:", error);
      throw error;
    }
  }
}

// Testing this is a nightmare
describe("UserRegistrationService", () => {
  test("should register user", async () => {
    // How do you test this without:
    // 1. Setting up a real PostgreSQL database
    // 2. Actually sending emails through Gmail SMTP
    // 3. Dealing with environment variables
    // 4. Network calls that can fail randomly

    const service = new UserRegistrationService();

    // This test will:
    // - Connect to your production database if you're not careful
    // - Send actual emails to real email addresses
    // - Fail if your internet is down
    // - Take forever because of network calls

    await service.registerUser({
      email: "test@example.com",
      name: "Test User",
      password: "password123",
    });

    // How do you verify the user was created without querying the real database?
    // How do you verify the email was sent without actually sending it?
  });
});

// Define clear interfaces for all dependencies
export interface IEmailService {
  sendWelcomeEmail(to: string, name: string): Promise<void>;
  sendPasswordResetEmail(to: string, resetToken: string): Promise<void>;
}

export interface IUserRepository {
  createUser(user: CreateUserDto): Promise<User>;
  findByEmail(email: string): Promise<User | null>;
  findById(id: string): Promise<User | null>;
}

export interface ILogger {
  info(message: string, meta?: any): void;
  error(message: string, error?: Error): void;
  warn(message: string, meta?: any): void;
}

export interface IPasswordHasher {
  hash(password: string): Promise<string>;
  verify(password: string, hash: string): Promise<boolean>;
}

// Production implementations
export class SMTPEmailService implements IEmailService {
  constructor(private smtpConfig: SMTPConfig) {}

  async sendWelcomeEmail(to: string, name: string): Promise<void> {
    const client = new SMTPClient(this.smtpConfig);
    await client.sendMail({
      from: "noreply@company.com",
      to,
      subject: "Welcome to Our Platform",
      html: `<h1>Welcome ${name}!</h1><p>Your account has been created successfully.</p>`,
    });
  }

  async sendPasswordResetEmail(to: string, resetToken: string): Promise<void> {
    const client = new SMTPClient(this.smtpConfig);
    const resetUrl = `${process.env.APP_URL}/reset-password?token=${resetToken}`;

    await client.sendMail({
      from: "noreply@company.com",
      to,
      subject: "Password Reset Request",
      html: `<p>Click <a href="${resetUrl}">here</a> to reset your password.</p>`,
    });
  }
}

export class PostgresUserRepository implements IUserRepository {
  constructor(private db: Database) {}

  async createUser(userData: CreateUserDto): Promise<User> {
    const query = `
      INSERT INTO users (id, email, name, password_hash, created_at)
      VALUES ($1, $2, $3, $4, $5)
      RETURNING *
    `;

    const userId = uuidv4();
    const result = await this.db.query(query, [
      userId,
      userData.email,
      userData.name,
      userData.passwordHash,
      new Date(),
    ]);

    return this.mapToUser(result.rows[0]);
  }

  async findByEmail(email: string): Promise<User | null> {
    const query = "SELECT * FROM users WHERE email = $1 AND deleted_at IS NULL";
    const result = await this.db.query(query, [email]);

    return result.rows[0] ? this.mapToUser(result.rows[0]) : null;
  }

  async findById(id: string): Promise<User | null> {
    const query = "SELECT * FROM users WHERE id = $1 AND deleted_at IS NULL";
    const result = await this.db.query(query, [id]);

    return result.rows[0] ? this.mapToUser(result.rows[0]) : null;
  }

  private mapToUser(row: any): User {
    return new User(row.id, row.email, row.name, row.created_at);
  }
}

export class WinstonLogger implements ILogger {
  private logger: winston.Logger;

  constructor() {
    this.logger = winston.createLogger({
      level: "info",
      format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.json()
      ),
      transports: [
        new winston.transports.File({ filename: "error.log", level: "error" }),
        new winston.transports.File({ filename: "combined.log" }),
      ],
    });

    if (process.env.NODE_ENV !== "production") {
      this.logger.add(
        new winston.transports.Console({
          format: winston.format.simple(),
        })
      );
    }
  }

  info(message: string, meta?: any): void {
    this.logger.info(message, meta);
  }

  error(message: string, error?: Error): void {
    this.logger.error(message, { error: error?.stack });
  }

  warn(message: string, meta?: any): void {
    this.logger.warn(message, meta);
  }
}

export class BCryptPasswordHasher implements IPasswordHasher {
  constructor(private saltRounds: number = 12) {}

  async hash(password: string): Promise<string> {
    return bcrypt.hash(password, this.saltRounds);
  }

  async verify(password: string, hash: string): Promise<boolean> {
    return bcrypt.compare(password, hash);
  }
}

// Service with injected dependencies
export class UserRegistrationService {
  constructor(
    private userRepository: IUserRepository,
    private emailService: IEmailService,
    private logger: ILogger,
    private passwordHasher: IPasswordHasher
  ) {}

  async registerUser(userData: CreateUserRequest): Promise<User> {
    this.logger.info("Starting user registration", { email: userData.email });

    try {
      // Check if user already exists
      const existingUser = await this.userRepository.findByEmail(
        userData.email
      );
      if (existingUser) {
        throw new UserRegistrationError("User with this email already exists");
      }

      // Hash password using injected service
      const passwordHash = await this.passwordHasher.hash(userData.password);

      // Create user through repository
      const user = await this.userRepository.createUser({
        email: userData.email,
        name: userData.name,
        passwordHash,
      });

      // Send welcome email through injected service
      await this.emailService.sendWelcomeEmail(user.email, user.name);

      this.logger.info("User registered successfully", { userId: user.id });

      return user;
    } catch (error) {
      this.logger.error("User registration failed", error as Error);
      throw error;
    }
  }
}

// Dependency injection container
export class DIContainer {
  private services = new Map<string, any>();
  private factories = new Map<string, () => any>();

  register<T>(name: string, factory: () => T): void {
    this.factories.set(name, factory);
  }

  registerSingleton<T>(name: string, factory: () => T): void {
    this.register(name, () => {
      if (!this.services.has(name)) {
        this.services.set(name, factory());
      }
      return this.services.get(name);
    });
  }

  resolve<T>(name: string): T {
    const factory = this.factories.get(name);
    if (!factory) {
      throw new Error(`Service ${name} not registered`);
    }
    return factory();
  }

  resolveAll(): Record<string, any> {
    const resolved: Record<string, any> = {};
    for (const [name] of this.factories) {
      resolved[name] = this.resolve(name);
    }
    return resolved;
  }
}

// Container configuration
export function setupDIContainer(): DIContainer {
  const container = new DIContainer();

  // Infrastructure services
  container.registerSingleton("logger", () => new WinstonLogger());

  container.registerSingleton(
    "passwordHasher",
    () => new BCryptPasswordHasher(12)
  );

  container.registerSingleton(
    "database",
    () =>
      new PostgresDatabase({
        connectionString: process.env.DATABASE_URL,
        ssl: process.env.NODE_ENV === "production",
      })
  );

  // Email service with configuration
  container.registerSingleton(
    "emailService",
    () =>
      new SMTPEmailService({
        host: process.env.SMTP_HOST || "smtp.gmail.com",
        port: parseInt(process.env.SMTP_PORT || "587"),
        secure: false,
        auth: {
          user: process.env.EMAIL_USER!,
          pass: process.env.EMAIL_PASS!,
        },
      })
  );

  // Repository layer
  container.register(
    "userRepository",
    () => new PostgresUserRepository(container.resolve("database"))
  );

  // Application services
  container.register(
    "userRegistrationService",
    () =>
      new UserRegistrationService(
        container.resolve("userRepository"),
        container.resolve("emailService"),
        container.resolve("logger"),
        container.resolve("passwordHasher")
      )
  );

  return container;
}

// Test implementations for easy mocking
export class MockEmailService implements IEmailService {
  public sentEmails: Array<{ to: string; type: string; data?: any }> = [];

  async sendWelcomeEmail(to: string, name: string): Promise<void> {
    this.sentEmails.push({ to, type: "welcome", data: { name } });
  }

  async sendPasswordResetEmail(to: string, resetToken: string): Promise<void> {
    this.sentEmails.push({ to, type: "password-reset", data: { resetToken } });
  }

  getLastEmail() {
    return this.sentEmails[this.sentEmails.length - 1];
  }

  getEmailsForRecipient(email: string) {
    return this.sentEmails.filter((e) => e.to === email);
  }
}

export class MockUserRepository implements IUserRepository {
  public users: User[] = [];
  private nextId = 1;

  async createUser(userData: CreateUserDto): Promise<User> {
    const user = new User(
      `user-${this.nextId++}`,
      userData.email,
      userData.name,
      new Date()
    );

    this.users.push(user);
    return user;
  }

  async findByEmail(email: string): Promise<User | null> {
    return this.users.find((u) => u.email === email) || null;
  }

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

export class MockLogger implements ILogger {
  public logs: Array<{ level: string; message: string; meta?: any }> = [];

  info(message: string, meta?: any): void {
    this.logs.push({ level: "info", message, meta });
  }

  error(message: string, error?: Error): void {
    this.logs.push({ level: "error", message, meta: { error } });
  }

  warn(message: string, meta?: any): void {
    this.logs.push({ level: "warn", message, meta });
  }
}

export class MockPasswordHasher implements IPasswordHasher {
  async hash(password: string): Promise<string> {
    return `hashed_${password}`;
  }

  async verify(password: string, hash: string): Promise<boolean> {
    return hash === `hashed_${password}`;
  }
}

// Now testing is a breeze
describe("UserRegistrationService", () => {
  let userRegistrationService: UserRegistrationService;
  let mockUserRepository: MockUserRepository;
  let mockEmailService: MockEmailService;
  let mockLogger: MockLogger;
  let mockPasswordHasher: MockPasswordHasher;

  beforeEach(() => {
    // Set up test doubles
    mockUserRepository = new MockUserRepository();
    mockEmailService = new MockEmailService();
    mockLogger = new MockLogger();
    mockPasswordHasher = new MockPasswordHasher();

    // Inject test doubles
    userRegistrationService = new UserRegistrationService(
      mockUserRepository,
      mockEmailService,
      mockLogger,
      mockPasswordHasher
    );
  });

  test("should successfully register a new user", async () => {
    const userData: CreateUserRequest = {
      email: "test@example.com",
      name: "Test User",
      password: "password123",
    };

    const user = await userRegistrationService.registerUser(userData);

    // Verify user was created
    expect(user.email).toBe("test@example.com");
    expect(user.name).toBe("Test User");

    // Verify user was saved to repository
    const savedUser = await mockUserRepository.findByEmail("test@example.com");
    expect(savedUser).toBeTruthy();

    // Verify welcome email was sent
    expect(mockEmailService.sentEmails).toHaveLength(1);
    expect(mockEmailService.getLastEmail()).toEqual({
      to: "test@example.com",
      type: "welcome",
      data: { name: "Test User" },
    });

    // Verify password was hashed
    expect(mockPasswordHasher.hash).toHaveBeenCalledWith("password123");

    // Verify logging occurred
    expect(
      mockLogger.logs.some(
        (log) =>
          log.level === "info" &&
          log.message.includes("registered successfully")
      )
    ).toBe(true);
  });

  test("should reject duplicate email registration", async () => {
    // Set up existing user
    await mockUserRepository.createUser({
      email: "existing@example.com",
      name: "Existing User",
      passwordHash: "hashed_password",
    });

    const userData: CreateUserRequest = {
      email: "existing@example.com",
      name: "New User",
      password: "password123",
    };

    await expect(
      userRegistrationService.registerUser(userData)
    ).rejects.toThrow("User with this email already exists");

    // Verify no email was sent
    expect(mockEmailService.sentEmails).toHaveLength(0);

    // Verify error was logged
    expect(
      mockLogger.logs.some(
        (log) =>
          log.level === "error" && log.message.includes("registration failed")
      )
    ).toBe(true);
  });

  test("should handle email service failure gracefully", async () => {
    // Make email service fail
    mockEmailService.sendWelcomeEmail = jest
      .fn()
      .mockRejectedValue(new Error("SMTP server down"));

    const userData: CreateUserRequest = {
      email: "test@example.com",
      name: "Test User",
      password: "password123",
    };

    await expect(
      userRegistrationService.registerUser(userData)
    ).rejects.toThrow("SMTP server down");

    // Verify user was still created (depending on your business logic)
    const users = mockUserRepository.users;
    expect(users).toHaveLength(1);

    // Verify error was logged
    expect(mockLogger.logs.some((log) => log.level === "error")).toBe(true);
  });
});

// The nightmare of complex object creation scattered throughout your codebase
class ReportGenerator {
  generateUserReport(userId: string, reportType: string, options: any) {
    let report;

    // Object creation logic mixed with business logic - RED FLAG #1
    if (reportType === "daily") {
      report = {
        id: uuidv4(),
        type: "daily",
        userId,
        title: "Daily Activity Report",
        createdAt: new Date(),
        sections: [
          { name: "summary", template: "daily-summary" },
          { name: "activities", template: "activity-list" },
        ],
        formatting: {
          pageSize: "A4",
          orientation: "portrait",
          margins: { top: 20, bottom: 20, left: 15, right: 15 },
        },
        filters: {
          dateRange: {
            start: new Date(Date.now() - 24 * 60 * 60 * 1000),
            end: new Date(),
          },
        },
      };
    } else if (reportType === "weekly") {
      report = {
        id: uuidv4(),
        type: "weekly",
        userId,
        title: "Weekly Performance Report",
        createdAt: new Date(),
        sections: [
          { name: "summary", template: "weekly-summary" },
          { name: "performance", template: "performance-chart" },
          { name: "trends", template: "trend-analysis" },
        ],
        formatting: {
          pageSize: "A4",
          orientation: "landscape", // Different from daily
          margins: { top: 15, bottom: 15, left: 10, right: 10 },
        },
        filters: {
          dateRange: {
            start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
            end: new Date(),
          },
        },
      };
    } else if (reportType === "monthly") {
      // Even more complex creation logic...
      report = {
        id: uuidv4(),
        type: "monthly",
        userId,
        title: "Monthly Comprehensive Report",
        createdAt: new Date(),
        sections: [
          { name: "executive-summary", template: "exec-summary" },
          { name: "detailed-metrics", template: "detailed-metrics" },
          { name: "comparisons", template: "month-over-month" },
          { name: "projections", template: "future-projections" },
        ],
        formatting: {
          pageSize: "A4",
          orientation: "portrait",
          margins: { top: 25, bottom: 25, left: 20, right: 20 },
        },
        filters: {
          dateRange: {
            start: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
            end: new Date(),
          },
          includeComparisons: true,
          includeProjections: options.includeProjections || false,
        },
      };
    } else {
      throw new Error("Unknown report type");
    }

    // More scattered object creation based on user preferences
    if (options.customTitle) {
      report.title = options.customTitle;
    }

    if (options.exportFormat === "pdf") {
      report.exportSettings = {
        format: "pdf",
        quality: "high",
        embedFonts: true,
      };
    } else if (options.exportFormat === "excel") {
      report.exportSettings = {
        format: "xlsx",
        includeCharts: true,
        sheetNames: ["Summary", "Data", "Charts"],
      };
    }

    return report;
  }
}

// Every class that needs to create reports duplicates this logic
class ScheduledReportService {
  createScheduledReport(schedule: any) {
    // Duplicate object creation logic - RED FLAG #2
    let report;
    if (schedule.reportType === "daily") {
      // Copy-pasted from ReportGenerator with slight variations
      report = {
        id: uuidv4(),
        type: "daily",
        userId: schedule.userId,
        title: "Scheduled Daily Report",
        createdAt: new Date(),
        // ... more duplicated code
      };
    }
    // ... more duplication
  }
}

// Domain models with clear structure
export class Report {
  constructor(
    public readonly id: string,
    public readonly type: ReportType,
    public readonly userId: string,
    public title: string,
    public readonly createdAt: Date,
    public sections: ReportSection[],
    public formatting: ReportFormatting,
    public filters: ReportFilters,
    public exportSettings?: ExportSettings
  ) {}

  addSection(section: ReportSection): void {
    this.sections.push(section);
  }

  updateTitle(newTitle: string): void {
    if (!newTitle.trim()) {
      throw new Error("Report title cannot be empty");
    }
    this.title = newTitle;
  }

  canExport(): boolean {
    return this.sections.length > 0;
  }
}

export class ReportSection {
  constructor(
    public name: string,
    public template: string,
    public data?: any,
    public visible: boolean = true
  ) {}
}

export class ReportFormatting {
  constructor(
    public pageSize: PageSize,
    public orientation: PageOrientation,
    public margins: Margins
  ) {}
}

export class ReportFilters {
  constructor(
    public dateRange: DateRange,
    public includeComparisons: boolean = false,
    public includeProjections: boolean = false,
    public customFilters: Record<string, any> = {}
  ) {}
}

export class ExportSettings {
  constructor(
    public format: ExportFormat,
    public quality?: string,
    public embedFonts?: boolean,
    public includeCharts?: boolean,
    public sheetNames?: string[]
  ) {}
}

// Types for type safety
type ReportType = "daily" | "weekly" | "monthly" | "quarterly" | "annual";
type PageSize = "A4" | "A3" | "Letter" | "Legal";
type PageOrientation = "portrait" | "landscape";
type ExportFormat = "pdf" | "xlsx" | "csv" | "html";

interface Margins {
  top: number;
  bottom: number;
  left: number;
  right: number;
}

interface DateRange {
  start: Date;
  end: Date;
}

// Abstract Factory for creating different report types
export abstract class ReportFactory {
  abstract createReport(
    userId: string,
    options?: ReportCreationOptions
  ): Report;

  protected createBaseReport(
    type: ReportType,
    userId: string,
    title: string
  ): Report {
    return new Report(
      uuidv4(),
      type,
      userId,
      title,
      new Date(),
      [],
      this.getDefaultFormatting(type),
      this.getDefaultFilters(type)
    );
  }

  protected abstract getDefaultFormatting(type: ReportType): ReportFormatting;
  protected abstract getDefaultFilters(type: ReportType): ReportFilters;
}

// Concrete factories for specific report types
export class DailyReportFactory extends ReportFactory {
  createReport(userId: string, options?: ReportCreationOptions): Report {
    const report = this.createBaseReport(
      "daily",
      userId,
      "Daily Activity Report"
    );

    // Add daily-specific sections
    report.addSection(new ReportSection("summary", "daily-summary"));
    report.addSection(new ReportSection("activities", "activity-list"));

    // Apply custom options
    if (options?.customTitle) {
      report.updateTitle(options.customTitle);
    }

    if (options?.exportSettings) {
      report.exportSettings = options.exportSettings;
    }

    return report;
  }

  protected getDefaultFormatting(type: ReportType): ReportFormatting {
    return new ReportFormatting("A4", "portrait", {
      top: 20,
      bottom: 20,
      left: 15,
      right: 15,
    });
  }

  protected getDefaultFilters(type: ReportType): ReportFilters {
    return new ReportFilters({
      start: new Date(Date.now() - 24 * 60 * 60 * 1000),
      end: new Date(),
    });
  }
}

export class WeeklyReportFactory extends ReportFactory {
  createReport(userId: string, options?: ReportCreationOptions): Report {
    const report = this.createBaseReport(
      "weekly",
      userId,
      "Weekly Performance Report"
    );

    // Add weekly-specific sections
    report.addSection(new ReportSection("summary", "weekly-summary"));
    report.addSection(new ReportSection("performance", "performance-chart"));
    report.addSection(new ReportSection("trends", "trend-analysis"));

    // Apply custom options
    if (options?.customTitle) {
      report.updateTitle(options.customTitle);
    }

    if (options?.exportSettings) {
      report.exportSettings = options.exportSettings;
    }

    return report;
  }

  protected getDefaultFormatting(type: ReportType): ReportFormatting {
    return new ReportFormatting(
      "A4",
      "landscape", // Better for charts and tables
      { top: 15, bottom: 15, left: 10, right: 10 }
    );
  }

  protected getDefaultFilters(type: ReportType): ReportFilters {
    return new ReportFilters({
      start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
      end: new Date(),
    });
  }
}

export class MonthlyReportFactory extends ReportFactory {
  createReport(userId: string, options?: ReportCreationOptions): Report {
    const report = this.createBaseReport(
      "monthly",
      userId,
      "Monthly Comprehensive Report"
    );

    // Add monthly-specific sections
    report.addSection(new ReportSection("executive-summary", "exec-summary"));
    report.addSection(
      new ReportSection("detailed-metrics", "detailed-metrics")
    );
    report.addSection(new ReportSection("comparisons", "month-over-month"));

    // Conditionally add projections section
    if (options?.includeProjections) {
      report.addSection(new ReportSection("projections", "future-projections"));
    }

    // Apply custom options
    if (options?.customTitle) {
      report.updateTitle(options.customTitle);
    }

    if (options?.exportSettings) {
      report.exportSettings = options.exportSettings;
    }

    return report;
  }

  protected getDefaultFormatting(type: ReportType): ReportFormatting {
    return new ReportFormatting("A4", "portrait", {
      top: 25,
      bottom: 25,
      left: 20,
      right: 20,
    });
  }

  protected getDefaultFilters(type: ReportType): ReportFilters {
    return new ReportFilters(
      {
        start: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
        end: new Date(),
      },
      true, // includeComparisons
      false // includeProjections (can be overridden)
    );
  }
}

// Factory registry for managing multiple factories
export class ReportFactoryRegistry {
  private factories = new Map<ReportType, ReportFactory>();

  constructor() {
    this.registerFactory("daily", new DailyReportFactory());
    this.registerFactory("weekly", new WeeklyReportFactory());
    this.registerFactory("monthly", new MonthlyReportFactory());
  }

  registerFactory(type: ReportType, factory: ReportFactory): void {
    this.factories.set(type, factory);
  }

  createReport(
    type: ReportType,
    userId: string,
    options?: ReportCreationOptions
  ): Report {
    const factory = this.factories.get(type);
    if (!factory) {
      throw new Error(`No factory registered for report type: ${type}`);
    }

    return factory.createReport(userId, options);
  }

  getSupportedTypes(): ReportType[] {
    return Array.from(this.factories.keys());
  }
}

// Builder pattern for complex report configuration
export class ReportBuilder {
  private report?: Report;

  constructor(private factoryRegistry: ReportFactoryRegistry) {}

  forUser(userId: string): ReportBuilder {
    this.userId = userId;
    return this;
  }

  ofType(type: ReportType): ReportBuilder {
    this.reportType = type;
    return this;
  }

  withTitle(title: string): ReportBuilder {
    this.customTitle = title;
    return this;
  }

  withDateRange(start: Date, end: Date): ReportBuilder {
    this.dateRange = { start, end };
    return this;
  }

  withSection(name: string, template: string, data?: any): ReportBuilder {
    if (!this.additionalSections) {
      this.additionalSections = [];
    }
    this.additionalSections.push(new ReportSection(name, template, data));
    return this;
  }

  withFormatting(formatting: Partial<ReportFormatting>): ReportBuilder {
    this.customFormatting = formatting;
    return this;
  }

  withExportSettings(settings: ExportSettings): ReportBuilder {
    this.exportSettings = settings;
    return this;
  }

  includeComparisons(include: boolean = true): ReportBuilder {
    this.shouldIncludeComparisons = include;
    return this;
  }

  includeProjections(include: boolean = true): ReportBuilder {
    this.shouldIncludeProjections = include;
    return this;
  }

  build(): Report {
    if (!this.userId || !this.reportType) {
      throw new Error("UserId and reportType are required to build a report");
    }

    const options: ReportCreationOptions = {
      customTitle: this.customTitle,
      exportSettings: this.exportSettings,
      includeProjections: this.shouldIncludeProjections,
    };

    // Create base report using factory
    const report = this.factoryRegistry.createReport(
      this.reportType,
      this.userId,
      options
    );

    // Apply builder-specific customizations
    if (this.dateRange) {
      report.filters = new ReportFilters(
        this.dateRange,
        this.shouldIncludeComparisons ?? report.filters.includeComparisons,
        this.shouldIncludeProjections ?? report.filters.includeProjections
      );
    }

    if (this.customFormatting) {
      report.formatting = Object.assign(
        report.formatting,
        this.customFormatting
      );
    }

    if (this.additionalSections) {
      this.additionalSections.forEach((section) => report.addSection(section));
    }

    return report;
  }

  // Private state for builder
  private userId?: string;
  private reportType?: ReportType;
  private customTitle?: string;
  private dateRange?: DateRange;
  private additionalSections?: ReportSection[];
  private customFormatting?: Partial<ReportFormatting>;
  private exportSettings?: ExportSettings;
  private shouldIncludeComparisons?: boolean;
  private shouldIncludeProjections?: boolean;
}

// Clean service layer using factories and builders
export class ReportService {
  constructor(private factoryRegistry: ReportFactoryRegistry) {}

  // Simple factory usage for standard reports
  generateStandardReport(type: ReportType, userId: string): Report {
    return this.factoryRegistry.createReport(type, userId);
  }

  // Builder usage for complex custom reports
  generateCustomReport(): ReportBuilder {
    return new ReportBuilder(this.factoryRegistry);
  }

  // Example business methods using the patterns
  async generateWeeklyPerformanceReport(userId: string): Promise<Report> {
    return this.generateCustomReport()
      .forUser(userId)
      .ofType("weekly")
      .withTitle("Weekly Performance Analysis")
      .withDateRange(new Date(Date.now() - 7 * 24 * 60 * 60 * 1000), new Date())
      .withExportSettings(new ExportSettings("pdf", "high", true))
      .includeComparisons(true)
      .build();
  }

  async generateExecutiveReport(
    userId: string,
    customSections: ReportSection[]
  ): Promise<Report> {
    const builder = this.generateCustomReport()
      .forUser(userId)
      .ofType("monthly")
      .withTitle("Executive Summary Report")
      .withFormatting({
        pageSize: "A3",
        orientation: "landscape",
      })
      .includeComparisons(true)
      .includeProjections(true);

    // Add custom sections dynamically
    customSections.forEach((section) => {
      builder.withSection(section.name, section.template, section.data);
    });

    return builder.build();
  }
}

// Usage examples showing the power of these patterns
interface ReportCreationOptions {
  customTitle?: string;
  exportSettings?: ExportSettings;
  includeProjections?: boolean;
}

// Clean controller using the service
export class ReportController {
  constructor(private reportService: ReportService) {}

  async generateReport(req: Request, res: Response): Promise<void> {
    try {
      const { type, userId, options } = req.body;

      let report: Report;

      if (options && Object.keys(options).length > 0) {
        // Use builder for custom reports
        const builder = this.reportService
          .generateCustomReport()
          .forUser(userId)
          .ofType(type);

        if (options.title) builder.withTitle(options.title);
        if (options.dateRange)
          builder.withDateRange(options.dateRange.start, options.dateRange.end);
        if (options.exportFormat) {
          builder.withExportSettings(new ExportSettings(options.exportFormat));
        }

        report = builder.build();
      } else {
        // Use factory for standard reports
        report = this.reportService.generateStandardReport(type, userId);
      }

      res.json({
        reportId: report.id,
        type: report.type,
        title: report.title,
        sections: report.sections.length,
        canExport: report.canExport(),
      });
    } catch (error) {
      res.status(400).json({ error: error.message });
    }
  }
}

// The nightmare of tightly coupled event handling and hardcoded algorithms
class UserService {
  private emailService = new EmailService();
  private analyticsService = new AnalyticsService();
  private notificationService = new NotificationService();
  private auditService = new AuditService();

  async createUser(userData: CreateUserRequest): Promise<User> {
    const user = new User(userData.email, userData.name);
    await this.saveUser(user);

    // Tightly coupled side effects - RED FLAG #1
    // What if EmailService is down? The whole operation fails
    await this.emailService.sendWelcomeEmail(user.email, user.name);

    // What if we need to send different emails based on user type?
    // More if/else logic scattered everywhere
    if (user.isPremium()) {
      await this.emailService.sendPremiumWelcomeEmail(user.email, user.name);
    }

    // What if AnalyticsService takes 30 seconds to respond?
    await this.analyticsService.trackUserRegistration(user);

    // Adding new side effects requires modifying this core business method
    await this.notificationService.sendAdminNotification(
      "New user registered",
      user
    );
    await this.auditService.logUserCreation(user);

    return user;
  }

  async deleteUser(userId: string): Promise<void> {
    const user = await this.findUser(userId);

    // Hardcoded deletion logic - RED FLAG #2
    await this.deleteUserPosts(userId);
    await this.deleteUserComments(userId);
    await this.deleteUserFollowers(userId);
    await this.markUserAsDeleted(userId);

    // More tightly coupled side effects
    await this.emailService.sendGoodbyeEmail(user.email, user.name);
    await this.analyticsService.trackUserDeletion(user);
    await this.auditService.logUserDeletion(user);
  }
}

// Payment processing with hardcoded strategies
class PaymentService {
  async processPayment(paymentRequest: PaymentRequest): Promise<PaymentResult> {
    // Inflexible algorithm selection - RED FLAG #3
    if (paymentRequest.amount < 10) {
      // Small payments go through micro-payment processor
      return await this.processMicroPayment(paymentRequest);
    } else if (paymentRequest.amount < 1000) {
      // Standard payments
      if (paymentRequest.country === "US") {
        return await this.processWithStripe(paymentRequest);
      } else if (paymentRequest.country === "EU") {
        return await this.processWithPayPal(paymentRequest);
      } else {
        throw new Error("Unsupported country");
      }
    } else {
      // Large payments need additional verification
      if (paymentRequest.isVerified) {
        return await this.processLargePayment(paymentRequest);
      } else {
        throw new Error("Large payments require verification");
      }
    }
  }

  // Adding new payment methods requires modifying the core logic
  private async processMicroPayment(
    request: PaymentRequest
  ): Promise<PaymentResult> {
    // Hardcoded micro-payment logic
  }

  private async processWithStripe(
    request: PaymentRequest
  ): Promise<PaymentResult> {
    // Hardcoded Stripe logic
  }

  private async processWithPayPal(
    request: PaymentRequest
  ): Promise<PaymentResult> {
    // Hardcoded PayPal logic
  }
}