2026년 NestJS와 MongoDB 완벽 가이드: Mongoose, 집계 파이프라인, 면접 대비

# Mongoose 통합 패키지 설치
npm install @nestjs/mongoose mongoose

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';

@Module({
  imports: [
    MongooseModule.forRoot(process.env.MONGODB_URI, {
      // 프로덕션 워크로드를 위한 연결 풀 크기
      maxPoolSize: 10,
      // 연결 실패 시 10초 후 타임아웃
      serverSelectionTimeoutMS: 10000,
    }),
  ],
})
export class AppModule {}

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { HydratedDocument, Types } from 'mongoose';

// TypeScript 자동완성을 위한 도큐먼트 타입
export type UserDocument = HydratedDocument<User>;

@Schema({
  timestamps: true, // createdAt과 updatedAt 추가
  collection: 'users', // 명시적 컬렉션 이름
})
export class User {
  // MongoDB ObjectId, 자동 생성
  _id: Types.ObjectId;

  @Prop({ required: true, unique: true, index: true })
  email: string;

  @Prop({ required: true })
  passwordHash: string;

  @Prop({ type: String, enum: ['admin', 'user', 'guest'], default: 'user' })
  role: string;

  @Prop({ type: [String], default: [] })
  permissions: string[];
}

export const UserSchema = SchemaFactory.createForClass(User);

import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model, Types } from 'mongoose';
import { User, UserDocument } from './user.schema';

@Injectable()
export class UserService {
  constructor(
    @InjectModel(User.name) private userModel: Model<UserDocument>,
  ) {}

  async findById(id: string): Promise<UserDocument> {
    // 쿼리 전에 ObjectId 형식 검증
    if (!Types.ObjectId.isValid(id)) {
      throw new NotFoundException('잘못된 사용자 ID 형식입니다');
    }
    const user = await this.userModel.findById(id).exec();
    if (!user) {
      throw new NotFoundException(`사용자 ${id}를 찾을 수 없습니다`);
    }
    return user;
  }

  async findByEmail(email: string): Promise<UserDocument | null> {
    // 대소문자를 구분하지 않는 이메일 검색
    return this.userModel.findOne({ 
      email: { $regex: new RegExp(`^${email}$`, 'i') } 
    }).exec();
  }

  async create(data: Partial<User>): Promise<UserDocument> {
    const user = new this.userModel(data);
    return user.save();
  }
}

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model, PipelineStage } from 'mongoose';
import { Order, OrderDocument } from './order.schema';

interface MonthlyRevenue {
  month: number;
  revenue: number;
  orderCount: number;
}

@Injectable()
export class AnalyticsService {
  constructor(
    @InjectModel(Order.name) private orderModel: Model<OrderDocument>,
  ) {}

  async getRevenueByMonth(year: number): Promise<MonthlyRevenue[]> {
    const pipeline: PipelineStage[] = [
      // 스테이지 1: 연도로 필터링
      {
        $match: {
          createdAt: {
            $gte: new Date(`${year}-01-01`),
            $lt: new Date(`${year + 1}-01-01`),
          },
          status: 'completed',
        },
      },
      // 스테이지 2: 월별로 그룹화
      {
        $group: {
          _id: { $month: '$createdAt' },
          revenue: { $sum: '$totalAmount' },
          orderCount: { $sum: 1 },
        },
      },
      // 스테이지 3: 월 순서로 정렬
      { $sort: { _id: 1 } },
      // 스테이지 4: 출력 형식 정리
      {
        $project: {
          _id: 0,
          month: '$_id',
          revenue: 1,
          orderCount: 1,
        },
      },
    ];

    return this.orderModel.aggregate(pipeline).exec();
  }
}

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model, PipelineStage } from 'mongoose';
import { Order, OrderDocument } from './order.schema';

@Injectable()
export class OrderDetailsService {
  constructor(
    @InjectModel(Order.name) private orderModel: Model<OrderDocument>,
  ) {}

  async getOrdersWithUserDetails(): Promise<any[]> {
    const pipeline: PipelineStage[] = [
      // users 컬렉션과 조인
      {
        $lookup: {
          from: 'users',
          localField: 'userId',
          foreignField: '_id',
          as: 'user',
        },
      },
      // 배열에서 단일 객체로 변환
      { $unwind: '$user' },
      // 필요한 필드만 선택
      {
        $project: {
          orderNumber: 1,
          totalAmount: 1,
          'user.email': 1,
          'user.role': 1,
        },
      },
    ];

    return this.orderModel.aggregate(pipeline).exec();
  }
}

import { Injectable, BadRequestException } from '@nestjs/common';
import { InjectModel, InjectConnection } from '@nestjs/mongoose';
import { Model, Connection } from 'mongoose';
import { Account, AccountDocument } from './account.schema';

@Injectable()
export class TransferService {
  constructor(
    @InjectModel(Account.name) private accountModel: Model<AccountDocument>,
    @InjectConnection() private connection: Connection,
  ) {}

  async transfer(
    fromAccountId: string,
    toAccountId: string,
    amount: number,
  ): Promise<void> {
    // 세션 시작
    const session = await this.connection.startSession();

    try {
      await session.withTransaction(async () => {
        // 출금 계좌에서 차감
        const fromAccount = await this.accountModel.findByIdAndUpdate(
          fromAccountId,
          { $inc: { balance: -amount } },
          { session, new: true },
        );

        if (!fromAccount || fromAccount.balance < 0) {
          throw new BadRequestException('잔액이 부족합니다');
        }

        // 입금 계좌에 추가
        await this.accountModel.findByIdAndUpdate(
          toAccountId,
          { $inc: { balance: amount } },
          { session },
        );
      });
    } finally {
      await session.endSession();
    }
  }
}

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { HydratedDocument } from 'mongoose';

export type ProductDocument = HydratedDocument<Product>;

@Schema({
  timestamps: true,
  // 스키마 레벨에서 인덱스 정의
  autoIndex: process.env.NODE_ENV !== 'production',
})
export class Product {
  @Prop({ required: true, index: true })
  name: string;

  @Prop({ required: true })
  price: number;

  @Prop({ index: true })
  category: string;

  @Prop({ type: [String], index: true })
  tags: string[];
}

export const ProductSchema = SchemaFactory.createForClass(Product);

// 복합 인덱스 정의
ProductSchema.index({ category: 1, price: -1 });
ProductSchema.index({ name: 'text', tags: 'text' });

// lean()을 사용한 빠른 쿼리
const users = await this.userModel.find().lean().exec();

// 프로덕션 환경용 연결 설정
MongooseModule.forRoot(process.env.MONGODB_URI, {
  maxPoolSize: 50,
  minPoolSize: 10,
  serverSelectionTimeoutMS: 5000,
  socketTimeoutMS: 45000,
  retryWrites: true,
  w: 'majority',
});