Microservices and MVC in a NestJS Project

Microservices and MVC in a NestJS Project

NestJS is a progressive Node.js framework that provides a solid structure for building scalable applications. It supports both Microservice architecture and MVC (Model-View-Controller) pattern, allowing developers to choose the best fit for their use case.

---

1. Microservices in NestJS

What are Microservices?

Microservices architecture allows an application to be broken down into multiple independent services, each handling a specific responsibility. These services communicate using lightweight mechanisms such as HTTP, WebSockets, or messaging brokers (Kafka, RabbitMQ, etc.).

How to Implement Microservices in NestJS?

NestJS provides built-in support for microservices via the @nestjs/microservices module.

Step 1: Install Required Dependencies

npm install @nestjs/microservices

Step 2: Create a Microservice

Define a microservice that listens on a specific transport (e.g., TCP).

import { 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,  // Using TCP transport
    options: { host: '127.0.0.1', port: 3001 },
  });

  await app.listen();
  console.log('Microservice is running on port 3001');
}

bootstrap();

Step 3: Create a Microservice Handler

Inside a service, define message patterns.

import { Controller } from '@nestjs/common';
import { MessagePattern } from '@nestjs/microservices';

@Controller()
export class MathController {
  @MessagePattern({ cmd: 'sum' })  // Message-based communication
  sum(data: number[]): number {
    return data.reduce((a, b) => a + b, 0);
  }
}

Step 4: Create a Client (API Gateway or Another Microservice)

The client will send messages to the microservice.

import { Controller, Get } from '@nestjs/common';
import { Client, ClientProxy, Transport } from '@nestjs/microservices';

@Controller()
export class AppController {
  @Client({ transport: Transport.TCP, options: { host: '127.0.0.1', port: 3001 } })
  private client: ClientProxy;

  @Get('sum')
  async getSum(): Promise<number> {
    return this.client.send({ cmd: 'sum' }, [3, 5]).toPromise();
  }
}

Benefits of Microservices in NestJS

✅ Scalability – Each service scales independently.

✅ Decoupling – Services can be deployed separately.

✅ Flexibility – Services can be written in different programming languages.

---

2. MVC in NestJS

What is MVC?

MVC (Model-View-Controller) is a design pattern that separates application logic into three layers:

• Model (M): Handles data and business logic.
• View (V): Responsible for UI rendering. (NestJS usually does not use this since it's more backend-focused.)
• Controller (C): Handles requests and responses.

How to Implement MVC in NestJS?

Step 1: Create a Controller

Controllers handle HTTP requests and return responses.

import { Controller, Get } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Get()
  getUsers(): string {
    return 'List of users';
  }
}

Step 2: Create a Service

The service contains business logic and interacts with the database.

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

@Injectable()
export class UsersService {
  getAllUsers(): string[] {
    return ['Alice', 'Bob', 'Charlie'];
  }
}

Step 3: Use the Service in the Controller

Inject the service into the controller to fetch data.

import { Controller, Get } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  getUsers(): string[] {
    return this.usersService.getAllUsers();
  }
}

Step 4: Register Components in a Module

A module groups related components together.

import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';

@Module({
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

---

Comparison: Microservices vs. MVC in NestJS

Feature	Microservices	MVC
Architecture	Distributed (multiple services)	Monolithic (single codebase)
Scalability	High (each service scales independently)	Limited (entire app scales together)
Communication	Message-based (Kafka, RabbitMQ, etc.)	Direct function calls (synchronous)
Deployment	Services deployed separately	Deployed as a single unit
Best For	Large, scalable applications	Small to medium-sized applications

---

Conclusion

• Use Microservices if you need scalability, independent deployments, or different services for different teams.
• Use MVC if you're building a small to medium monolithic application with a structured architecture.

NestJS provides built-in support for both architectures, allowing developers to choose the right approach for their needs. 🚀