Декораторы в TypeScript

// Простой декоратор класса, который сообщает об определении класса
function logClass(constructor: Function, context: ClassDecoratorContext) {
  console.log(`Класс ${constructor.name} определён в ${new Date().toISOString()}`);
}

// Применяем декоратор
@logClass
class UserService {
  getUsers() {
    return ['Alice', 'Bob', 'Charlie'];
  }
}

// Вывод при загрузке файла: "Класс UserService определён в [метка времени]"

// Декоратор, который добавляет свойство version и сообщает о создании экземпляра
function versioned(version: string) {
  return function (constructor: Function, context: ClassDecoratorContext) {
    // Добавляем статическое свойство
    constructor.prototype.version = version;

    // Сохраняем исходный конструктор
    const original: any = constructor;
    // Создаём новый конструктор, который оборачивает исходный
    const newConstructor: any = function (...args: any[]) {
      console.log(`Создание экземпляра ${original.name} v${version}`);
      return new original(...args);
    };

    // Копируем прототип, чтобы instanceof работал
    newConstructor.prototype = original.prototype;
    return newConstructor;
  };
}

// Применяем декоратор с версией
@versioned('1.0.0')
class ApiClient {
  fetchData() {
    console.log('Получение данных...');
  }
}

const client = new ApiClient();
console.log((client as any).version); // Выводит: 1.0.0
client.fetchData();

function sealed(constructor: Function, context: ClassDecoratorContext) {
  console.log(`Запечатывание ${constructor.name}...`);
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

@sealed
class Greeter {
  greeting: string;
  constructor(message: string) {
    this.greeting = message;
  }
  greet() {
    return `Привет, ${this.greeting}`;
  }
}

// В строгом режиме это вызовет ошибку
// Greeter.prototype.newMethod = function() {}; // Ошибка: невозможно добавить свойство newMethod

// Декоратор метода для измерения времени выполнения
function measureTime(
  originalMethod: any,
  context: ClassMethodDecoratorContext
) {
  const propertyKey = String(context.name);
  return function (this: any, ...args: any[]) {
    const start = performance.now();
    const result = originalMethod.apply(this, args);
    const end = performance.now();
    console.log(`${propertyKey} выполнен за ${(end - start).toFixed(2)} мс`);
    return result;
  };
}

// Используем декоратор
class DataProcessor {
  @measureTime
  processData(data: number[]): number[] {
    // Имитируем время обработки
    for (let i = 0; i < 100000000; i++) { /* обработка */ }
    return data.map(x => x * 2);
  }
}

// При вызове будет выведено время выполнения
const processor = new DataProcessor();
processor.processData([1, 2, 3, 4, 5]);

// Роли пользователей
type UserRole = 'admin' | 'editor' | 'viewer';

// Контекст текущего пользователя (упрощённый)
const currentUser = {
  id: 1,
  name: 'John Doe',
  roles: ['viewer'] as UserRole[]
};

// Фабрика декораторов для управления доступом на основе ролей
function AllowedRoles(...allowedRoles: UserRole[]) {
  return function (
    originalMethod: any,
    context: ClassMethodDecoratorContext
  ) {
    const propertyKey = String(context.name);
    return function (this: any, ...args: any[]) {
      const hasPermission = allowedRoles.some(role =>
        currentUser.roles.includes(role)
      );
      if (!hasPermission) {
        throw new Error(
          `Пользователь ${currentUser.name} не имеет права вызывать ${propertyKey}`
        );
      }
      return originalMethod.apply(this, args);
    };
  };
}

// Используем декоратор
class DocumentService {
  @AllowedRoles('admin', 'editor')
  deleteDocument(id: string) {
    console.log(`Документ ${id} удалён`);
  }
  @AllowedRoles('admin', 'editor', 'viewer')
  viewDocument(id: string) {
    console.log(`Просмотр документа ${id}`);
  }
}

// Использование
const docService = new DocumentService();
try {
  docService.viewDocument('doc123'); // Работает — роль viewer разрешена
  docService.deleteDocument('doc123'); // Выбрасывает ошибку — viewer не может удалять
} catch (error) {
  console.error(error.message);
}
// Меняем роль пользователя на admin
currentUser.roles = ['admin'];
docService.deleteDocument('doc123'); // Теперь работает — admin может удалять

function deprecated(message: string) {
  return function (
    originalMethod: any,
    context: ClassMethodDecoratorContext
  ) {
    const propertyKey = String(context.name);
    return function (this: any, ...args: any[]) {
      console.warn(`Предупреждение: ${propertyKey} устарел. ${message}`);
      return originalMethod.apply(this, args);
    };
  };
}

class PaymentService {
  @deprecated('Используйте processPaymentV2')
  processPayment(amount: number, currency: string) {
    console.log(`Обработка платежа ${amount} ${currency}`);
  }

  processPaymentV2(amount: number, currency: string) {
    console.log(`Обработка платежа v2 ${amount} ${currency}`);
  }
}

const payment = new PaymentService();
payment.processPayment(100, 'USD'); // Показывает предупреждение об устаревании
payment.processPaymentV2(100, 'USD'); // Без предупреждения

// Декоратор свойства, который форматирует строковое свойство
function format(formatString: string) {
  return function (target: ClassAccessorDecoratorTarget<any, string>, context: ClassAccessorDecoratorContext) {
    let value: string;
    const getter = () => value;
    const setter = (newVal: string) => {
      value = formatString.replace('{}', newVal);
    };
    return {
      get: getter,
      set: setter
    };
  };
}

class Greeter {
  @format('Привет, {}!')
  accessor greeting: string;
}

const greeter = new Greeter();
greeter.greeting = 'Мир';
console.log(greeter.greeting); // Выводит: Привет, Мир!

function logProperty(target: ClassAccessorDecoratorTarget<any, any>, context: ClassAccessorDecoratorContext) {
  const propertyKey = String(context.name);
  let value: any;
  const getter = function() {
    console.log(`Чтение ${propertyKey}: ${value}`);
    return value;
  };

  const setter = function(newVal: any) {
    console.log(`Запись ${propertyKey} с ${value} на ${newVal}`);
    value = newVal;
  };

  return {
    get: getter,
    set: setter
  };
}

class Product {
  @logProperty
  accessor name: string;
  @logProperty
  accessor price: number;

  constructor(name: string, price: number) {
    this.name = name;
    this.price = price;
  }
}

const product = new Product('Ноутбук', 999.99);
product.price = 899.99; // Выводит: Запись price с 999.99 на 899.99
console.log(product.name); // Выводит: Чтение name: Ноутбук

function required(target: ClassAccessorDecoratorTarget<any, any>, context: ClassAccessorDecoratorContext) {
  const propertyKey = String(context.name);
  let value: any;

  const getter = function() {
    if (value === undefined) {
      throw new Error(`Свойство ${propertyKey} обязательно`);
    }
    return value;
  };

  const setter = function(newVal: any) {
    value = newVal;
  };

  return {
    get: getter,
    set: setter
  };
}

class User {
  @required
  accessor username: string;
  @required
  accessor email: string;
  age?: number;

  constructor(username: string, email: string) {
    this.username = username;
    this.email = email;
  }
}

const user1 = new User('johndoe', 'john@example.com'); // Работает
// const user2 = new User(undefined, 'test@example.com'); // Выбрасывает ошибку: Свойство username обязательно
// const user2 = new User('johndoe', undefined); // Выбрасывает ошибку: Свойство email обязательно

type ParamType = 'string' | 'number' | 'boolean';

// Описывает одно правило для параметра: какой тип ожидается на какой позиции
function validateParam(type: ParamType) {
  return { type };
}

// Декоратор метода: правила перечислены в том же порядке, что и параметры
function validate(...rules: { type: ParamType }[]) {
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    const validations: Array<{index: number, type: string}> =
      rules.map((rule, index) => ({ index, type: rule.type }));

    return function (this: any, ...args: any[]) {
      for (const validation of validations) {
        const { index, type } = validation;
        const param = args[index];
        let isValid = false;

        switch (type) {
          case 'string':
            isValid = typeof param === 'string' && param.length > 0;
            break;
          case 'number':
            isValid = typeof param === 'number' && !isNaN(param);
            break;
          case 'boolean':
            isValid = typeof param === 'boolean';
        }

        if (!isValid) {
          throw new Error(`Параметр с индексом ${index} не прошёл проверку типа ${type}`);
        }
      }

      return originalMethod.apply(this, args);
    };
  };
}

class UserService {
  @validate(validateParam('string'), validateParam('number'), validateParam('boolean'))
  createUser(name: string, age: number, isActive: boolean) {
    console.log(`Создание пользователя: ${name}, ${age}, ${isActive}`);
  }
}

const service = new UserService();
service.createUser('John', 30, true); // Работает
// service.createUser('', 30, true); // Выбрасывает ошибку: Параметр с индексом 0 не прошёл проверку типа string
// service.createUser('John', 'thirty' as any, true); // Выбрасывает ошибку: Параметр с индексом 1 не прошёл проверку типа number

// Фабрика декораторов, которая принимает конфигурацию
function logWithConfig(config: { level: 'log' | 'warn' | 'error', message?: string }) {
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    const propertyKey = String(context.name);
    return function (this: any, ...args: any[]) {
      const { level = 'log', message = 'Выполнение метода' } = config;
      console[level](`${message}: ${propertyKey}`, { arguments: args });
      const result = originalMethod.apply(this, args);
      console[level](`${propertyKey} завершён`);
      return result;
    };
  };
}

class PaymentService {
  @logWithConfig({ level: 'log', message: 'Обработка платежа' })
  processPayment(amount: number) {
    console.log(`Обработка платежа на $${amount}`);
  }
}

function first() {
  console.log('first(): фабрика вычислена');
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    console.log('first(): вызван');
  };
}

function second() {
  console.log('second(): фабрика вычислена');
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    console.log('second(): вызван');
  };
}

class ExampleClass {
  @first()
  @second()
  method() {}
}

// Вывод:
// first(): фабрика вычислена
// second(): фабрика вычислена
// second(): вызван
// first(): вызван

// Простые реализации декораторов (упрощены для примера)
const ROUTES: any[] = [];

function Controller(prefix: string = '') {
  return function (constructor: Function, context: ClassDecoratorContext) {
    constructor.prototype.prefix = prefix;
    // Декораторы методов выполняются раньше декоратора класса, поэтому
    // собранные до этого момента маршруты без цели принадлежат этому классу
    ROUTES.forEach(route => {
      if (!route.target) {
        route.target = constructor;
      }
    });
  };
}

function Get(path: string = '') {
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    ROUTES.push({
      method: 'get',
      path,
      handler: originalMethod,
      target: undefined
    });
  };
}

// Используем декораторы
@Controller('/users')
class UserController {
  @Get('/')
  getAllUsers() {
    return { users: [{ id: 1, name: 'John' }] };
  }

  @Get('/:id')
  getUserById(id: string) {
    return { id, name: 'John' };
  }
}

// Имитируем регистрацию маршрутов
function registerRoutes() {
  ROUTES.forEach(route => {
    const prefix = route.target.prototype.prefix || '';
    console.log(`Зарегистрирован ${route.method.toUpperCase()} ${prefix}${route.path}`);
  });
}

registerRoutes();
// Вывод:
// Зарегистрирован GET /users/
// Зарегистрирован GET /users/:id