Advanced TypeScript Patterns for Enterprise Applications

Enterprise applications require robust and scalable solutions to manage complex requirements and evolving business needs. TypeScript offers advanced patterns and features that can significantly enhance the development of large-scale applications. This article explores some of these patterns and demonstrates how to apply them effectively.

1. Dependency Injection with InversifyJS

Dependency Injection (DI) helps manage dependencies between components, promoting modularity and testability. InversifyJS is a popular DI framework for TypeScript applications.

import 'reflect-metadata';
import { injectable, inject, Container } from 'inversify';

@injectable()
class Logger {
  log(message: string) {
    console.log(message);
  }
}

@injectable()
class UserService {
  constructor(@inject(Logger) private logger: Logger) {}

  getUser(id: number) {
    this.logger.log(`Fetching user with id ${id}`);
    return { id, name: 'Jane Doe' };
  }
}

const container = new Container();
container.bind(Logger).toSelf();
container.bind(UserService).toSelf();

const userService = container.get(UserService);
userService.getUser(1);

2. Using Generics for Flexible and Reusable Components

Generics enable the creation of flexible, reusable components and functions. They help maintain type safety while handling different data types.

function wrapInArray<T>(item: T): T[] {
  return [item];
}

const numberArray = wrapInArray(42); // number[]
const stringArray = wrapInArray('Hello'); // string[]

3. Advanced Type Guards for Complex Types

Type Guards refine the type of a variable within a conditional block, ensuring type safety and preventing runtime errors.

type Animal = { type: 'cat'; meow: () => void } | { type: 'dog'; bark: () => void };

function isCat(animal: Animal): animal is Animal & { type: 'cat' } {
  return animal.type === 'cat';
}

const animal: Animal = { type: 'cat', meow: () => console.log('Meow') };

if (isCat(animal)) {
  animal.meow(); // TypeScript knows `animal` is a cat
}

4. Using TypeScript Decorators for Metadata

Decorators are a powerful feature for adding metadata to classes and methods, often used in combination with frameworks like Angular.

function Log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function(...args: any[]) {
    console.log(`Called ${propertyKey} with args: ${args}`);
    return originalMethod.apply(this, args);
  };
}

class ExampleService {
  @Log
  doSomething(arg: number) {
    console.log('Doing something with', arg);
  }
}

const service = new ExampleService();
service.doSomething(42);

5. Leveraging Union and Intersection Types for Complex Data Structures

Union and Intersection types provide ways to model complex data structures and combine multiple types into a single type.

type ErrorResponse = { error: string };
type SuccessResponse = { data: any };

type ApiResponse = ErrorResponse | SuccessResponse;

function handleResponse(response: ApiResponse) {
  if ('error' in response) {
    console.error('Error:', response.error);
  } else {
    console.log('Data:', response.data);
  }
}

6. Implementing Conditional Types for Flexible APIs

Conditional types enable creating types based on conditions, allowing for highly flexible and reusable code.

type IsString<T> = T extends string ? 'Yes' : 'No';

type Test1 = IsString<string>; // 'Yes'
type Test2 = IsString<number>; // 'No'

Conclusion

Applying advanced TypeScript patterns can greatly enhance the scalability, maintainability, and robustness of enterprise applications. By leveraging Dependency Injection, Generics, Type Guards, Decorators, Union and Intersection Types, and Conditional Types, developers can build more flexible and reliable systems that can handle complex requirements efficiently.