Decoratori în TypeScript

// Un decorator de clasă simplu care afișează definirea clasei
function logClass(constructor: Function, context: ClassDecoratorContext) {
  console.log(`Clasa ${constructor.name} a fost definită la ${new Date().toISOString()}`);
}

// Aplicarea decoratorului
@logClass
class UserService {
  getUsers() {
    return ['Alice', 'Bob', 'Charlie'];
  }
}

// Rezultatul afișat la încărcarea fișierului: „Clasa UserService a fost definită la [marcaj de timp]”

// Un decorator care adaugă o proprietate version și afișează crearea instanțelor
function versioned(version: string) {
  return function (constructor: Function, context: ClassDecoratorContext) {
    // Adaugă o proprietate statică
    constructor.prototype.version = version;

    // Păstrează constructorul original
    const original: any = constructor;
    // Creează un constructor nou care îl învelește pe cel original
    const newConstructor: any = function (...args: any[]) {
      console.log(`Se creează o instanță de ${original.name} v${version}`);
      return new original(...args);
    };

    // Copiază prototipul, ca instanceof să funcționeze
    newConstructor.prototype = original.prototype;
    return newConstructor;
  };
}

// Aplicarea decoratorului cu o versiune
@versioned('1.0.0')
class ApiClient {
  fetchData() {
    console.log('Se preiau datele...');
  }
}

const client = new ApiClient();
console.log((client as any).version); // Afișează: 1.0.0
client.fetchData();

function sealed(constructor: Function, context: ClassDecoratorContext) {
  console.log(`Se sigilează ${constructor.name}...`);
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

@sealed
class Greeter {
  greeting: string;
  constructor(message: string) {
    this.greeting = message;
  }
  greet() {
    return `Salut, ${this.greeting}`;
  }
}

// Acest lucru va arunca o eroare în modul strict
// Greeter.prototype.newMethod = function() {}; // Eroare: nu se poate adăuga proprietatea newMethod

// Decorator de metodă pentru măsurarea timpului de execuție
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} s-a executat în ${(end - start).toFixed(2)}ms`);
    return result;
  };
}

// Folosirea decoratorului
class DataProcessor {
  @measureTime
  processData(data: number[]): number[] {
    // Simulează timpul de prelucrare
    for (let i = 0; i < 100000000; i++) { /* prelucrare */ }
    return data.map(x => x * 2);
  }
}

// Atunci când este apelată, va afișa timpul de execuție
const processor = new DataProcessor();
processor.processData([1, 2, 3, 4, 5]);

// Rolurile utilizatorilor
type UserRole = 'admin' | 'editor' | 'viewer';

// Contextul utilizatorului curent (simplificat)
const currentUser = {
  id: 1,
  name: 'John Doe',
  roles: ['viewer'] as UserRole[]
};

// Fabrică de decoratori pentru controlul accesului pe bază de roluri
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(
          `Utilizatorul ${currentUser.name} nu este autorizat să apeleze ${propertyKey}`
        );
      }
      return originalMethod.apply(this, args);
    };
  };
}

// Folosirea decoratorului
class DocumentService {
  @AllowedRoles('admin', 'editor')
  deleteDocument(id: string) {
    console.log(`Documentul ${id} a fost șters`);
  }
  @AllowedRoles('admin', 'editor', 'viewer')
  viewDocument(id: string) {
    console.log(`Se vizualizează documentul ${id}`);
  }
}

// Utilizare
const docService = new DocumentService();
try {
  docService.viewDocument('doc123'); // Funcționează - rolul viewer este permis
  docService.deleteDocument('doc123'); // Aruncă o eroare - viewer nu poate șterge
} catch (error) {
  console.error(error.message);
}
// Schimbă rolul utilizatorului în admin
currentUser.roles = ['admin'];
docService.deleteDocument('doc123'); // Acum funcționează - admin poate șterge

function deprecated(message: string) {
  return function (
    originalMethod: any,
    context: ClassMethodDecoratorContext
  ) {
    const propertyKey = String(context.name);
    return function (this: any, ...args: any[]) {
      console.warn(`Avertisment: ${propertyKey} este învechită. ${message}`);
      return originalMethod.apply(this, args);
    };
  };
}

class PaymentService {
  @deprecated('Folosește processPaymentV2 în schimb')
  processPayment(amount: number, currency: string) {
    console.log(`Se procesează plata de ${amount} ${currency}`);
  }

  processPaymentV2(amount: number, currency: string) {
    console.log(`Se procesează plata v2 de ${amount} ${currency}`);
  }
}

const payment = new PaymentService();
payment.processPayment(100, 'USD'); // Afișează avertismentul de învechire
payment.processPaymentV2(100, 'USD'); // Fără avertisment

// Decorator de proprietate pentru formatarea unei proprietăți de tip string
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('Salut, {}!')
  accessor greeting: string;
}

const greeter = new Greeter();
greeter.greeting = 'Lume';
console.log(greeter.greeting); // Afișează: Salut, Lume!

function logProperty(target: ClassAccessorDecoratorTarget<any, any>, context: ClassAccessorDecoratorContext) {
  const propertyKey = String(context.name);
  let value: any;
  const getter = function() {
    console.log(`Se citește ${propertyKey}: ${value}`);
    return value;
  };

  const setter = function(newVal: any) {
    console.log(`Se setează ${propertyKey} de la ${value} la ${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('Laptop', 999.99);
product.price = 899.99; // Afișează: Se setează price de la 999.99 la 899.99
console.log(product.name); // Afișează: Se citește name: Laptop

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(`Proprietatea ${propertyKey} este obligatorie`);
    }
    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'); // Funcționează
// const user2 = new User(undefined, 'test@example.com'); // Aruncă eroare: Proprietatea username este obligatorie
// const user2 = new User('johndoe', undefined); // Aruncă eroare: Proprietatea email este obligatorie

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

// Descrie o regulă pentru un parametru: ce tip este așteptat pe ce poziție
function validateParam(type: ParamType) {
  return { type };
}

// Decorator de metodă: regulile sunt enumerate în aceeași ordine ca parametrii
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(`Parametrul de la indexul ${index} nu a trecut validarea ${type}`);
        }
      }

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

class UserService {
  @validate(validateParam('string'), validateParam('number'), validateParam('boolean'))
  createUser(name: string, age: number, isActive: boolean) {
    console.log(`Se creează utilizatorul: ${name}, ${age}, ${isActive}`);
  }
}

const service = new UserService();
service.createUser('John', 30, true); // Funcționează
// service.createUser('', 30, true); // Aruncă eroare: Parametrul de la indexul 0 nu a trecut validarea string
// service.createUser('John', 'thirty' as any, true); // Aruncă eroare: Parametrul de la indexul 1 nu a trecut validarea number

// Fabrică de decoratori care acceptă o configurație
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 = 'Se execută metoda' } = config;
      console[level](`${message}: ${propertyKey}`, { arguments: args });
      const result = originalMethod.apply(this, args);
      console[level](`${propertyKey} s-a încheiat`);
      return result;
    };
  };
}

class PaymentService {
  @logWithConfig({ level: 'log', message: 'Se procesează plata' })
  processPayment(amount: number) {
    console.log(`Se procesează plata de $${amount}`);
  }
}

function first() {
  console.log('first(): fabrică evaluată');
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    console.log('first(): apelat');
  };
}

function second() {
  console.log('second(): fabrică evaluată');
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    console.log('second(): apelat');
  };
}

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

// Rezultat:
// first(): fabrică evaluată
// second(): fabrică evaluată
// second(): apelat
// first(): apelat

// Implementări simple de decoratori (simplificate pentru exemplu)
const ROUTES: any[] = [];

function Controller(prefix: string = '') {
  return function (constructor: Function, context: ClassDecoratorContext) {
    constructor.prototype.prefix = prefix;
    // Decoratorii de metodă rulează înaintea decoratorului de clasă, așa că
    // rutele colectate până acum fără o țintă aparțin acestei clase
    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
    });
  };
}

// Folosirea decoratorilor
@Controller('/users')
class UserController {
  @Get('/')
  getAllUsers() {
    return { users: [{ id: 1, name: 'John' }] };
  }

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

// Simulează înregistrarea rutelor
function registerRoutes() {
  ROUTES.forEach(route => {
    const prefix = route.target.prototype.prefix || '';
    console.log(`Înregistrat ${route.method.toUpperCase()} ${prefix}${route.path}`);
  });
}

registerRoutes();
// Rezultat:
// Înregistrat GET /users/
// Înregistrat GET /users/:id