API 게이트웨이 패턴 구현

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

// orders-service/src/main.ts
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;
}

// orders-service/src/orders/orders.module.ts (수정)
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 {}

// orders-service/src/orders/orders.controller.ts (수정)
import { Controller, Get, Post, Body, Param, Inject, OnModuleInit, HttpException, HttpStatus } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { OrdersService } from './orders.service';
import { Observable, lastValueFrom } from 'rxjs';

// .proto 파일에 정의된 서비스 인터페이스 정의
interface UserService {
  GetUserById(data: { id: number }): Observable<User>;
  CreateUser(data: { name: string; email: string }): Observable<User>;
}

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

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

@Controller('api') // 모든 API 요청의 접두사 (API Gateway 역할 명시)
export class OrdersController implements OnModuleInit {
  private userService: UserService;

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

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

  // --- API 게이트웨이 라우팅 및 요청 조합 예시 ---

  // GET /api/users/:userId : 사용자 정보 조회 (Users Service로 라우팅)
  @Get('users/:userId')
  async getUser(@Param('userId') userId: string): Promise<User> {
    const id = parseInt(userId, 10);
    if (isNaN(id)) {
      throw new HttpException('Invalid user ID', HttpStatus.BAD_REQUEST);
    }

    try {
      const user = await lastValueFrom(this.userService.GetUserById({ id }));
      if (!user || user.id === 0) { // gRPC에서 사용자 없는 경우 id=0으로 가정
        throw new HttpException('User not found', HttpStatus.NOT_FOUND);
      }
      return user;
    } catch (error) {
      console.error('gRPC Error for getUser:', error.details || error.message);
      // gRPC 에러를 HTTP 에러로 변환하여 클라이언트에 전달
      throw new HttpException(
        `Failed to fetch user: ${error.details || error.message}`,
        error.code === 5 ? HttpStatus.NOT_FOUND : HttpStatus.INTERNAL_SERVER_ERROR // gRPC NOT_FOUND(5)를 HTTP 404로 매핑
      );
    }
  }

  // POST /api/users : 사용자 생성 (Users Service로 라우팅)
  @Post('users')
  async createUser(@Body() userDto: { name: string; email: string }): Promise<User> {
    try {
      const newUser = await lastValueFrom(this.userService.CreateUser(userDto));
      return newUser;
    } catch (error) {
      console.error('gRPC Error for createUser:', error.details || error.message);
      throw new HttpException(
        `Failed to create user: ${error.details || error.message}`,
        HttpStatus.INTERNAL_SERVER_ERROR
      );
    }
  }

  // POST /api/orders : 주문 생성 (Orders Service 자체 처리)
  @Post('orders')
  createOrder(@Body() orderDto: { userId: number; item: string }): Order {
    return this.ordersService.createOrder(orderDto.userId, orderDto.item);
  }

  // GET /api/orders/:orderId/details : 주문 및 관련 사용자 정보 조합 (Orders Service + Users Service)
  // 이 엔드포인트는 API 게이트웨이의 "요청 합성" 기능을 보여줍니다.
  @Get('orders/:orderId/details')
  async getOrderDetails(@Param('orderId') orderId: string): Promise<any> {
    const id = parseInt(orderId, 10);
    if (isNaN(id)) {
      throw new HttpException('Invalid order ID', HttpStatus.BAD_REQUEST);
    }

    // 1. 주문 정보 조회 (Orders Service 자체 로직)
    const order = this.ordersService.findOne(id);
    if (!order) {
      throw new HttpException('Order not found', HttpStatus.NOT_FOUND);
    }

    // 2. 사용자 정보 조회 (Users Service 호출 - gRPC)
    try {
      const user = await lastValueFrom(this.userService.GetUserById({ id: order.userId }));
      if (!user || user.id === 0) {
        // 사용자 정보가 없더라도 주문 정보는 반환
        return { order, user: null, message: 'User not found for this order.' };
      }
      return { order, user }; // 두 서비스의 응답을 조합하여 반환
    } catch (error) {
      console.error('gRPC Error for getOrderDetails (user):', error.details || error.message);
      // 사용자 서비스에 문제가 있더라도 주문 정보는 반환
      return { order, user: null, message: `Failed to fetch user details: ${error.details || error.message}` };
    }
  }
}

// orders-service/src/orders/orders.service.ts (수정)
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);
  }
}

// orders-service/src/app.module.ts
import { Module } from '@nestjs/common';
import { OrdersModule } from './orders/orders.module';

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