NestJS Microservices Development

Project Structure

This project uses NestJS for three microservices:

• apps/auth - Authentication (JWT, Passport)
• apps/order - Order management (integrates with Temporal)
• apps/product - Product catalog

Shared modules are in packages/core.

Creating a New Module

1. Create Module File

typescript
1// feature/feature.module.ts
2import { Module } from '@nestjs/common';
3import { FeatureController } from './feature.controller';
4import { FeatureService } from './feature.service';
5
6@Module({
7  controllers: [FeatureController],
8  providers: [FeatureService],
9  exports: [FeatureService],
10})
11export class FeatureModule {}

2. Create Service with Repository Pattern

typescript
1// feature/feature.service.ts
2import { Injectable } from '@nestjs/common';
3import { PrismaService } from '@projectx/db';
4
5@Injectable()
6export class FeatureService {
7  constructor(private readonly prisma: PrismaService) {}
8
9  async findAll() {
10    return this.prisma.feature.findMany();
11  }
12
13  async findOne(id: string) {
14    return this.prisma.feature.findUnique({ where: { id } });
15  }
16
17  async create(data: CreateFeatureDto) {
18    return this.prisma.feature.create({ data });
19  }
20}

3. Create Controller with Swagger

typescript
1// feature/feature.controller.ts
2import { Controller, Get, Post, Body, Param } from '@nestjs/common';
3import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
4import { FeatureService } from './feature.service';
5
6@ApiTags('features')
7@Controller('features')
8export class FeatureController {
9  constructor(private readonly featureService: FeatureService) {}
10
11  @Get()
12  @ApiOperation({ summary: 'Get all features' })
13  @ApiResponse({ status: 200, description: 'Returns all features' })
14  findAll() {
15    return this.featureService.findAll();
16  }
17
18  @Get(':id')
19  @ApiOperation({ summary: 'Get feature by ID' })
20  findOne(@Param('id') id: string) {
21    return this.featureService.findOne(id);
22  }
23
24  @Post()
25  @ApiOperation({ summary: 'Create a feature' })
26  create(@Body() createFeatureDto: CreateFeatureDto) {
27    return this.featureService.create(createFeatureDto);
28  }
29}

DTOs with Validation

typescript
1// feature/dto/create-feature.dto.ts
2import { IsString, IsNotEmpty, IsOptional } from 'class-validator';
3import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
4
5export class CreateFeatureDto {
6  @ApiProperty({ description: 'Feature name' })
7  @IsString()
8  @IsNotEmpty()
9  name: string;
10
11  @ApiPropertyOptional({ description: 'Feature description' })
12  @IsString()
13  @IsOptional()
14  description?: string;
15}

Authentication Guards

Use guards from @projectx/core:

typescript
1import { UseGuards } from '@nestjs/common';
2import { JwtAuthGuard } from '@projectx/core';
3
4@Controller('protected')
5@UseGuards(JwtAuthGuard)
6export class ProtectedController {
7  // All routes require authentication
8}

Exception Handling

typescript
1import { NotFoundException, BadRequestException } from '@nestjs/common';
2
3// In service
4async findOne(id: string) {
5  const item = await this.prisma.feature.findUnique({ where: { id } });
6  if (!item) {
7    throw new NotFoundException(`Feature with ID ${id} not found`);
8  }
9  return item;
10}

Testing Services

typescript
1import { Test, TestingModule } from '@nestjs/testing';
2import { FeatureService } from './feature.service';
3import { PrismaService } from '@projectx/db';
4
5describe('FeatureService', () => {
6  let service: FeatureService;
7  let prisma: PrismaService;
8
9  beforeEach(async () => {
10    const module: TestingModule = await Test.createTestingModule({
11      providers: [
12        FeatureService,
13        {
14          provide: PrismaService,
15          useValue: {
16            feature: {
17              findMany: jest.fn(),
18              findUnique: jest.fn(),
19              create: jest.fn(),
20            },
21          },
22        },
23      ],
24    }).compile();
25
26    service = module.get<FeatureService>(FeatureService);
27    prisma = module.get<PrismaService>(PrismaService);
28  });
29
30  it('should be defined', () => {
31    expect(service).toBeDefined();
32  });
33});

Running Services

bash
1# Run specific service
2pnpm dev:auth
3pnpm dev:order
4pnpm dev:product
5
6# Run all services
7pnpm dev

Best Practices

1. Always use DTOs for request/response validation
2. Document with Swagger decorators for API documentation
3. Use repository pattern via Prisma services from @projectx/db
4. Handle errors with NestJS built-in exceptions
5. Write tests for services and controllers
6. Use guards from @projectx/core for authentication