Microservices in TypeScript: Advanced Architecture and Practice

Introduction: Why TypeScript is the Ideal Choice for Microservices

Modern distributed architecture requires from a developer not only knowledge of frameworks, but also a deep understanding of interaction patterns, error handling, and data typing. TypeScript, thanks to strict static typing and a powerful decorator system, is becoming the de facto standard for building reliable microservices. Unlike pure JavaScript, TypeScript allows catching errors at the compilation stage, which is critical for systems with dozens of services.

In this article, we will analyze advanced techniques for building microservice architecture in TypeScript: from organizing a modular structure based on NestJS to implementing Saga and CQRS transactional patterns. You will learn how to set up efficient inter-service communication via RabbitMQ and gRPC, and get ready-made code templates for production solutions.

1. Microservice Architecture in NestJS: From Monolith to Distributed System

NestJS is a progressive framework for Node.js that is ideal for microservice architecture thanks to built-in support for transports and decorators. Let's look at how to properly organize a project.

1.1. Basic Microservice Structure

Each microservice should be an isolated module with clear boundaries. Example of a minimal structure:

// user-service/src/main.tsimport { NestFactory } from '@nestjs/core';import { MicroserviceOptions, Transport } from '@nestjs/microservices';import { AppModule } from './app.module';

async function bootstrap() {  const app = await NestFactory.createMicroservice<MicroserviceOptions>(    AppModule,    {      transport: Transport.TCP,      options: {        host: '0.0.0.0',        port: 3001,      },    },  );  await app.listen();}bootstrap();

The key point is the use of MicroserviceOptions and strict typing of the transport. This guarantees that when changing the protocol (for example, from TCP to Redis), the compiler will hint which parameters need to be changed.

1.2. Modular Organization and Dependency Injection

For production systems, it is important to separate business logic and infrastructure code. Use NestJS modules to group related components:

// user-service/src/user/user.module.tsimport { Module } from '@nestjs/common';import { UserController } from './user.controller';import { UserService } from './user.service';import { DatabaseModule } from '../database/database.module';

@Module({  imports: [DatabaseModule],  controllers: [UserController],  providers: [UserService],  exports: [UserService],})export class UserModule {}

An advanced practice is using factory providers for dynamic configuration of database clients or message queues.

2. Saga and CQRS Patterns: Managing Distributed Transactions

In microservice architecture, traditional ACID transactions cannot be used. Instead, the Saga pattern (for data consistency) and CQRS (for separating reads and writes) are applied.

2.1. Implementing the Saga Pattern in TypeScript

A Saga is a sequence of local transactions where each failure triggers a compensating action. Let's look at an example with an order and payment:

// order-service/src/sagas/create-order.saga.tsimport { Saga, ofType } from '@nestjs/cqrs';import { Observable } from 'rxjs';import { delay, map } from 'rxjs/operators';

export class CreateOrderSaga {  @Saga()  createOrder = (events$: Observable<any>): Observable<ICommand> => {    return events$.pipe(      ofType(OrderCreatedEvent),      delay(1000),      map(event => new ReserveInventoryCommand(event.orderId)),    );  };

  @Saga()  handlePaymentFailure = (events$: Observable<any>): Observable<IComma