How to fix Parameter decorator cannot use 'readonly' modifier in TypeScript

// WRONG - readonly with parameter decorator
class UserService {
  constructor(
    @Inject(HttpService) readonly http: HttpService,  // Error
    @Inject(ConfigService) readonly config: ConfigService  // Error
  ) {}
}

// CORRECT - remove readonly from decorated parameters
class UserService {
  constructor(
    @Inject(HttpService) http: HttpService,  // Fixed
    @Inject(ConfigService) config: ConfigService  // Fixed
  ) {}
}

// WRONG
class AuthController {
  login(
    @Body() readonly credentials: LoginDto,  // Error
    @Headers('Authorization') readonly authHeader: string  // Error
  ) {
    // ...
  }
}

// CORRECT
class AuthController {
  login(
    @Body() credentials: LoginDto,  // Fixed
    @Headers('Authorization') authHeader: string  // Fixed
  ) {
    // ...
  }
}

// WRONG - readonly in decorated constructor parameters
class UserService {
  constructor(
    @Inject(HttpService) readonly http: HttpService,  // Error
    @Inject(Logger) readonly logger: Logger  // Error
  ) {}
}

// CORRECT - assign readonly properties in constructor body
class UserService {
  readonly http: HttpService;
  readonly logger: Logger;

  constructor(
    @Inject(HttpService) http: HttpService,
    @Inject(Logger) logger: Logger
  ) {
    this.http = http;
    this.logger = logger;
  }
}

// Angular/NestJS service pattern
@Injectable()
export class UserService {
  readonly http: HttpService;
  readonly config: ConfigService;

  constructor(
    http: HttpService,
    config: ConfigService
  ) {
    this.http = http;
    this.config = config;
  }
}

// WRONG - readonly with decorator
class OrderService {
  constructor(
    @Inject(PaymentService) readonly payment: PaymentService,  // Error
    @Inject(EmailService) readonly email: EmailService  // Error
  ) {}
}

// CORRECT - use private/protected
class OrderService {
  constructor(
    @Inject(PaymentService) private payment: PaymentService,  // Fixed
    @Inject(EmailService) protected email: EmailService  // Fixed
  ) {}

  processOrder() {
    // Can still use this.payment and this.email
    this.payment.charge();
    this.email.sendReceipt();
  }
}

class Example {
  constructor(
    @Inject(Service) private service: Service
  ) {}

  // Can still reassign (unless you add additional checks)
  changeService(newService: Service) {
    this.service = newService;  // Allowed with private, not with readonly
  }
}

// WRONG - parameter decorator with readonly
class UserDto {
  create(
    @IsEmail() readonly email: string,  // Error
    @MinLength(6) readonly password: string  // Error
  ) {}
}

// CORRECT - use property decorators on a class
class UserDto {
  @IsEmail()
  email: string;

  @MinLength(6)
  password: string;

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

// Usage
const user = new UserDto('test@example.com', 'password123');
validate(user);  // Validation framework checks property decorators

import { IsEmail, MinLength } from 'class-validator';

class CreateUserDto {
  @IsEmail()
  email: string;

  @MinLength(6)
  password: string;

  // Optional: make properties readonly at class level
  constructor(email: string, password: string) {
    this.email = email;
    this.password = password;
    Object.freeze(this);  // Makes the entire instance immutable
  }
}

// Define a readonly interface
interface ReadonlyConfig {
  readonly apiUrl: string;
  readonly timeout: number;
  readonly retries: number;
}

class ApiClient {
  constructor(
    @Inject(ConfigService) config: ConfigService  // No readonly needed
  ) {
    // Create readonly object from config
    const readonlyConfig: ReadonlyConfig = {
      apiUrl: config.get('API_URL'),
      timeout: config.get('TIMEOUT'),
      retries: config.get('RETRIES'),
    };

    // Use readonlyConfig which is immutable at compile time
  }
}

type Readonly<T> = { readonly [P in keyof T]: T[P] };

interface Config {
  apiUrl: string;
  timeout: number;
}

class Service {
  private readonly config: Readonly<Config>;

  constructor(@Inject(ConfigService) configService: ConfigService) {
    this.config = {
      apiUrl: configService.apiUrl,
      timeout: configService.timeout,
    };
  }

  // this.config is readonly at compile time
}

// tsconfig.json - ensure proper settings
{
  "compilerOptions": {
    "target": "ES2022",
    "experimentalDecorators": true,  // Required for legacy decorators
    "emitDecoratorMetadata": true,   // Often needed with DI frameworks

    // For TypeScript 5.0+ with stage 3 decorators:
    // "experimentalDecorators": false,  // Not needed for stage 3
    // "useDefineForClassFields": true,

    "strict": true
  }
}

# Update TypeScript
npm install typescript@latest

# Update framework packages
npm install @angular/core@latest  # or @nestjs/common, typeorm, etc.