TypeScript Parameter Decorators

In TypeScript, parameter decorators are used to modify or add metadata to function parameters. Parameter decorators can be applied to constructor parameters or method parameters and are commonly used for purposes like logging, validation, or dependency injection.

 

What is a Parameter Decorator?

A parameter decorator is a function applied to the parameters of a class method or constructor. It allows you to augment or manipulate the parameters before or during method execution.

Syntax of Parameter Decorators

The decorator function for parameters has the following signature:

function ParameterDecorator(target: any, methodName: string, parameterIndex: number) {
  // Custom behavior goes here
}

• target: The prototype of the class (for instance methods) or the constructor function (for static methods).
• methodName: The name of the method to which the parameter belongs.
• parameterIndex: The index of the parameter in the method or constructor.

 

Enabling Parameter Decorators in TypeScript

To use decorators, you need to enable the experimentalDecorators option in your tsconfig.json file.

{
  "compilerOptions": {
    "experimentalDecorators": true
  }
}

 

Applying a Simple Parameter Decorator

A simple parameter decorator can log the method name and the index of the parameter. This helps us track how the parameters are passed into methods.

Example: Applying a Simple Parameter Decorator

function LogParameter(target: any, methodName: string, parameterIndex: number) {
  console.log(`Parameter at index ${parameterIndex} in method ${methodName}`);
}

class Example {
  greet(@LogParameter message: string) {
    console.log(message);
  }
}

const example = new Example();
example.greet("Hello, world!");  // Output: Parameter at index 0 in method greet

• The @LogParameter decorator logs the index of the parameter in the method whenever the method is called.

 

Using Parameter Decorators for Validation

You can use parameter decorators to validate parameters before a method or constructor is executed. This allows for powerful input validation within the class methods.

Example: Parameter Decorator for Validation

function ValidateParameter(target: any, methodName: string, parameterIndex: number) {
  const existingValidations = Reflect.getOwnMetadata('validations', target, methodName) || [];
  existingValidations.push(parameterIndex);
  Reflect.defineMetadata('validations', existingValidations, target, methodName);
}

function validate(target: any, methodName: string, args: any[]) {
  const validations = Reflect.getOwnMetadata('validations', target, methodName) || [];
  for (const index of validations) {
    if (args[index] == null || args[index] === "") {
      throw new Error(`Invalid parameter at index ${index} in method ${methodName}`);
    }
  }
}

class Example {
  greet(@ValidateParameter message: string) {
    console.log(message);
  }
}

const example = new Example();

try {
  validate(example, "greet", [""]);  // Throws error: Invalid parameter at index 0 in method greet
} catch (error) {
  console.log(error.message);
}

• The @ValidateParameter decorator marks the parameter for validation.
• The validate function checks for invalid parameter values (e.g., null or empty string).

 

Parameter Decorators for Dependency Injection

One common use case for parameter decorators is dependency injection (DI). You can create a parameter decorator that injects services or other dependencies into the constructor of a class.

Example: Dependency Injection with Parameter Decorators

function Inject(service: any) {
  return function(target: any, methodName: string, parameterIndex: number) {
    // Logic for injecting the service into the constructor
    console.log(`Injecting service into parameter ${parameterIndex}`);
  };
}

class MyService {}

class Example {
  constructor(@Inject(MyService) private service: MyService) {
    console.log('Service injected:', this.service);
  }
}

const example = new Example(new MyService());

• The @Inject decorator is used to mark a parameter as needing dependency injection.

 

Using Parameter Decorators with Reflect Metadata

You can use the reflect-metadata library to create more advanced behavior for parameter decorators, such as dynamically injecting services, logging method calls, and tracking the metadata of method parameters.

Example: Using Reflect Metadata with Parameter Decorators

import "reflect-metadata";

function LogParam(target: any, methodName: string, parameterIndex: number) {
  const existingParams = Reflect.getOwnMetadata('params', target, methodName) || [];
  existingParams.push(parameterIndex);
  Reflect.defineMetadata('params', existingParams, target, methodName);
}

class Example {
  greet(@LogParam message: string) {
    console.log(message);
  }
}

const example = new Example();
example.greet("Hello");  // Output: Hello
console.log(Reflect.getOwnMetadata('params', example, 'greet'));  // Output: [ 0 ]

• The @LogParam decorator stores metadata about the parameter index.

 

Parameter Decorators with Custom Logic

You can also create parameter decorators that apply custom logic, such as transforming parameters or implementing more complex validation rules.

Example: Parameter Decorator with Custom Logic

function TransformParameter(target: any, methodName: string, parameterIndex: number) {
  const originalMethod = target[methodName];

  target[methodName] = function(...args: any[]) {
    if (typeof args[parameterIndex] === "string") {
      args[parameterIndex] = args[parameterIndex].toUpperCase();
    }
    return originalMethod.apply(this, args);
  };
}

class Example {
  greet(@TransformParameter message: string) {
    console.log(message);
  }
}

const example = new Example();
example.greet("hello");  // Output: HELLO

• The @TransformParameter decorator converts the parameter value to uppercase before passing it to the method.

 

Summary

• Parameter decorators in TypeScript are used to add metadata or modify the behavior of method or constructor parameters.
• They can be used for a variety of tasks, such as logging, validation, dependency injection, and transformation of parameter values.
• Reflect Metadata can be used with parameter decorators to store and retrieve metadata.
• Parameter decorators are powerful tools for building scalable applications with advanced features like DI and input validation.