API 게이트웨이 패턴 구현

# orders-service 프로젝트가 없다면 새로 생성 (있다면 스킵)
nest new orders-service --skip-install
cd orders-service
npm install @nestjs/microservices @grpc/grpc-js @grpc/proto-loader rxjs

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  // CORS 활성화 (옵션, 클라이언트 웹 개발 시 필요)
  app.enableCors();
  await app.listen(3000); // 클라이언트가 접근할 API 게이트웨이 포트
  console.log('API Gateway (Orders Service) is listening on port 3000');
}
bootstrap();

// orders-service/proto/users.proto (users-service의 proto/users.proto와 동일)
syntax = "proto3";

package users;

service UserService {
  rpc GetUserById (UserByIdRequest) returns (User);
  rpc CreateUser (CreateUserRequest) returns (User);
}

message UserByIdRequest {
  int32 id = 1;
}

message CreateUserRequest {
  string name = 1;
  string email = 2;
}

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { OrdersController } from './orders.controller';
import { OrdersService } from './orders.service';
import { join } from 'path';

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'USERS_SERVICE', // gRPC 클라이언트 토큰
        transport: Transport.GRPC,
        options: {
          package: 'users',
          protoPath: join(__dirname, '../../proto/users.proto'), // .proto 파일 경로
          url: 'localhost:50051', // Users gRPC 서비스 주소
          loader: {
            keepCase: true,
            longs: String,
            enums: String,
            defaults: true,
            oneofs: true,
          },
        },
      },
    ]),
  ],
  controllers: [OrdersController],
  providers: [OrdersService],
})
export class OrdersModule {}

import {
  BadGatewayException,
  BadRequestException,
  Body,
  Controller,
  GatewayTimeoutException,
  Get,
  HttpException,
  Inject,
  Logger,
  NotFoundException,
  OnModuleInit,
  Param,
  ParseIntPipe,
  Post,
  ServiceUnavailableException,
} from '@nestjs/common';
import { status, type CallOptions } from '@grpc/grpc-js';
import { ClientGrpc } from '@nestjs/microservices';
import { OrdersService } from './orders.service';
import { lastValueFrom, Observable } from 'rxjs';

// 동적 proto client가 노출하는 lower camel-case 메서드 계약
interface UserService {
  getUserById(data: { id: number }, options?: CallOptions): Observable<User>;
  createUser(
    data: { name: string; email: string },
    options?: CallOptions,
  ): Observable<User>;
}

interface User {
  id: number;
  name: string;
  email: string;
}

interface Order {
  id: number;
  userId: number;
  item: string;
  createdAt: Date;
}

type DependencyStatus = 'ok' | 'not-found' | 'timeout' | 'unavailable';

interface OrderDetails {
  order: Order;
  user: User | null;
  dependencyStatus: DependencyStatus;
}

interface GrpcErrorShape {
  code?: number;
}

function readGrpcError(error: unknown): GrpcErrorShape {
  return typeof error === 'object' && error !== null
    ? (error as GrpcErrorShape)
    : {};
}

// 이 예제 Gateway가 선택한 외부 HTTP 계약입니다. 보편적인 표준표가 아닙니다.
function mapGrpcError(error: unknown): HttpException {
  switch (readGrpcError(error).code) {
    case status.INVALID_ARGUMENT:
      return new BadRequestException('Invalid Users Service request');
    case status.NOT_FOUND:
      return new NotFoundException('User not found');
    case status.DEADLINE_EXCEEDED:
      return new GatewayTimeoutException('Users Service timed out');
    case status.UNAVAILABLE:
      return new ServiceUnavailableException(
        'Users Service is temporarily unavailable',
      );
    default:
      return new BadGatewayException('Users Service request failed');
  }
}

@Controller('api')
export class OrdersController implements OnModuleInit {
  private userService!: UserService;
  private readonly logger = new Logger(OrdersController.name);

  constructor(
    private readonly ordersService: OrdersService,
    @Inject('USERS_SERVICE') private readonly client: ClientGrpc,
  ) {}

  onModuleInit(): void {
    this.userService = this.client.getService<UserService>('UserService');
  }

  private logUpstreamFailure(route: string, error: unknown): void {
    const { code } = readGrpcError(error);
    this.logger.warn(
      `route=${route} upstream=users-service grpcCode=${code ?? 'UNKNOWN'}`,
    );
  }

  @Get('users/:userId')
  async getUser(
    @Param('userId', ParseIntPipe) userId: number,
  ): Promise<User> {
    try {
      return await lastValueFrom(
        this.userService.getUserById(
          { id: userId },
          { deadline: Date.now() + 1_500 },
        ),
      );
    } catch (error) {
      this.logUpstreamFailure('GET /api/users/:userId', error);
      throw new BadGatewayException('Users Service request failed');
    }
  }

  @Post('users')
  async createUser(@Body() userDto: { name: string; email: string }): Promise<User> {
    try {
      return await lastValueFrom(
        this.userService.createUser(
          userDto,
          { deadline: Date.now() + 1_500 },
        ),
      );
    } catch (error) {
      this.logUpstreamFailure('POST /api/users', error);
      throw mapGrpcError(error);
    }
  }

  @Post('orders')
  createOrder(@Body() orderDto: { userId: number; item: string }): Order {
    return this.ordersService.createOrder(orderDto.userId, orderDto.item);
  }

  @Get('orders/:orderId/details')
  async getOrderDetails(
    @Param('orderId', ParseIntPipe) orderId: number,
  ): Promise<OrderDetails> {
    const order = this.ordersService.findOne(orderId);
    if (!order) {
      throw new NotFoundException('Order not found');
    }

    try {
      const user = await lastValueFrom(
        this.userService.getUserById(
          { id: order.userId },
          { deadline: Date.now() + 1_500 },
        ),
      );
      return { order, user, dependencyStatus: 'ok' };
    } catch (error) {
      const { code } = readGrpcError(error);
      this.logUpstreamFailure('GET /api/orders/:orderId/details', error);

      if (code === status.NOT_FOUND) {
        return { order, user: null, dependencyStatus: 'not-found' };
      }
      if (code === status.DEADLINE_EXCEEDED) {
        return { order, user: null, dependencyStatus: 'timeout' };
      }
      if (code === status.UNAVAILABLE) {
        return { order, user: null, dependencyStatus: 'unavailable' };
      }
      throw mapGrpcError(error);
    }
  }
}

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

interface Order {
  id: number;
  userId: number;
  item: string;
  createdAt: Date;
}

@Injectable()
export class OrdersService {
  private orders: Order[] = [];
  private nextId = 1;

  createOrder(userId: number, item: string): Order {
    const newOrder = {
      id: this.nextId++,
      userId,
      item,
      createdAt: new Date(),
    };
    this.orders.push(newOrder);
    return newOrder;
  }

  findOne(id: number): Order | undefined {
    return this.orders.find(order => order.id === id);
  }
}

import { Module } from '@nestjs/common';
import { OrdersModule } from './orders/orders.module';

@Module({
  imports: [OrdersModule],
  controllers: [],
  providers: [],
})
export class AppModule {}