What is the Reflection API in programming?

The Reflection API is a collection of built-in features within programming languages that enables a program to analyze and alter its structure, behavior, and metadata at runtime. It allows for the inspection of classes, interfaces, methods, and fields dynamically, without requiring their names during compilation.

Key capabilities typically offered by the Reflection API include: 1. Class Inspection: The ability to explore the structure of classes, including their fields, methods, constructors, and associated annotations. 2. Dynamic Class Instantiation: Creating instances of classes at runtime even when their names are unknown at compile time. 3. Dynamic Method Invocation: Calling methods on objects without prior knowledge of their names during compilation. 4. Field Access and Modification: Accessing and altering class fields, including private ones that are usually restricted. 5. Annotation Examination: Checking for annotations tied to classes, methods, and fields, allowing for actions based on their presence or values.

Examples in JavaScript

Let’s explore some practical examples within JavaScript:

1. Inspecting Object Properties: Utilize a for...in loop or Object.keys() to dynamically iterate through an object's properties:

   const obj = {

   name: 'John',

   age: 30,

   city: 'New York'

   };

   for (const key in obj) {

   console.log(${key}: ${obj[key]});

   }

2. Dynamic Access and Modification of Object Properties: Access and change object properties using bracket notation:

   const obj = { name: 'John' };

   // Accessing property dynamically

   const propertyName = 'name';

   console.log(obj[propertyName]); // Output: John

   // Modifying property dynamically

   const newValue = 'Jane';

   obj[propertyName] = newValue;

   console.log(obj.name); // Output: Jane

3. Dynamic Method Invocation: JavaScript allows for invoking object methods dynamically using bracket notation:

   const obj = {

   greet: function() {

   console.log('Hello!');

   }

   };

   const methodName = 'greet';

   obj[methodName](); // Output: Hello!

Limitations of the Reflection API in JavaScript

In comparison to languages like Java or C#, JavaScript has certain limitations regarding reflection capabilities:

1. Strict Typing: JavaScript is dynamically typed, meaning types are determined at runtime. In contrast, Java and C# allow for compile-time type inspection due to their static typing.
2. Type Metadata: Java and C# provide extensive metadata at runtime due to their rich type systems, whereas JavaScript offers less type metadata because of its dynamic typing.
3. Reflection Emit: Unlike C#, which can dynamically generate IL code through reflection emit, JavaScript lacks a direct equivalent for this capability.
4. Annotations and Attributes: While Java and C# support annotations and attributes for adding metadata, JavaScript’s decorators (used in TypeScript or Babel) do not integrate as deeply into the language.

In summary, although JavaScript offers some reflection-like capabilities, its dynamic nature and design differences limit certain features available in statically-typed languages.

Reflect-Metadata in JS / TS (Problem)

To address some limitations, various packages exist, with Reflect-Metadata being a notable example.

Before discussing Reflect-Metadata, it’s important to understand the problem it aims to solve!

The problem:

Imagine a scenario where you need to restrict access to certain APIs based on user permissions. Implementing this logic repetitively can be cumbersome:

function adminOnlyMethod() {

if (currentUser.role === roles.ADMIN) {

console.log("This method is only for admins.");

// Admin-specific actions

} else {

console.log("You don't have permission to perform this action.");

}

}

With numerous APIs, repeating this logic is inefficient. Instead, a higher-order function or a middleware pattern can streamline the process, like this:

// Higher-order function to create role-restricted methods

function restrictToRole(role, method) {

return function(...args) {

if (currentUser.role === role) {

return method.apply(this, args); // Execute original method

} else {

console.log("You don't have permission to perform this action.");

}

};

}

// Example method

function adminOnlyMethod() {

console.log("This method is only for admins.");

}

// Wrap the method with role-based access control

const restrictedAdminMethod = restrictToRole(roles.ADMIN, adminOnlyMethod);

While this approach is better, it still lacks elegance. This is where Reflect-Metadata comes into play.

How does Reflect-Metadata work?

The reflect-metadata library in JavaScript and TypeScript provides an API for runtime reflection capabilities. It allows developers to add and read metadata from class declarations and members.

Here’s a brief overview of its functionalities: 1. Adding Metadata: Developers can use Reflect.metadata() to attach metadata to classes, methods, or properties using a key-value pair. 2. Accessing Metadata: The library offers methods like Reflect.getMetadata() to retrieve associated metadata at runtime. 3. Usage in TypeScript: Commonly used with TypeScript decorators, it allows for a more intuitive and declarative approach to adding metadata. 4. Runtime Reflection: It facilitates various runtime reflection tasks, including dependency injection, serialization, and validation.

Here’s a simple example using reflect-metadata with TypeScript decorators:

import 'reflect-metadata';

// Define a decorator function

function MyDecorator(target: any, key: string) {

// Add metadata to the target (class)

Reflect.defineMetadata('customMetadataKey', 'someValue', target, key);

}

class MyClass {

@MyDecorator

myMethod() {}

}

// Retrieve metadata at runtime

const metadataValue = Reflect.getMetadata('customMetadataKey', MyClass.prototype, 'myMethod');

console.log(metadataValue); // Output: 'someValue'

Solve the issue with Reflect-Metadata

Consider resolving the previous issue with a decorator:

@Post('login')

@Public()

async login(@Request() req: UserRequest): Promise<LoginResponseDto> {

return this.authService.login(req.user);

}

Defining a @Public decorator could look like this (using NestJS):

import { SetMetadata } from '@nestjs/common';

export const IS_PUBLIC_KEY = 'isPublic';

export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

In the guard, you can check if the API is decorated with the specific metadata:

@Injectable()

export class JwtAuthGuard extends AuthGuard('jwt') {

constructor(private reflector: Reflector) {

super();

}

canActivate(context: ExecutionContext) {

const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [

context.getHandler(),

context.getClass(),

]);

if (isPublic) {

return true;

}

return super.canActivate(context);

}

}

This approach is more declarative and significantly reduces code duplication!

For further exploration, check out my article on creating a dependency injection container from scratch.

Hope you found this post insightful! Feel free to share your thoughts.