Decorator

interface UserRepository {
  findById(id: string): Promise<User | null>;
  findAll(): Promise<User[]>;
  save(user: User): Promise<User>;
}

// Implémentation de base
class ApiUserRepository implements UserRepository {
  async findById(id: string) { /* appel API */ }
  async findAll() { /* appel API */ }
  async save(user: User) { /* appel API */ }
}

// Decorator : ajoute du cache sans modifier ApiUserRepository
class CachedUserRepository implements UserRepository {
  private cache = new Map<string, User>();

  constructor(private repository: UserRepository) {}

  async findById(id: string): Promise<User | null> {
    if (this.cache.has(id)) {
      return this.cache.get(id)!;
    }
    const user = await this.repository.findById(id);
    if (user) this.cache.set(id, user);
    return user;
  }

  async findAll(): Promise<User[]> {
    return this.repository.findAll();
  }

  async save(user: User): Promise<User> {
    const saved = await this.repository.save(user);
    this.cache.set(saved.id, saved); // met à jour le cache
    return saved;
  }
}

// Decorator : ajoute du logging
class LoggedUserRepository implements UserRepository {
  constructor(private repository: UserRepository, private logger: Logger) {}

  async findById(id: string) {
    this.logger.info(`findById: ${id}`);
    const result = await this.repository.findById(id);
    this.logger.info(`findById: ${id} → ${result ? 'found' : 'not found'}`);
    return result;
  }

  async findAll() {
    this.logger.info('findAll');
    return this.repository.findAll();
  }

  async save(user: User) {
    this.logger.info(`save: ${user.id}`);
    return this.repository.save(user);
  }
}

// Composition de decorators
const repository = new LoggedUserRepository(
  new CachedUserRepository(
    new ApiUserRepository()
  ),
  logger
);

// HOC : ajoute une garde d'authentification
function withAuth<P extends object>(WrappedComponent: React.ComponentType<P>) {
  return function AuthGuard(props: P) {
    const { isAuthenticated, isLoading } = useAuth();

    if (isLoading) return <Spinner />;
    if (!isAuthenticated) return <Navigate to="/login" />;

    return <WrappedComponent {...props} />;
  };
}

// HOC : ajoute un boundary d'erreur
function withErrorBoundary<P extends object>(WrappedComponent: React.ComponentType<P>) {
  return function WithErrorBoundary(props: P) {
    return (
      <ErrorBoundary fallback={<ErrorMessage />}>
        <WrappedComponent {...props} />
      </ErrorBoundary>
    );
  };
}

// Composition de HOC
const ProtectedDashboard = withAuth(withErrorBoundary(Dashboard));

// Hook de base
function useUsers() {
  return useQuery({ queryKey: ['users'], queryFn: fetchUsers });
}

// "Decorator" : ajoute du logging autour du hook
function useUsersWithLogging() {
  const query = useUsers();

  useEffect(() => {
    if (query.isError) {
      logger.error('Failed to fetch users', query.error);
    }
  }, [query.isError, query.error]);

  return query;
}

function Log(target: unknown, key: string, descriptor: PropertyDescriptor) {
  const original = descriptor.value;
  descriptor.value = async function (...args: unknown[]) {
    console.log(`${key} called with`, args);
    const result = await original.apply(this, args);
    console.log(`${key} returned`, result);
    return result;
  };
  return descriptor;
}

class UserService {
  @Log
  async getUser(id: string): Promise<User> {
    return fetch(`/api/users/${id}`).then(r => r.json());
  }
}