// Subsystems — כל אחד אחראי על דבר אחד
class UserValidator {
  validate(data: RegisterRequest): { valid: boolean; errors: string[] } {
    const errors: string[] = [];
    if (!data.email.includes('@')) errors.push('Invalid email');
    if (data.password.length < 8) errors.push('Password too short');
    if (!data.name.trim()) errors.push('Name required');
    return { valid: errors.length === 0, errors };
  }
}

class PasswordHasher {
  async hash(password: string): Promise<string> {
    // bcrypt in production
    return `hashed_${password}_salt`;
  }
}

class UserRepository {
  async create(data: {
    email: string;
    name: string;
    password: string;
  }): Promise<string> {
    console.log('DB: Creating user', data.email);
    return `user_${Date.now()}`;
  }

  async findByEmail(email: string): Promise<{ id: string; email: string } | null> {
    console.log('DB: Finding user', email);
    return null;
  }
}

class WelcomeEmailService {
  async sendWelcome(to: string, name: string): Promise<void> {
    console.log(`Email: Sending welcome to ${to}`);
  }

  async sendPasswordReset(to: string, token: string): Promise<void> {
    console.log(`Email: Sending reset to ${to}`);
  }
}

// Facade — Interface פשוט לכל הלוגיקה
interface RegisterRequest {
  email: string;
  password: string;
  name: string;
}

interface RegisterResult {
  userId: string;
  email: string;
}

class UserServiceFacade {
  private validator = new UserValidator();
  private hasher = new PasswordHasher();
  private repository = new UserRepository();
  private mailer = new WelcomeEmailService();

  async register(data: RegisterRequest): Promise<RegisterResult> {
    // ולידציה
    const validation = this.validator.validate(data);
    if (!validation.valid) {
      throw new Error(`Validation failed: ${validation.errors.join(', ')}`);
    }

    // בדיקה שהמשתמש לא קיים
    const existing = await this.repository.findByEmail(data.email);
    if (existing) {
      throw new Error('Email already registered');
    }

    // הצפנה
    const hashedPassword = await this.hasher.hash(data.password);

    // שמירה
    const userId = await this.repository.create({
      email: data.email,
      name: data.name,
      password: hashedPassword,
    });

    // שליחת Email
    await this.mailer.sendWelcome(data.email, data.name);

    console.log(`User registered: ${userId}`);
    return { userId, email: data.email };
  }

  async requestPasswordReset(email: string): Promise<void> {
    const user = await this.repository.findByEmail(email);
    if (!user) return; // לא חושפים אם Email קיים

    const token = crypto.randomUUID();
    await this.mailer.sendPasswordReset(email, token);
  }
}

// Controller — פשוט ונקי
class UserRegistrationController {
  constructor(private userService: UserServiceFacade) {}

  async register(data: RegisterRequest) {
    // Controller לא יודע על Validator, Hasher, DB, או Mailer
    return this.userService.register(data);
  }
}
Facade Pattern — ממשק פשוט למערכת מורכבת

Facade Pattern — ממשק פשוט למערכת מורכבת

Facade Pattern — ממשק פשוט למערכת מורכבת
