TypeScript Decorators

// A simple class decorator that logs class definition
function logClass(constructor: Function, context: ClassDecoratorContext) {
  console.log(`Class ${constructor.name} was defined at ${new Date().toISOString()}`);
}

// Applying the decorator
@logClass
class UserService {
  getUsers() {
    return ['Alice', 'Bob', 'Charlie'];
  }
}

// Output when the file is loaded: "Class UserService was defined at [timestamp]"

// A decorator that adds a version property and logs instantiation
function versioned(version: string) {
  return function (constructor: Function, context: ClassDecoratorContext) {
    // Add a static property
    constructor.prototype.version = version;

    // Store the original constructor
    const original: any = constructor;
    // Create a new constructor that wraps the original
    const newConstructor: any = function (...args: any[]) {
      console.log(`Creating instance of ${original.name} v${version}`);
      return new original(...args);
    };

    // Copy prototype so instanceof works
    newConstructor.prototype = original.prototype;
    return newConstructor;
  };
}

// Applying the decorator with a version
@versioned('1.0.0')
class ApiClient {
  fetchData() {
    console.log('Fetching data...');
  }
}

const client = new ApiClient();
console.log((client as any).version); // Outputs: 1.0.0
client.fetchData();

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

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

// This will throw an error in strict mode
// Greeter.prototype.newMethod = function() {}; // Error: Cannot add property newMethod

// Method decorator to measure execution time
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} executed in ${(end - start).toFixed(2)}ms`);
    return result;
  };
}

// Using the decorator
class DataProcessor {
  @measureTime
  processData(data: number[]): number[] {
    // Simulate processing time
    for (let i = 0; i < 100000000; i++) { /* processing */ }
    return data.map(x => x * 2);
  }
}

// When called, it will log the execution time
const processor = new DataProcessor();
processor.processData([1, 2, 3, 4, 5]);

// User roles
type UserRole = 'admin' | 'editor' | 'viewer';

// Current user context (simplified)
const currentUser = {
  id: 1,
  name: 'John Doe',
  roles: ['viewer'] as UserRole[]
};

// Decorator factory for role-based access control
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(
          `User ${currentUser.name} is not authorized to call ${propertyKey}`
        );
      }
      return originalMethod.apply(this, args);
    };
  };
}

// Using the decorator
class DocumentService {
  @AllowedRoles('admin', 'editor')
  deleteDocument(id: string) {
    console.log(`Document ${id} deleted`);
  }
  @AllowedRoles('admin', 'editor', 'viewer')
  viewDocument(id: string) {
    console.log(`Viewing document ${id}`);
  }
}

// Usage
const docService = new DocumentService();
try {
  docService.viewDocument('doc123'); // Works - viewer role is allowed
  docService.deleteDocument('doc123'); // Throws error - viewer cannot delete
} catch (error) {
  console.error(error.message);
}
// Change user role to admin
currentUser.roles = ['admin'];
docService.deleteDocument('doc123'); // Now works - admin can delete

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

class PaymentService {
  @deprecated('Use processPaymentV2 instead')
  processPayment(amount: number, currency: string) {
    console.log(`Processing payment of ${amount} ${currency}`);
  }

  processPaymentV2(amount: number, currency: string) {
    console.log(`Processing payment v2 of ${amount} ${currency}`);
  }
}

const payment = new PaymentService();
payment.processPayment(100, 'USD'); // Shows deprecation warning
payment.processPaymentV2(100, 'USD'); // No warning

// Property decorator to format a string property
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('Hello, {}!')
  accessor greeting: string;
}

const greeter = new Greeter();
greeter.greeting = 'World';
console.log(greeter.greeting); // Outputs: Hello, World!

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

  const setter = function(newVal: any) {
    console.log(`Setting ${propertyKey} from ${value} to ${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; // Logs: Setting price from 999.99 to 899.99
console.log(product.name); // Logs: Getting 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(`Property ${propertyKey} is required`);
    }
    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', '[email protected]'); // Works
// const user2 = new User(undefined, '[email protected]'); // Throws error: Property username is required
// const user2 = new User('johndoe', undefined); // Throws error: Property email is required

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

// Describes one parameter rule: which type is expected at which position
function validateParam(type: ParamType) {
  return { type };
}

// Method decorator: the rules are listed in the same order as the parameters
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(`Parameter at index ${index} failed ${type} validation`);
        }
      }

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

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

const service = new UserService();
service.createUser('John', 30, true); // Works
// service.createUser('', 30, true); // Throws error: Parameter at index 0 failed string validation
// service.createUser('John', 'thirty' as any, true); // Throws error: Parameter at index 1 failed number validation

// Decorator factory that accepts configuration
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 = 'Executing method' } = config;
      console[level](`${message}: ${propertyKey}`, { arguments: args });
      const result = originalMethod.apply(this, args);
      console[level](`${propertyKey} completed`);
      return result;
    };
  };
}

class PaymentService {
  @logWithConfig({ level: 'log', message: 'Processing payment' })
  processPayment(amount: number) {
    console.log(`Processing payment of $${amount}`);
  }
}

function first() {
  console.log('first(): factory evaluated');
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    console.log('first(): called');
  };
}

function second() {
  console.log('second(): factory evaluated');
  return function (originalMethod: any, context: ClassMethodDecoratorContext) {
    console.log('second(): called');
  };
}

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

// Output:
// first(): factory evaluated
// second(): factory evaluated
// second(): called
// first(): called

// Simple decorator implementations (simplified for example)
const ROUTES: any[] = [];

function Controller(prefix: string = '') {
  return function (constructor: Function, context: ClassDecoratorContext) {
    constructor.prototype.prefix = prefix;
    // Method decorators run before the class decorator, so the routes
    // collected so far without a target belong to this class
    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
    });
  };
}

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

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

// Simulate route registration
function registerRoutes() {
  ROUTES.forEach(route => {
    const prefix = route.target.prototype.prefix || '';
    console.log(`Registered ${route.method.toUpperCase()} ${prefix}${route.path}`);
  });
}

registerRoutes();
// Output:
// Registered GET /users/
// Registered GET /users/:id