// tsconfig.json
{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true  // needed for reflect-metadata (DI frameworks)
  }
}

// A class decorator receives the constructor as its only argument
function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

function log(constructor: Function) {
  console.log(`Class created: ${constructor.name}`);
}

@sealed
@log
class BankAccount {
  balance = 0;
}
// Output: "Class created: BankAccount"
// BankAccount is now sealed — no new properties can be added

// Decorator factory — returns a decorator (allows configuration)
function Component(options: { selector: string; template: string }) {
  return function (constructor: Function) {
    (constructor as any).selector = options.selector;
    (constructor as any).template = options.template;
    console.log(`Component registered: ${options.selector}`);
  };
}

@Component({
  selector: 'app-root',
  template: '<h1>Hello</h1>',
})
class AppComponent {
  title = 'My App';
}

console.log((AppComponent as any).selector); // 'app-root'

function log(
  target: object,
  propertyKey: string,
  descriptor: PropertyDescriptor,
) {
  const originalMethod = descriptor.value as (...args: unknown[]) => unknown;

  descriptor.value = function (...args: unknown[]) {
    console.log(`Calling ${propertyKey} with args:`, args);
    const result = originalMethod.apply(this, args);
    console.log(`${propertyKey} returned:`, result);
    return result;
  };

  return descriptor;
}

function memoize(
  _target: object,
  _key: string,
  descriptor: PropertyDescriptor,
) {
  const original = descriptor.value as (...args: unknown[]) => unknown;
  const cache = new Map<string, unknown>();

  descriptor.value = function (...args: unknown[]) {
    const cacheKey = JSON.stringify(args);
    if (cache.has(cacheKey)) {
      return cache.get(cacheKey);
    }
    const result = original.apply(this, args);
    cache.set(cacheKey, result);
    return result;
  };
}

class Calculator {
  @log
  add(a: number, b: number): number {
    return a + b;
  }

  @memoize
  fibonacci(n: number): number {
    if (n <= 1) return n;
    return this.fibonacci(n - 1) + this.fibonacci(n - 2);
  }
}

const calc = new Calculator();
calc.add(3, 4);
// Calling add with args: [3, 4]
// add returned: 7

// Using reflect-metadata to store validation rules
import 'reflect-metadata';

function MinLength(min: number) {
  return function (target: object, propertyKey: string) {
    const existing: Array<{ key: string; min: number }> =
      Reflect.getMetadata('validators', target) ?? [];
    Reflect.defineMetadata(
      'validators',
      [...existing, { key: propertyKey, min }],
      target,
    );
  };
}

function validate(instance: object): string[] {
  const validators: Array<{ key: string; min: number }> =
    Reflect.getMetadata('validators', Object.getPrototypeOf(instance)) ?? [];
  return validators
    .filter(({ key, min }) => {
      const value = (instance as Record<string, unknown>)[key];
      return typeof value === 'string' && value.length < min;
    })
    .map(({ key, min }) => `${key} must be at least ${min} characters`);
}

class User {
  @MinLength(3)
  name: string;

  @MinLength(8)
  password: string;

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

const u = new User('Al', 'pass');
console.log(validate(u));
// ['name must be at least 3 characters', 'password must be at least 8 characters']

import 'reflect-metadata';

function Inject(token: string) {
  return function (target: object, _methodKey: string | undefined, paramIndex: number) {
    const existing: Array<{ index: number; token: string }> =
      Reflect.getMetadata('inject', target) ?? [];
    Reflect.defineMetadata('inject', [...existing, { index: paramIndex, token }], target);
  };
}

class AppController {
  constructor(
    @Inject('UserService') private userService: unknown,
    @Inject('AuthService') private authService: unknown,
  ) {}
}

function classDecorator(label: string) {
  return (_: Function) => console.log(`Class: ${label}`);
}
function methodDecorator(label: string) {
  return (_: object, __: string, ___: PropertyDescriptor) =>
    console.log(`Method: ${label}`);
}

@classDecorator('C1')  // executed last (outermost)
@classDecorator('C2')  // executed second-to-last
class Example {
  @methodDecorator('M1') // applied second (outermost)
  @methodDecorator('M2') // applied first (innermost)
  greet() {}
}

// Output:
// Method: M2
// Method: M1
// Class: C2
// Class: C1

// TypeScript 5 — no tsconfig flags needed (experimentalDecorators must be false/absent)

// Class decorator — receives the class and a context object
function frozen<T extends new (...args: unknown[]) => object>(
  target: T,
  context: ClassDecoratorContext,
) {
  return class extends target {
    constructor(...args: unknown[]) {
      super(...args);
      Object.freeze(this);
    }
  };
}

@frozen
class Config {
  host = 'localhost';
  port = 3000;
}

const cfg = new Config();
cfg.host = 'prod.example.com'; // silently fails (frozen in strict: throws TypeError)
console.log(cfg.host); // 'localhost'

// Method decorator in ECMAScript decorator style
function log<This, Args extends unknown[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>,
) {
  const methodName = String(context.name);

  return function (this: This, ...args: Args): Return {
    console.log(`[${methodName}] called with:`, args);
    const result = target.call(this, ...args);
    console.log(`[${methodName}] returned:`, result);
    return result;
  };
}

// Bound method decorator — ensures 'this' is always the class instance
function bound<This, Args extends unknown[], Return>(
  target: (this: This, ...args: Args) => Return,
  context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>,
) {
  context.addInitializer(function (this: This) {
    // 'this' here is the instance being constructed
    (this as Record<string | symbol, unknown>)[context.name] =
      target.bind(this);
  });
}

class Timer {
  count = 0;

  @log
  increment(): number {
    return ++this.count;
  }

  @bound
  tick(): void {
    this.increment();
  }
}

const t = new Timer();
t.increment(); // [increment] called with: []   [increment] returned: 1
const tick = t.tick; // safely extractable — bound by decorator
tick();
console.log(t.count); // 2

// Field/property decorator in ECMAScript style
function required(
  _target: undefined,
  context: ClassFieldDecoratorContext,
) {
  return function (this: object, value: unknown) {
    if (value === undefined || value === null || value === '') {
      throw new Error(`Field "${String(context.name)}" is required`);
    }
    return value;
  };
}

function clamp(min: number, max: number) {
  return function (_target: undefined, _context: ClassFieldDecoratorContext) {
    return function (_this: object, value: unknown): number {
      if (typeof value !== 'number') throw new Error('Expected a number');
      return Math.min(Math.max(value, min), max);
    };
  };
}

class UserProfile {
  @required
  name: string;

  @clamp(0, 150)
  age: number;

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

const p = new UserProfile('Alice', 25);
console.log(p.age); // 25

const p2 = new UserProfile('Bob', 200);
console.log(p2.age); // 150 — clamped

// const p3 = new UserProfile('', 30); // ❌ throws: Field "name" is required

import {
  Controller, Get, Post, Body, Param, HttpCode,
  HttpStatus, UseGuards, Injectable,
} from '@nestjs/common';

// ─── Service ──────────────────────────────────────────────────
@Injectable()
export class UserService {
  constructor(
    // @InjectRepository uses parameter decorators + reflect-metadata
    // to wire up the database connection at runtime
    @InjectRepository(User)
    private readonly repo: Repository<User>,
  ) {}

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

  async findOne(id: string): Promise<User | null> {
    return this.repo.findOneBy({ id });
  }
}

// ─── Controller ───────────────────────────────────────────────
@Controller('users')        // ← class decorator: registers route prefix
@UseGuards(AuthGuard)       // ← class decorator: applies guard to all routes
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get()                    // ← method decorator: GET /users
  findAll(): Promise<User[]> {
    return this.userService.findAll();
  }

  @Get(':id')               // ← method decorator: GET /users/:id
  findOne(@Param('id') id: string): Promise<User | null> {
    //      ↑ parameter decorator extracts :id from route params
    return this.userService.findOne(id);
  }

  @Post()                   // ← method decorator: POST /users
  @HttpCode(HttpStatus.CREATED)
  create(@Body() dto: CreateUserDto): Promise<User> {
    //     ↑ parameter decorator parses request body
    return this.userService.create(dto);
  }
}

import { Component, Input, Output, EventEmitter, OnInit } from '@angular/core';

@Component({
  selector: 'app-user-card',
  template: `
    <div class="card">
      <h2>{{ user.name }}</h2>
      <p>{{ user.email }}</p>
      <button (click)="onSelect()">Select</button>
    </div>
  `,
  styles: [`
    .card { border: 1px solid #ccc; padding: 1rem; border-radius: 4px; }
  `],
})
export class UserCardComponent implements OnInit {
  @Input() user!: { name: string; email: string }; // receives data from parent
  @Output() selected = new EventEmitter<string>(); // emits to parent

  ngOnInit(): void {
    console.log('UserCard initialised for', this.user.name);
  }

  onSelect(): void {
    this.selected.emit(this.user.email);
  }
}

// Injectable service
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable({ providedIn: 'root' })  // registers in root injector
export class ApiService {
  constructor(private http: HttpClient) {}

  getUsers(): Observable<User[]> {
    return this.http.get<User[]>('/api/users');
  }
}

// validation.ts — TS5 ECMAScript decorators

type Validator = (value: unknown) => string | null;
const VALIDATORS = Symbol('validators');

function addValidator(
  context: ClassFieldDecoratorContext,
  validator: Validator,
) {
  context.addInitializer(function (this: Record<symbol, Validator[]>) {
    const field = String(context.name);
    const existing = (this[VALIDATORS] ??= {}) as Record<string, Validator[]>;
    existing[field] = [...(existing[field] ?? []), validator];
  });
}

export function required(_: undefined, context: ClassFieldDecoratorContext) {
  return (value: unknown) => {
    addValidator(context, (v) =>
      v === undefined || v === null || v === ''
        ? `${String(context.name)} is required`
        : null,
    );
    return value;
  };
}

export function minLength(min: number) {
  return (_: undefined, context: ClassFieldDecoratorContext) => {
    addValidator(context, (v) =>
      typeof v === 'string' && v.length < min
        ? `${String(context.name)} must be at least ${min} characters`
        : null,
    );
    return (value: unknown) => value;
  };
}

export function isEmail(_: undefined, context: ClassFieldDecoratorContext) {
  return (value: unknown) => {
    addValidator(context, (v) =>
      typeof v === 'string' && !/^[^@]+@[^@]+\.[^@]+$/.test(v)
        ? `${String(context.name)} must be a valid email address`
        : null,
    );
    return value;
  };
}

export function validate(instance: object): string[] {
  const validators = (instance as Record<symbol, Record<string, Validator[]>>)[VALIDATORS] ?? {};
  return Object.entries(validators).flatMap(([key, fns]) =>
    fns
      .map(fn => fn((instance as Record<string, unknown>)[key]))
      .filter((e): e is string => e !== null),
  );
}

// Usage
class RegistrationForm {
  @required
  @minLength(2)
  name = '';

  @required
  @isEmail
  email = '';

  @required
  @minLength(8)
  password = '';
}

const form = new RegistrationForm();
form.name = 'A';
form.email = 'not-an-email';
form.password = 'short';

console.log(validate(form));
// ['name must be at least 2 characters',
//  'email must be a valid email address',
//  'password must be at least 8 characters']