AI 기반 시각화 전문지식 서비스

프로그램개발 · 분야 선택22개 분야

Ver3.0 전체 열람

Ver3.0 🛒 Node.js와 Express로 만드는 쇼핑몰 API 서버 완벽 가이드

2025.10.19

재능넷

댓글 0 전체 51 페이지

🛒 Node.js와 Express로 만드는 쇼핑몰 API 서버 완벽 가이드

실전 프로젝트로 배우는 백엔드 개발의 모든 것

🎯 왜 Node.js와 Express로 쇼핑몰 API를 만들까?

요즘 쇼핑몰 하나 만들려고 하면 정말 고민이 많아지지? 🤔 프론트엔드는 React나 Vue로 하고, 모바일 앱도 따로 만들어야 하고... 그럴 때 필요한 게 바로 API 서버야!

Node.js와 Express를 선택하는 이유는 명확해. 첫째, **JavaScript 하나로 프론트와 백엔드를 모두 다룰 수 있다**는 점이 엄청난 장점이야. 둘째, **비동기 처리에 최적화**되어 있어서 동시에 많은 사용자 요청을 처리하기 좋아. 셋째, **npm 생태계**가 어마어마하게 방대해서 필요한 기능은 대부분 라이브러리로 해결할 수 있지.

💡 실제 사례: 아마존, 넷플릭스, 우버 같은 글로벌 기업들도 Node.js를 활용하고 있어. 특히 실시간 데이터 처리가 중요한 서비스에서 Node.js의 성능은 검증됐다고 볼 수 있지!

재능넷(https://www.jaenung.net) 같은 플랫폼에서도 백엔드 개발 재능을 거래하는 경우가 많은데, Node.js 기반 API 개발은 정말 수요가 높은 분야야. 📈

🛠️ 개발 환경 세팅하기

필수 도구 설치

본격적으로 시작하기 전에 개발 환경부터 제대로 갖춰보자! ⚙️

1. Node.js 설치
공식 사이트(nodejs.org)에서 LTS 버전을 다운로드해. 현재 기준으로 18.x 이상 버전을 추천해. 설치 후 터미널에서 확인해보자:

node --version
npm --version

2. 프로젝트 초기화
새로운 폴더를 만들고 npm 프로젝트를 초기화해:

mkdir shopping-mall-api
cd shopping-mall-api
npm init -y

3. Express 및 필수 패키지 설치
이제 본격적으로 필요한 패키지들을 설치할 차례야:

npm install express
npm install mongoose dotenv cors
npm install jsonwebtoken bcrypt
npm install express-validator
npm install --save-dev nodemon

🎓 패키지 설명: • express: 웹 프레임워크
• mongoose: MongoDB ODM
• dotenv: 환경변수 관리
• cors: 크로스 오리진 요청 처리
• jsonwebtoken: JWT 인증
• bcrypt: 비밀번호 암호화
• express-validator: 입력값 검증
• nodemon: 자동 재시작 (개발용)

프로젝트 구조 설계

깔끔한 프로젝트 구조는 유지보수의 핵심이야! 📁 다음과 같은 구조를 추천해:

shopping-mall-api/
├── src/
│   ├── config/
│   │   └── database.js
│   ├── models/
│   │   ├── User.js
│   │   ├── Product.js
│   │   ├── Order.js
│   │   └── Cart.js
│   ├── routes/
│   │   ├── auth.js
│   │   ├── products.js
│   │   ├── orders.js
│   │   └── cart.js
│   ├── controllers/
│   │   ├── authController.js
│   │   ├── productController.js
│   │   ├── orderController.js
│   │   └── cartController.js
│   ├── middlewares/
│   │   ├── auth.js
│   │   └── errorHandler.js
│   └── utils/
│       └── validators.js
├── .env
├── .gitignore
├── package.json
└── server.js

이런 구조를 사용하면 **관심사의 분리(Separation of Concerns)**가 명확해져서 나중에 코드를 찾거나 수정하기가 훨씬 쉬워져. ✨

🚀 기본 서버 구축하기

Express 서버 초기 설정

자, 이제 본격적으로 서버를 만들어보자! 💻 server.js 파일을 생성하고 다음 코드를 작성해:

const express = require('express');
const cors = require('cors');
const dotenv = require('dotenv');

// 환경변수 로드
dotenv.config();

// Express 앱 생성
const app = express();

// 미들웨어 설정
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 기본 라우트
app.get('/', (req, res) => {
  res.json({ 
    message: '쇼핑몰 API 서버에 오신 것을 환영합니다!',
    version: '1.0.0'
  });
});

// 서버 시작
const PORT = process.env.PORT || 5000;
app.listen(PORT, () => {
  console.log(`서버가 포트 ${PORT}에서 실행 중입니다.`);
});

이 코드는 정말 기본적인 Express 서버야. cors()는 프론트엔드에서 API를 호출할 수 있게 해주고, express.json()은 JSON 형태의 요청 본문을 파싱해주지.

환경변수 설정

.env 파일을 만들어서 중요한 설정값들을 관리하자:

PORT=5000
MONGODB_URI=mongodb://localhost:27017/shopping-mall
JWT_SECRET=your-super-secret-key-change-this-in-production
JWT_EXPIRE=7d
NODE_ENV=development

⚠️ 보안 주의사항: .env 파일은 절대로 Git에 커밋하면 안 돼! .gitignore에 반드시 추가해야 해. JWT_SECRET은 실제 운영 환경에서는 복잡하고 긴 랜덤 문자열을 사용해야 해.

MongoDB 연결 설정

src/config/database.js 파일을 만들어서 데이터베이스 연결을 설정하자:

const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    console.log('MongoDB 연결 성공!');
  } catch (error) {
    console.error('MongoDB 연결 실패:', error.message);
    process.exit(1);
  }
};

module.exports = connectDB;

그리고 server.js에서 이 함수를 호출해:

const connectDB = require('./src/config/database');

// MongoDB 연결
connectDB();

📦 데이터 모델 설계하기

쇼핑몰 API의 핵심은 데이터 모델이야! 🗂️ 제대로 설계하면 나중에 기능 추가가 훨씬 쉬워져.

User 모델 (회원 정보)

src/models/User.js 파일을 만들어보자:

const mongoose = require('mongoose');
const bcrypt = require('bcrypt');

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: [true, '이메일은 필수입니다'],
    unique: true,
    lowercase: true,
    trim: true,
    match: [/^\S+@\S+\.\S+$/, '유효한 이메일을 입력해주세요']
  },
  password: {
    type: String,
    required: [true, '비밀번호는 필수입니다'],
    minlength: [6, '비밀번호는 최소 6자 이상이어야 합니다'],
    select: false
  },
  name: {
    type: String,
    required: [true, '이름은 필수입니다'],
    trim: true
  },
  phone: {
    type: String,
    required: [true, '전화번호는 필수입니다']
  },
  address: {
    zipCode: String,
    street: String,
    detail: String
  },
  role: {
    type: String,
    enum: ['user', 'admin'],
    default: 'user'
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

// 비밀번호 암호화 미들웨어
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  
  const salt = await bcrypt.genSalt(10);
  this.password = await bcrypt.hash(this.password, salt);
  next();
});

// 비밀번호 확인 메서드
userSchema.methods.comparePassword = async function(candidatePassword) {
  return await bcrypt.compare(candidatePassword, this.password);
};

module.exports = mongoose.model('User', userSchema);

💡 핵심 포인트: • pre('save') 미들웨어로 비밀번호를 자동으로 암호화해
• select: false로 비밀번호는 기본 조회에서 제외돼
• comparePassword 메서드로 로그인 시 비밀번호 검증을 쉽게 할 수 있어

Product 모델 (상품 정보)

src/models/Product.js를 만들어보자:

const mongoose = require('mongoose');

const productSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, '상품명은 필수입니다'],
    trim: true,
    maxlength: [100, '상품명은 100자를 초과할 수 없습니다']
  },
  description: {
    type: String,
    required: [true, '상품 설명은 필수입니다'],
    maxlength: [2000, '설명은 2000자를 초과할 수 없습니다']
  },
  price: {
    type: Number,
    required: [true, '가격은 필수입니다'],
    min: [0, '가격은 0 이상이어야 합니다']
  },
  discountPrice: {
    type: Number,
    min: [0, '할인가는 0 이상이어야 합니다']
  },
  category: {
    type: String,
    required: [true, '카테고리는 필수입니다'],
    enum: ['의류', '전자제품', '식품', '도서', '생활용품', '기타']
  },
  stock: {
    type: Number,
    required: [true, '재고는 필수입니다'],
    min: [0, '재고는 0 이상이어야 합니다'],
    default: 0
  },
  images: [{
    url: String,
    alt: String
  }],
  rating: {
    average: {
      type: Number,
      default: 0,
      min: 0,
      max: 5
    },
    count: {
      type: Number,
      default: 0
    }
  },
  isActive: {
    type: Boolean,
    default: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  },
  updatedAt: {
    type: Date,
    default: Date.now
  }
});

// 업데이트 시 updatedAt 자동 갱신
productSchema.pre('save', function(next) {
  this.updatedAt = Date.now();
  next();
});

// 가상 필드: 할인율 계산
productSchema.virtual('discountRate').get(function() {
  if (this.discountPrice && this.price > this.discountPrice) {
    return Math.round(((this.price - this.discountPrice) / this.price) * 100);
  }
  return 0;
});

module.exports = mongoose.model('Product', productSchema);

여기서 주목할 점은 virtual 필드야! ✨ 실제로 DB에 저장되지 않지만, 조회할 때 자동으로 계산되는 필드를 만들 수 있어. 할인율 같은 계산값에 유용하지.

Order 모델 (주문 정보)

주문 모델은 좀 더 복잡해. src/models/Order.js:

const mongoose = require('mongoose');

const orderSchema = new mongoose.Schema({
  user: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  orderNumber: {
    type: String,
    unique: true,
    required: true
  },
  items: [{
    product: {
      type: mongoose.Schema.Types.ObjectId,
      ref: 'Product',
      required: true
    },
    name: String,
    price: Number,
    quantity: {
      type: Number,
      required: true,
      min: 1
    },
    subtotal: Number
  }],
  totalAmount: {
    type: Number,
    required: true
  },
  shippingAddress: {
    name: String,
    phone: String,
    zipCode: String,
    street: String,
    detail: String
  },
  paymentMethod: {
    type: String,
    enum: ['card', 'bank', 'virtual', 'mobile'],
    required: true
  },
  paymentStatus: {
    type: String,
    enum: ['pending', 'paid', 'failed', 'refunded'],
    default: 'pending'
  },
  orderStatus: {
    type: String,
    enum: ['pending', 'confirmed', 'preparing', 'shipped', 'delivered', 'cancelled'],
    default: 'pending'
  },
  createdAt: {
    type: Date,
    default: Date.now
  },
  paidAt: Date,
  deliveredAt: Date
});

// 주문번호 자동 생성
orderSchema.pre('save', async function(next) {
  if (!this.orderNumber) {
    const date = new Date();
    const dateStr = date.toISOString().slice(0, 10).replace(/-/g, '');
    const random = Math.floor(Math.random() * 10000).toString().padStart(4, '0');
    this.orderNumber = `ORD${dateStr}${random}`;
  }
  next();
});

module.exports = mongoose.model('Order', orderSchema);

🎯 주문 모델 설계 팁: 주문 정보에는 상품의 현재 정보(이름, 가격)를 복사해서 저장하는 게 좋아. 왜냐하면 나중에 상품 정보가 변경되더라도 주문 당시의 정보를 유지해야 하거든! 📝

Cart 모델 (장바구니)

마지막으로 장바구니 모델이야. src/models/Cart.js:

const mongoose = require('mongoose');

const cartSchema = new mongoose.Schema({
  user: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true,
    unique: true
  },
  items: [{
    product: {
      type: mongoose.Schema.Types.ObjectId,
      ref: 'Product',
      required: true
    },
    quantity: {
      type: Number,
      required: true,
      min: 1,
      default: 1
    },
    addedAt: {
      type: Date,
      default: Date.now
    }
  }],
  updatedAt: {
    type: Date,
    default: Date.now
  }
});

// 업데이트 시 updatedAt 자동 갱신
cartSchema.pre('save', function(next) {
  this.updatedAt = Date.now();
  next();
});

module.exports = mongoose.model('Cart', cartSchema);

🔐 인증 시스템 구축하기

쇼핑몰에서 인증은 정말 중요해! 🔒 JWT(JSON Web Token)를 사용해서 안전하고 확장 가능한 인증 시스템을 만들어보자.

JWT 미들웨어 작성

src/middlewares/auth.js 파일을 만들어보자:

const jwt = require('jsonwebtoken');
const User = require('../models/User');

exports.protect = async (req, res, next) => {
  try {
    let token;
    
    // 헤더에서 토큰 추출
    if (req.headers.authorization && 
        req.headers.authorization.startsWith('Bearer')) {
      token = req.headers.authorization.split(' ')[1];
    }
    
    if (!token) {
      return res.status(401).json({
        success: false,
        message: '인증 토큰이 없습니다'
      });
    }
    
    // 토큰 검증
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    
    // 사용자 정보 조회
    req.user = await User.findById(decoded.id);
    
    if (!req.user) {
      return res.status(401).json({
        success: false,
        message: '사용자를 찾을 수 없습니다'
      });
    }
    
    next();
  } catch (error) {
    return res.status(401).json({
      success: false,
      message: '유효하지 않은 토큰입니다'
    });
  }
};

// 관리자 권한 확인
exports.authorize = (...roles) => {
  return (req, res, next) => {
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({
        success: false,
        message: '접근 권한이 없습니다'
      });
    }
    next();
  };
};

인증 컨트롤러 작성

src/controllers/authController.js를 만들어서 회원가입, 로그인 로직을 구현하자:

const jwt = require('jsonwebtoken');
const User = require('../models/User');

// JWT 토큰 생성 함수
const generateToken = (id) => {
  return jwt.sign({ id }, process.env.JWT_SECRET, {
    expiresIn: process.env.JWT_EXPIRE
  });
};

// 회원가입
exports.register = async (req, res) => {
  try {
    const { email, password, name, phone } = req.body;
    
    // 이메일 중복 확인
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(400).json({
        success: false,
        message: '이미 가입된 이메일입니다'
      });
    }
    
    // 사용자 생성
    const user = await User.create({
      email,
      password,
      name,
      phone
    });
    
    // 토큰 생성
    const token = generateToken(user._id);
    
    res.status(201).json({
      success: true,
      message: '회원가입이 완료되었습니다',
      token,
      user: {
        id: user._id,
        email: user.email,
        name: user.name,
        role: user.role
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '회원가입 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 로그인
exports.login = async (req, res) => {
  try {
    const { email, password } = req.body;
    
    // 입력값 확인
    if (!email || !password) {
      return res.status(400).json({
        success: false,
        message: '이메일과 비밀번호를 입력해주세요'
      });
    }
    
    // 사용자 조회 (비밀번호 포함)
    const user = await User.findOne({ email }).select('+password');
    
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '이메일 또는 비밀번호가 올바르지 않습니다'
      });
    }
    
    // 비밀번호 확인
    const isPasswordCorrect = await user.comparePassword(password);
    
    if (!isPasswordCorrect) {
      return res.status(401).json({
        success: false,
        message: '이메일 또는 비밀번호가 올바르지 않습니다'
      });
    }
    
    // 토큰 생성
    const token = generateToken(user._id);
    
    res.status(200).json({
      success: true,
      message: '로그인 성공',
      token,
      user: {
        id: user._id,
        email: user.email,
        name: user.name,
        role: user.role
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '로그인 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 내 정보 조회
exports.getMe = async (req, res) => {
  try {
    const user = await User.findById(req.user.id);
    
    res.status(200).json({
      success: true,
      user
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '사용자 정보 조회 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

인증 라우트 설정

src/routes/auth.js를 만들어서 라우트를 연결하자:

const express = require('express');
const router = express.Router();
const { register, login, getMe } = require('../controllers/authController');
const { protect } = require('../middlewares/auth');

router.post('/register', register);
router.post('/login', login);
router.get('/me', protect, getMe);

module.exports = router;

그리고 server.js에서 이 라우트를 등록해:

const authRoutes = require('./src/routes/auth');

app.use('/api/auth', authRoutes);

🔑 JWT 인증 흐름: 1. 사용자가 로그인하면 서버가 JWT 토큰을 발급해
2. 클라이언트는 이 토큰을 저장하고, 이후 요청마다 헤더에 포함시켜
3. 서버는 토큰을 검증해서 사용자를 식별하고 권한을 확인해
4. 토큰에는 만료 시간이 있어서 보안이 강화돼 🛡️

🛍️ 상품 관리 API 구축하기

이제 본격적으로 쇼핑몰의 핵심 기능인 상품 관리 API를 만들어보자! 📦

상품 컨트롤러 작성

src/controllers/productController.js를 만들어보자:

const Product = require('../models/Product');

// 상품 목록 조회 (필터링, 정렬, 페이지네이션)
exports.getProducts = async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 12;
    const skip = (page - 1) * limit;
    
    // 필터 조건 구성
    const filter = { isActive: true };
    
    if (req.query.category) {
      filter.category = req.query.category;
    }
    
    if (req.query.minPrice || req.query.maxPrice) {
      filter.price = {};
      if (req.query.minPrice) filter.price.$gte = parseInt(req.query.minPrice);
      if (req.query.maxPrice) filter.price.$lte = parseInt(req.query.maxPrice);
    }
    
    if (req.query.search) {
      filter.$or = [
        { name: { $regex: req.query.search, $options: 'i' } },
        { description: { $regex: req.query.search, $options: 'i' } }
      ];
    }
    
    // 정렬 옵션
    let sort = {};
    if (req.query.sort === 'price-asc') sort.price = 1;
    else if (req.query.sort === 'price-desc') sort.price = -1;
    else if (req.query.sort === 'rating') sort['rating.average'] = -1;
    else sort.createdAt = -1;
    
    // 상품 조회
    const products = await Product.find(filter)
      .sort(sort)
      .skip(skip)
      .limit(limit);
    
    const total = await Product.countDocuments(filter);
    
    res.status(200).json({
      success: true,
      count: products.length,
      total,
      page,
      totalPages: Math.ceil(total / limit),
      products
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '상품 목록 조회 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 상품 상세 조회
exports.getProduct = async (req, res) => {
  try {
    const product = await Product.findById(req.params.id);
    
    if (!product) {
      return res.status(404).json({
        success: false,
        message: '상품을 찾을 수 없습니다'
      });
    }
    
    res.status(200).json({
      success: true,
      product
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '상품 조회 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 상품 등록 (관리자 전용)
exports.createProduct = async (req, res) => {
  try {
    const product = await Product.create(req.body);
    
    res.status(201).json({
      success: true,
      message: '상품이 등록되었습니다',
      product
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '상품 등록 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 상품 수정 (관리자 전용)
exports.updateProduct = async (req, res) => {
  try {
    const product = await Product.findByIdAndUpdate(
      req.params.id,
      req.body,
      { new: true, runValidators: true }
    );
    
    if (!product) {
      return res.status(404).json({
        success: false,
        message: '상품을 찾을 수 없습니다'
      });
    }
    
    res.status(200).json({
      success: true,
      message: '상품이 수정되었습니다',
      product
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '상품 수정 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 상품 삭제 (관리자 전용)
exports.deleteProduct = async (req, res) => {
  try {
    const product = await Product.findByIdAndUpdate(
      req.params.id,
      { isActive: false },
      { new: true }
    );
    
    if (!product) {
      return res.status(404).json({
        success: false,
        message: '상품을 찾을 수 없습니다'
      });
    }
    
    res.status(200).json({
      success: true,
      message: '상품이 삭제되었습니다'
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '상품 삭제 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

💡 필터링과 페이지네이션: 상품 목록 API에서는 카테고리, 가격 범위, 검색어 등으로 필터링할 수 있고, 정렬 옵션도 제공해. 페이지네이션을 통해 한 번에 12개씩만 불러오니까 성능도 좋아지고 사용자 경험도 개선돼! ⚡

상품 라우트 설정

src/routes/products.js를 만들자:

const express = require('express');
const router = express.Router();
const {
  getProducts,
  getProduct,
  createProduct,
  updateProduct,
  deleteProduct
} = require('../controllers/productController');
const { protect, authorize } = require('../middlewares/auth');

router.get('/', getProducts);
router.get('/:id', getProduct);
router.post('/', protect, authorize('admin'), createProduct);
router.put('/:id', protect, authorize('admin'), updateProduct);
router.delete('/:id', protect, authorize('admin'), deleteProduct);

module.exports = router;

server.js에 라우트 등록:

const productRoutes = require('./src/routes/products');

app.use('/api/products', productRoutes);

🛒 장바구니 API 구축하기

장바구니는 쇼핑몰에서 정말 중요한 기능이야! 🛒 사용자가 여러 상품을 담아두고 나중에 한 번에 주문할 수 있게 해주지.

장바구니 컨트롤러 작성

src/controllers/cartController.js를 만들어보자:

const Cart = require('../models/Cart');
const Product = require('../models/Product');

// 장바구니 조회
exports.getCart = async (req, res) => {
  try {
    let cart = await Cart.findOne({ user: req.user.id })
      .populate('items.product', 'name price discountPrice images stock');
    
    if (!cart) {
      cart = await Cart.create({ user: req.user.id, items: [] });
    }
    
    // 총 금액 계산
    let totalAmount = 0;
    cart.items.forEach(item => {
      if (item.product) {
        const price = item.product.discountPrice || item.product.price;
        totalAmount += price * item.quantity;
      }
    });
    
    res.status(200).json({
      success: true,
      cart,
      totalAmount
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '장바구니 조회 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 장바구니에 상품 추가
exports.addToCart = async (req, res) => {
  try {
    const { productId, quantity } = req.body;
    
    // 상품 존재 확인
    const product = await Product.findById(productId);
    if (!product) {
      return res.status(404).json({
        success: false,
        message: '상품을 찾을 수 없습니다'
      });
    }
    
    // 재고 확인
    if (product.stock < quantity) {
      return res.status(400).json({
        success: false,
        message: '재고가 부족합니다'
      });
    }
    
    // 장바구니 조회 또는 생성
    let cart = await Cart.findOne({ user: req.user.id });
    if (!cart) {
      cart = await Cart.create({ user: req.user.id, items: [] });
    }
    
    // 이미 장바구니에 있는 상품인지 확인
    const existingItemIndex = cart.items.findIndex(
      item => item.product.toString() === productId
    );
    
    if (existingItemIndex > -1) {
      // 기존 상품 수량 증가
      cart.items[existingItemIndex].quantity += quantity;
    } else {
      // 새 상품 추가
      cart.items.push({ product: productId, quantity });
    }
    
    await cart.save();
    
    // populate해서 반환
    cart = await cart.populate('items.product', 'name price discountPrice images');
    
    res.status(200).json({
      success: true,
      message: '장바구니에 추가되었습니다',
      cart
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '장바구니 추가 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 장바구니 상품 수량 변경
exports.updateCartItem = async (req, res) => {
  try {
    const { productId, quantity } = req.body;
    
    if (quantity < 1) {
      return res.status(400).json({
        success: false,
        message: '수량은 1 이상이어야 합니다'
      });
    }
    
    const cart = await Cart.findOne({ user: req.user.id });
    if (!cart) {
      return res.status(404).json({
        success: false,
        message: '장바구니를 찾을 수 없습니다'
      });
    }
    
    const itemIndex = cart.items.findIndex(
      item => item.product.toString() === productId
    );
    
    if (itemIndex === -1) {
      return res.status(404).json({
        success: false,
        message: '장바구니에 해당 상품이 없습니다'
      });
    }
    
    cart.items[itemIndex].quantity = quantity;
    await cart.save();
    
    await cart.populate('items.product', 'name price discountPrice images');
    
    res.status(200).json({
      success: true,
      message: '수량이 변경되었습니다',
      cart
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '수량 변경 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 장바구니에서 상품 제거
exports.removeFromCart = async (req, res) => {
  try {
    const { productId } = req.params;
    
    const cart = await Cart.findOne({ user: req.user.id });
    if (!cart) {
      return res.status(404).json({
        success: false,
        message: '장바구니를 찾을 수 없습니다'
      });
    }
    
    cart.items = cart.items.filter(
      item => item.product.toString() !== productId
    );
    
    await cart.save();
    await cart.populate('items.product', 'name price discountPrice images');
    
    res.status(200).json({
      success: true,
      message: '상품이 제거되었습니다',
      cart
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '상품 제거 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 장바구니 비우기
exports.clearCart = async (req, res) => {
  try {
    const cart = await Cart.findOne({ user: req.user.id });
    if (!cart) {
      return res.status(404).json({
        success: false,
        message: '장바구니를 찾을 수 없습니다'
      });
    }
    
    cart.items = [];
    await cart.save();
    
    res.status(200).json({
      success: true,
      message: '장바구니가 비워졌습니다',
      cart
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '장바구니 비우기 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

장바구니 라우트 설정

src/routes/cart.js:

const express = require('express');
const router = express.Router();
const {
  getCart,
  addToCart,
  updateCartItem,
  removeFromCart,
  clearCart
} = require('../controllers/cartController');
const { protect } = require('../middlewares/auth');

router.use(protect); // 모든 장바구니 라우트는 인증 필요

router.get('/', getCart);
router.post('/add', addToCart);
router.put('/update', updateCartItem);
router.delete('/remove/:productId', removeFromCart);
router.delete('/clear', clearCart);

module.exports = router;

server.js에 등록:

const cartRoutes = require('./src/routes/cart');

app.use('/api/cart', cartRoutes);

📦 주문 처리 API 구축하기

드디어 주문 처리 API를 만들 차례야! 💳 이건 쇼핑몰의 가장 핵심적인 기능이지.

주문 컨트롤러 작성

src/controllers/orderController.js:

const Order = require('../models/Order');
const Cart = require('../models/Cart');
const Product = require('../models/Product');

// 주문 생성
exports.createOrder = async (req, res) => {
  try {
    const { shippingAddress, paymentMethod } = req.body;
    
    // 장바구니 조회
    const cart = await Cart.findOne({ user: req.user.id })
      .populate('items.product');
    
    if (!cart || cart.items.length === 0) {
      return res.status(400).json({
        success: false,
        message: '장바구니가 비어있습니다'
      });
    }
    
    // 주문 아이템 구성 및 재고 확인
    const orderItems = [];
    let totalAmount = 0;
    
    for (const item of cart.items) {
      const product = item.product;
      
      // 재고 확인
      if (product.stock < item.quantity) {
        return res.status(400).json({
          success: false,
          message: `${product.name}의 재고가 부족합니다`
        });
      }
      
      const price = product.discountPrice || product.price;
      const subtotal = price * item.quantity;
      
      orderItems.push({
        product: product._id,
        name: product.name,
        price: price,
        quantity: item.quantity,
        subtotal: subtotal
      });
      
      totalAmount += subtotal;
      
      // 재고 감소
      product.stock -= item.quantity;
      await product.save();
    }
    
    // 주문 생성
    const order = await Order.create({
      user: req.user.id,
      items: orderItems,
      totalAmount,
      shippingAddress,
      paymentMethod
    });
    
    // 장바구니 비우기
    cart.items = [];
    await cart.save();
    
    res.status(201).json({
      success: true,
      message: '주문이 완료되었습니다',
      order
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '주문 생성 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 내 주문 목록 조회
exports.getMyOrders = async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const skip = (page - 1) * limit;
    
    const orders = await Order.find({ user: req.user.id })
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(limit)
      .populate('items.product', 'name images');
    
    const total = await Order.countDocuments({ user: req.user.id });
    
    res.status(200).json({
      success: true,
      count: orders.length,
      total,
      page,
      totalPages: Math.ceil(total / limit),
      orders
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '주문 목록 조회 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 주문 상세 조회
exports.getOrder = async (req, res) => {
  try {
    const order = await Order.findById(req.params.id)
      .populate('items.product', 'name images')
      .populate('user', 'name email phone');
    
    if (!order) {
      return res.status(404).json({
        success: false,
        message: '주문을 찾을 수 없습니다'
      });
    }
    
    // 본인 주문이거나 관리자인지 확인
    if (order.user._id.toString() !== req.user.id && req.user.role !== 'admin') {
      return res.status(403).json({
        success: false,
        message: '접근 권한이 없습니다'
      });
    }
    
    res.status(200).json({
      success: true,
      order
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '주문 조회 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 주문 취소
exports.cancelOrder = async (req, res) => {
  try {
    const order = await Order.findById(req.params.id);
    
    if (!order) {
      return res.status(404).json({
        success: false,
        message: '주문을 찾을 수 없습니다'
      });
    }
    
    // 본인 주문인지 확인
    if (order.user.toString() !== req.user.id) {
      return res.status(403).json({
        success: false,
        message: '접근 권한이 없습니다'
      });
    }
    
    // 취소 가능한 상태인지 확인
    if (order.orderStatus !== 'pending' && order.orderStatus !== 'confirmed') {
      return res.status(400).json({
        success: false,
        message: '이미 배송이 시작된 주문은 취소할 수 없습니다'
      });
    }
    
    // 재고 복구
    for (const item of order.items) {
      const product = await Product.findById(item.product);
      if (product) {
        product.stock += item.quantity;
        await product.save();
      }
    }
    
    order.orderStatus = 'cancelled';
    await order.save();
    
    res.status(200).json({
      success: true,
      message: '주문이 취소되었습니다',
      order
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '주문 취소 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 주문 상태 변경 (관리자 전용)
exports.updateOrderStatus = async (req, res) => {
  try {
    const { orderStatus } = req.body;
    
    const order = await Order.findById(req.params.id);
    
    if (!order) {
      return res.status(404).json({
        success: false,
        message: '주문을 찾을 수 없습니다'
      });
    }
    
    order.orderStatus = orderStatus;
    
    if (orderStatus === 'delivered') {
      order.deliveredAt = Date.now();
    }
    
    await order.save();
    
    res.status(200).json({
      success: true,
      message: '주문 상태가 변경되었습니다',
      order
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '주문 상태 변경 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

// 전체 주문 목록 조회 (관리자 전용)
exports.getAllOrders = async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 20;
    const skip = (page - 1) * limit;
    
    const filter = {};
    if (req.query.status) {
      filter.orderStatus = req.query.status;
    }
    
    const orders = await Order.find(filter)
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(limit)
      .populate('user', 'name email')
      .populate('items.product', 'name');
    
    const total = await Order.countDocuments(filter);
    
    res.status(200).json({
      success: true,
      count: orders.length,
      total,
      page,
      totalPages: Math.ceil(total / limit),
      orders
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: '주문 목록 조회 중 오류가 발생했습니다',
      error: error.message
    });
  }
};

⚠️ 트랜잭션 처리: 실제 운영 환경에서는 주문 생성 시 재고 감소와 주문 생성을 하나의 트랜잭션으로 묶어야 해. MongoDB의 트랜잭션 기능을 사용하거나, 에러 발생 시 롤백 로직을 구현해야 데이터 정합성을 보장할 수 있어!

주문 라우트 설정

src/routes/orders.js:

const express = require('express');
const router = express.Router();
const {
  createOrder,
  getMyOrders,
  getOrder,
  cancelOrder,
  updateOrderStatus,
  getAllOrders
} = require('../controllers/orderController');
const { protect, authorize } = require('../middlewares/auth');

router.post('/', protect, createOrder);
router.get('/my', protect, getMyOrders);
router.get('/all', protect, authorize('admin'), getAllOrders);
router.get('/:id', protect, getOrder);
router.put('/:id/cancel', protect, cancelOrder);
router.put('/:id/status', protect, authorize('admin'), updateOrderStatus);

module.exports = router;

server.js에 등록:

const orderRoutes = require('./src/routes/orders');

app.use('/api/orders', orderRoutes);

🔍 입력값 검증과 에러 처리

API 서버에서 입력값 검증과 에러 처리는 정말 중요해! 🛡️ 사용자가 잘못된 데이터를 보내도 서버가 안전하게 처리할 수 있어야 하거든.

입력값 검증 미들웨어

express-validator를 사용해서 입력값을 검증해보자. src/utils/validators.js:

const { body, validationResult } = require('express-validator');

// 검증 결과 확인 미들웨어
exports.validate = (req, res, next) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({
      success: false,
      message: '입력값이 올바르지 않습니다',
      errors: errors.array()
    });
  }
  next();
};

// 회원가입 검증 규칙
exports.registerValidation = [
  body('email')
    .isEmail()
    .withMessage('유효한 이메일을 입력해주세요')
    .normalizeEmail(),
  body('password')
    .isLength({ min: 6 })
    .withMessage('비밀번호는 최소 6자 이상이어야 합니다'),
  body('name')
    .trim()
    .notEmpty()
    .withMessage('이름을 입력해주세요'),
  body('phone')
    .matches(/^[0-9]{10,11}$/)
    .withMessage('유효한 전화번호를 입력해주세요')
];

// 상품 등록 검증 규칙
exports.productValidation = [
  body('name')
    .trim()
    .notEmpty()
    .withMessage('상품명을 입력해주세요')
    .isLength({ max: 100 })
    .withMessage('상품명은 100자를 초과할 수 없습니다'),
  body('description')
    .trim()
    .notEmpty()
    .withMessage('상품 설명을 입력해주세요'),
  body('price')
    .isFloat({ min: 0 })
    .withMessage('가격은 0 이상이어야 합니다'),
  body('category')
    .isIn(['의류', '전자제품', '식품', '도서', '생활용품', '기타'])
    .withMessage('유효한 카테고리를 선택해주세요'),
  body('stock')
    .isInt({ min: 0 })
    .withMessage('재고는 0 이상의 정수여야 합니다')
];

// 주문 생성 검증 규칙
exports.orderValidation = [
  body('shippingAddress.name')
    .trim()
    .notEmpty()
    .withMessage('수령인 이름을 입력해주세요'),
  body('shippingAddress.phone')
    .matches(/^[0-9]{10,11}$/)
    .withMessage('유효한 전화번호를 입력해주세요'),
  body('shippingAddress.zipCode')
    .trim()
    .notEmpty()
    .withMessage('우편번호를 입력해주세요'),
  body('shippingAddress.street')
    .trim()
    .notEmpty()
    .withMessage('주소를 입력해주세요'),
  body('paymentMethod')
    .isIn(['card', 'bank', 'virtual', 'mobile'])
    .withMessage('유효한 결제 방법을 선택해주세요')
];

이제 라우트에서 이 검증 규칙들을 사용하면 돼:

const { registerValidation, validate } = require('../utils/validators');

router.post('/register', registerValidation, validate, register);

전역 에러 핸들러

src/middlewares/errorHandler.js를 만들어서 모든 에러를 일관되게 처리하자:

const errorHandler = (err, req, res, next) => {
  let error = { ...err };
  error.message = err.message;
  
  // Mongoose 중복 키 에러
  if (err.code === 11000) {
    const field = Object.keys(err.keyValue)[0];
    error.message = `이미 존재하는 ${field}입니다`;
    error.statusCode = 400;
  }
  
  // Mongoose 유효성 검사 에러
  if (err.name === 'ValidationError') {
    const messages = Object.values(err.errors).map(e => e.message);
    error.message = messages.join(', ');
    error.statusCode = 400;
  }
  
  // Mongoose ObjectId 에러
  if (err.name === 'CastError') {
    error.message = '잘못된 ID 형식입니다';
    error.statusCode = 400;
  }
  
  // JWT 에러
  if (err.name === 'JsonWebTokenError') {
    error.message = '유효하지 않은 토큰입니다';
    error.statusCode = 401;
  }
  
  if (err.name === 'TokenExpiredError') {
    error.message = '토큰이 만료되었습니다';
    error.statusCode = 401;
  }
  
  res.status(error.statusCode || 500).json({
    success: false,
    message: error.message || '서버 오류가 발생했습니다',
    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
  });
};

module.exports = errorHandler;

server.js의 마지막에 에러 핸들러를 등록해:

const errorHandler = require('./src/middlewares/errorHandler');

// 모든 라우트 뒤에 위치
app.use(errorHandler);

🎯 에러 처리 베스트 프랙티스: • 일관된 에러 응답 형식 사용
• 개발 환경에서는 상세한 에러 정보 제공
• 운영 환경에서는 민감한 정보 노출 방지
• 적절한 HTTP 상태 코드 사용
• 로깅 시스템 구축 (Winston, Morgan 등)

🚀 성능 최적화와 보안 강화

API 서버를 실제로 운영하려면 성능과 보안을 신경 써야 해! ⚡

성능 최적화 기법

1. 데이터베이스 인덱싱
자주 조회되는 필드에 인덱스를 추가하면 쿼리 속도가 엄청나게 빨라져:

// Product 모델에 인덱스 추가
productSchema.index({ name: 'text', description: 'text' });
productSchema.index({ category: 1, price: 1 });
productSchema.index({ createdAt: -1 });

// User 모델에 인덱스 추가
userSchema.index({ email: 1 });

// Order 모델에 인덱스 추가
orderSchema.index({ user: 1, createdAt: -1 });
orderSchema.index({ orderNumber: 1 });

2. 응답 압축
compression 미들웨어를 사용해서 응답 데이터를 압축하자:

npm install compression

// server.js
const compression = require('compression');

app.use(compression());

3. 캐싱 전략
자주 변경되지 않는 데이터는 Redis 같은 캐시를 사용하면 좋아:

npm install redis

// src/config/redis.js
const redis = require('redis');
const client = redis.createClient({
  host: process.env.REDIS_HOST || 'localhost',
  port: process.env.REDIS_PORT || 6379
});

client.on('error', (err) => console.error('Redis 에러:', err));

module.exports = client;

4. 페이지네이션과 필드 선택
대량의 데이터를 한 번에 보내지 말고, 필요한 필드만 선택해서 보내:

// 필요한 필드만 선택
const products = await Product.find()
  .select('name price images rating')
  .limit(20);

// populate할 때도 필드 선택
const order = await Order.findById(id)
  .populate('user', 'name email')
  .populate('items.product', 'name price images');

보안 강화 방법

1. Helmet 사용
HTTP 헤더를 설정해서 일반적인 웹 취약점을 방어해:

npm install helmet

// server.js
const helmet = require('helmet');

app.use(helmet());

2. Rate Limiting
API 남용을 방지하기 위해 요청 횟수를 제한하자:

npm install express-rate-limit

// server.js
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15분
  max: 100, // 최대 100개 요청
  message: '너무 많은 요청을 보냈습니다. 잠시 후 다시 시도해주세요.'
});

app.use('/api/', limiter);

3. XSS 방지
사용자 입력을 sanitize해서 XSS 공격을 방어해:

npm install xss-clean

// server.js
const xss = require('xss-clean');

app.use(xss());

4. NoSQL Injection 방지
MongoDB 쿼리 인젝션을 방지하자:

npm install express-mongo-sanitize

// server.js
const mongoSanitize = require('express-mongo-sanitize');

app.use(mongoSanitize());

5. HTTPS 사용
운영 환경에서는 반드시 HTTPS를 사용해야 해. Let's Encrypt로 무료 SSL 인증서를 받을 수 있어!

🔒 보안 체크리스트: ✅ 환경변수로 민감한 정보 관리
✅ JWT 토큰에 적절한 만료 시간 설정
✅ 비밀번호 암호화 (bcrypt)
✅ CORS 설정으로 허용된 도메인만 접근
✅ SQL/NoSQL Injection 방어
✅ XSS 공격 방어
✅ Rate Limiting 적용
✅ HTTPS 사용
✅ 정기적인 의존성 업데이트

📊 로깅과 모니터링

운영 중인 API 서버의 상태를 파악하려면 로깅과 모니터링이 필수야! 📈

Winston으로 로깅 구현

winston은 Node.js에서 가장 많이 사용되는 로깅 라이브러리야:

npm install winston

// src/config/logger.js
const winston = require('winston');

const logger = winston.createLogger({
  level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({ 
      filename: 'logs/error.log', 
      level: 'error' 
    }),
    new winston.transports.File({ 
      filename: 'logs/combined.log' 
    })
  ]
});

// 개발 환경에서는 콘솔에도 출력
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.combine(
      winston.format.colorize(),
      winston.format.simple()
    )
  }));
}

module.exports = logger;

이제 컨트롤러에서 로거를 사용할 수 있어:

const logger = require('../config/logger');

exports.createOrder = async (req, res) => {
  try {
    // ... 주문 생성 로직
    
    logger.info('주문 생성 성공', {
      userId: req.user.id,
      orderId: order._id,
      totalAmount: order.totalAmount
    });
    
    res.status(201).json({ success: true, order });
  } catch (error) {
    logger.error('주문 생성 실패', {
      userId: req.user.id,
      error: error.message,
      stack: error.stack
    });
    
    res.status(500).json({ success: false, message: '주문 생성 중 오류가 발생했습니다' });
  }
};

Morgan으로 HTTP 요청 로깅

morgan은 HTTP 요청을 자동으로 로깅해줘:

npm install morgan

// server.js
const morgan = require('morgan');
const logger = require('./src/config/logger');

// Morgan 스트림 설정
const stream = {
  write: (message) => logger.http(message.trim())
};

// 개발 환경에서는 'dev' 포맷 사용
if (process.env.NODE_ENV === 'development') {
  app.use(morgan('dev'));
} else {
  app.use(morgan('combined', { stream }));
}

🧪 테스트 작성하기

안정적인 API를 만들려면 테스트가 필수야! 🧪 Jest와 Supertest를 사용해서 테스트를 작성해보자.

테스트 환경 설정

npm install --save-dev jest supertest

// package.json에 테스트 스크립트 추가
{
  "scripts": {
    "test": "jest --watchAll --verbose",
    "test:coverage": "jest --coverage"
  },
  "jest": {
    "testEnvironment": "node",
    "coveragePathIgnorePatterns": ["/node_modules/"]
  }
}

API 테스트 예제

tests/auth.test.js:

const request = require('supertest');
const app = require('../server');
const User = require('../src/models/User');

describe('인증 API 테스트', () => {
  beforeEach(async () => {
    await User.deleteMany({});
  });
  
  describe('POST /api/auth/register', () => {
    it('회원가입 성공', async () => {
      const res = await request(app)
        .post('/api/auth/register')
        .send({
          email: 'test@example.com',
          password: 'password123',
          name: '홍길동',
          phone: '01012345678'
        });
      
      expect(res.statusCode).toBe(201);
      expect(res.body.success).toBe(true);
      expect(res.body.token).toBeDefined();
      expect(res.body.user.email).toBe('test@example.com');
    });
    
    it('중복 이메일로 회원가입 실패', async () => {
      await User.create({
        email: 'test@example.com',
        password: 'password123',
        name: '홍길동',
        phone: '01012345678'
      });
      
      const res = await request(app)
        .post('/api/auth/register')
        .send({
          email: 'test@example.com',
          password: 'password456',
          name: '김철수',
          phone: '01087654321'
        });
      
      expect(res.statusCode).toBe(400);
      expect(res.body.success).toBe(false);
    });
  });
  
  describe('POST /api/auth/login', () => {
    beforeEach(async () => {
      await User.create({
        email: 'test@example.com',
        password: 'password123',
        name: '홍길동',
        phone: '01012345678'
      });
    });
    
    it('로그인 성공', async () => {
      const res = await request(app)
        .post('/api/auth/login')
        .send({
          email: 'test@example.com',
          password: 'password123'
        });
      
      expect(res.statusCode).toBe(200);
      expect(res.body.success).toBe(true);
      expect(res.body.token).toBeDefined();
    });
    
    it('잘못된 비밀번호로 로그인 실패', async () => {
      const res = await request(app)
        .post('/api/auth/login')
        .send({
          email: 'test@example.com',
          password: 'wrongpassword'
        });
      
      expect(res.statusCode).toBe(401);
      expect(res.body.success).toBe(false);
    });
  });
});

💡 테스트 작성 팁: • 각 테스트는 독립적으로 실행되어야 해
• beforeEach로 테스트 전 데이터 초기화
• 성공 케이스와 실패 케이스 모두 테스트
• 엣지 케이스도 고려해서 작성
• 테스트 커버리지 80% 이상 목표

🚢 배포와 운영

개발이 끝났으면 이제 실제로 배포해야지! 🚀 여러 배포 옵션이 있어.

환경 변수 설정

운영 환경의 .env 파일:

NODE_ENV=production
PORT=5000
MONGODB_URI=mongodb+srv://username:password@cluster.mongodb.net/shopping-mall
JWT_SECRET=super-secret-production-key-change-this
JWT_EXPIRE=7d
REDIS_HOST=your-redis-host
REDIS_PORT=6379

PM2로 프로세스 관리

PM2는 Node.js 애플리케이션을 관리하는 프로세스 매니저야:

npm install -g pm2

// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'shopping-mall-api',
    script: './server.js',
    instances: 'max',
    exec_mode: 'cluster',
    env: {
      NODE_ENV: 'production'
    },
    error_file: './logs/err.log',
    out_file: './logs/out.log',
    log_date_format: 'YYYY-MM-DD HH:mm:ss'
  }]
};

// 실행
pm2 start ecosystem.config.js
pm2 save
pm2 startup

Docker 컨테이너화

Docker를 사용하면 어디서든 동일한 환경에서 실행할 수 있어:

# Dockerfile
FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 5000

CMD ["node", "server.js"]

# docker-compose.yml
version: '3.8'

services:
  api:
    build: .
    ports:
      - "5000:5000"
    environment:
      - NODE_ENV=production
      - MONGODB_URI=mongodb://mongo:27017/shopping-mall
    depends_on:
      - mongo
    restart: unless-stopped
  
  mongo:
    image: mongo:6
    volumes:
      - mongo-data:/data/db
    restart: unless-stopped

volumes:
  mongo-data:

클라우드 배포 옵션

1. Heroku - 간단하고 빠른 배포
2. AWS EC2 - 완전한 제어권
3. DigitalOcean - 가성비 좋은 VPS
4. Vercel/Netlify - 서버리스 함수로 배포
5. AWS Lambda - 서버리스 아키텍처

🎯 배포 체크리스트: ✅ 환경변수 설정 확인
✅ 데이터베이스 백업 설정
✅ HTTPS 인증서 설정
✅ 도메인 연결
✅ 모니터링 도구 설정
✅ 로그 수집 시스템 구축
✅ CI/CD 파이프라인 구성
✅ 에러 추적 도구 (Sentry 등)
✅ 성능 모니터링 (New Relic 등)

💡 실전 팁과 베스트 프랙티스

마지막으로 실제 프로젝트에서 유용한 팁들을 공유할게! ✨

API 문서화

Swagger를 사용해서 API 문서를 자동으로 생성하자:

npm install swagger-jsdoc swagger-ui-express

// server.js
const swaggerJsdoc = require('swagger-jsdoc');
const swaggerUi = require('swagger-ui-express');

const swaggerOptions = {
  definition: {
    openapi: '3.0.0',
    info: {
      title: '쇼핑몰 API',
      version: '1.0.0',
      description: 'Node.js와 Express로 만든 쇼핑몰 API 서버'
    },
    servers: [
      {
        url: 'http://localhost:5000',
        description: '개발 서버'
      }
    ]
  },
  apis: ['./src/routes/*.js']
};

const swaggerSpec = swaggerJsdoc(swaggerOptions);
app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));

버전 관리

API 버전을 관리해서 하위 호환성을 유지하자:

// v1 라우트
app.use('/api/v1/auth', authRoutesV1);
app.use('/api/v1/products', productRoutesV1);

// v2 라우트 (새로운 기능 추가)
app.use('/api/v2/auth', authRoutesV2);
app.use('/api/v2/products', productRoutesV2);

코드 구조화 팁

1. 서비스 레이어 분리
비즈니스 로직을 컨트롤러에서 분리해서 재사용성을 높여:

// src/services/orderService.js
class OrderService {
  async createOrder(userId, orderData) {
    // 비즈니스 로직
  }
  
  async calculateTotal(items) {
    // 계산 로직
  }
}

module.exports = new OrderService();

// 컨트롤러에서 사용
const orderService = require('../services/orderService');

exports.createOrder = async (req, res) => {
  const order = await orderService.createOrder(req.user.id, req.body);
  res.json({ success: true, order });
};

2. 상수 관리
매직 넘버나 문자열을 상수로 관리해:

// src/constants/orderStatus.js
module.exports = {
  PENDING: 'pending',
  CONFIRMED: 'confirmed',
  PREPARING: 'preparing',
  SHIPPED: 'shipped',
  DELIVERED: 'delivered',
  CANCELLED: 'cancelled'
};

3. 유틸리티 함수
자주 사용하는 기능은 유틸리티로 만들어:

// src/utils/helpers.js
exports.generateOrderNumber = () => {
  const date = new Date();
  const dateStr = date.toISOString().slice(0, 10).replace(/-/g, '');
  const random = Math.floor(Math.random() * 10000).toString().padStart(4, '0');
  return `ORD${dateStr}${random}`;
};

exports.calculateDiscountRate = (price, discountPrice) => {
  if (!discountPrice || price <= discountPrice) return 0;
  return Math.round(((price - discountPrice) / price) * 100);
};

성능 모니터링

느린 쿼리를 찾아서 최적화하자:

// MongoDB 슬로우 쿼리 로깅
mongoose.set('debug', (collectionName, method, query, doc) => {
  logger.debug(`${collectionName}.${method}`, {
    query: JSON.stringify(query),
    doc: JSON.stringify(doc)
  });
});

🎓 학습 리소스와 다음 단계

여기까지 따라왔다면 정말 대단해! 🎉 이제 기본적인 쇼핑몰 API 서버를 만들 수 있을 거야.

추가로 구현하면 좋은 기능들

1. 리뷰 시스템
• 상품 리뷰 작성/수정/삭제
• 평점 계산 및 업데이트
• 리뷰 이미지 업로드

2. 위시리스트
• 찜하기 기능
• 위시리스트 관리
• 가격 변동 알림

3. 쿠폰 시스템
• 할인 쿠폰 발급
• 쿠폰 적용 및 검증
• 프로모션 관리

4. 실시간 알림
• Socket.io로 실시간 주문 상태 알림
• 재입고 알림
• 프로모션 푸시 알림

5. 결제 연동
• 아임포트, 토스페이먼츠 등 PG사 연동
• 결제 검증 및 처리
• 환불 처리

6. 이미지 업로드
• Multer로 파일 업로드
• AWS S3 연동
• 이미지 리사이징 (Sharp)

🎯 마무리하며

와, 정말 긴 여정이었지? 😅 Node.js와 Express로 쇼핑몰 API 서버를 만드는 과정을 처음부터 끝까지 살펴봤어.

우리가 다룬 내용을 정리해보면:
• Express 서버 기본 설정
• MongoDB 데이터 모델 설계
• JWT 기반 인증 시스템
• 상품, 장바구니, 주문 관리 API
• 입력값 검증과 에러 처리
• 성능 최적화와 보안
• 로깅, 테스트, 배포

이 모든 걸 한 번에 완벽하게 이해하기는 어려워. 천천히 하나씩 구현해보면서 익혀가면 돼! 💪

가장 중요한 건 직접 코드를 작성해보는 것이야. 이 글을 보면서 따라 만들어보고, 자신만의 기능을 추가해보고, 에러를 만나면 해결해보면서 실력이 늘어나는 거지.

백엔드 개발은 정말 매력적인 분야야. 사용자가 보지 못하는 곳에서 모든 걸 조율하고, 데이터를 안전하게 관리하고, 비즈니스 로직을 구현하는 거니까. 쇼핑몰 API 서버를 만들면서 배운 지식은 다른 프로젝트에도 충분히 응용할 수 있어!

혹시 막히는 부분이 있거나 더 깊이 배우고 싶다면, 공식 문서를 읽어보거나 커뮤니티에 질문해봐. 그리고 실전 경험이 있는 개발자에게 멘토링을 받는 것도 정말 큰 도움이 돼.

자, 이제 당신 차례야! 🚀 이 가이드를 참고해서 멋진 쇼핑몰 API 서버를 만들어보자. 화이팅! 💻✨

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.

카페24,고도몰등 쇼핑몰 솔루션 디자인 및 기능구현,코딩, 합리적인 가격으로 수정해드립니다.

재능인 5급 인증

10.6K

카페24,고도몰등 쇼핑몰 솔루션 디자인 및 기능구현,코딩, 합리적인 가격으로 수정해드립니다.

카페24,고도몰,퍼스트몰,메이크샵등의 쇼핑몰 솔루션을 운영하시는 분들 대상으로 레이아웃,코딩,기능구현등 궁금하신 점 무엇이든 문의 가능하세요~ 이런분들 문의주세요~^^ 1.카페24/고도몰등 통해 쇼핑몰은 구축했는데 기본틀에서 오도가도 못하신 분들~ 2.무료디자인 적용하셨는데 내가 생각했던 구도가 아니신 분들~ 3.고도홈즈,카페24 빌더호스팅으로 회사홈페이지

5,000원~

4.1K

[카페24,메이크샵,고도몰,영카트] 제작/수정/코딩 리뉴얼해 드립니다

안녕하세요 [카페24&메이크샵&영카트 쇼핑몰,그누보드,맞춤형파싱] 전문 웹퍼블리셔입니다. 위 솔루션으로 운영하면서 생기는 코딩,소스,어드민기능 등 문제들 모두 문의&의뢰하실수 있습니다~ 보유스킬은 HTML5, CSS3,BootStrap,Javascript(jQuery),PHP,쇼핑몰 제작 등등 입니다. 적용대상: 1.디자인은 있는데 코딩이나 프로그래밍에서

5,000원~

쇼핑몰 상품 가격 주문 엑셀 자동화 프로그램을 제작해 드립니다

[오픈 이벤트] 첫 후기 5분까지 기본 15,000원 (기존 50,000원) · 3일 완료 쇼핑몰 가격·주문 엑셀 자동화 프로그램 반복적으로 확인하는 상품 가격과 주문 정보를 정리할 수 있는 맞춤형 엑셀 자동화 파일을 제작합니다. 가능한 작업 제공된 파일 형식에 맞춘 상품·가격 정리 주문 내역을 발주용 표로 변환 상품코드·옵션·수량 기준 매칭 버튼 실행 방

15,000원~ 후기 0개

해외 온라인 쇼핑몰 쇼피파이 구축대행 / 컨설팅 / 페북샵 / 구글샵

이베이 / 쇼피 직접 운영하고 있습니다. 쇼피파이 직접 만들어서 운영중입니다. 실제 쇼핑몰을 운영하고 있기에 누구보다도 셀러의 요구사항을 잘 이해하고 눈높이를 맞출 수가 있습니다. 컨설팅만 받을 경우 실제 자신의 홈페이지에 적용방법을 따로 구상하는데 시간과 노력이 듭니다. 물론 컨설팅이나 교육 내용을 충분히 숙지하는 것도 쉽지 않구요. "주식비법을 공부한다

399,000원~ 후기 0개

450

첫 방문부터 구매로 이끄는 반응형 최적화 카페24 고도몰 아임웹 쇼핑몰 제작

쇼핑몰 제작이 처음이라 어려우신가요? 새롭게 달라진 상품 구성, 디자인을 원하시고 있나요? 이탈률을 줄이고 구매 전환율을 올리는 기획, 잠재 고객을 깨우는 쇼핑몰이 필요하신가요? 효율적인 판매와 성장에 필요한 기능/디자인을 모두 담아 상품과 운영을 편리하실 수 있도록 세팅 진행을 해드립니다. 위글 스튜디오는 대표님의 시간을 단축해 드리기 위하여 쇼핑몰 제작

100,000원~ 후기 0개

807

종합 렌탈 쇼핑몰 무한 분양 솔루션을 제작해 드립니다.

*렌탈 쇼핑몰 무한 분양 솔루션* [주요 기능 및 개발 지원 사항] ˙ 4,000여가지 상품 API 연동 상품 공급 업체와 별도 계약 및 별도 비용 ˙ 저렴하고 빠르고 정확한 렌탈 솔루션 ˙ 몇천만원 비싼 솔루션 말고 200만원대 저렴하게 이용 하세요 ˙ 기본 디자인으로 제작기간 1일 ˙ 디자인 추가 제작시 문의 *서비스 설명* 다양한 프로그램 솔루션을 판

3,500,000원~ 후기 0개

Shopee - 동남아 온라인 쇼핑몰 쇼피 입점 세팅 대행 및 컨설팅

글로벌 셀러로 활동하고 싶으신가요? 요즘 재테크가 트렌드로 떠오르고 있습니다. 그런데 국내 쇼핑몰은 이미 포화상태라서 엄두를 못내신다면 글로벌 셀러를 경험해 보세요. 부업으로도 가능합니다. 몇번 술먹고, 밥먹을 돈으로 쇼피 입점이 가능하고, 유지/관리도 부업으로 가능하게 할 수 있습니다. 시작이 반이라고 시작한다면 물질적인 재테크가 아닌 무형의 재테크가 될

200,000원~ 후기 0개

프로그램개발 · 분야 선택22개 분야

🛒 Node.js와 Express로 만드는 쇼핑몰 API 서버 완벽 가이드

🎯 왜 Node.js와 Express로 쇼핑몰 API를 만들까?

🛠️ 개발 환경 세팅하기

필수 도구 설치

프로젝트 구조 설계

🚀 기본 서버 구축하기

Express 서버 초기 설정

환경변수 설정

MongoDB 연결 설정

📦 데이터 모델 설계하기

User 모델 (회원 정보)

Product 모델 (상품 정보)

Order 모델 (주문 정보)

Cart 모델 (장바구니)

🔐 인증 시스템 구축하기

JWT 미들웨어 작성

인증 컨트롤러 작성

인증 라우트 설정

🛍️ 상품 관리 API 구축하기

상품 컨트롤러 작성

상품 라우트 설정

🛒 장바구니 API 구축하기

장바구니 컨트롤러 작성

장바구니 라우트 설정

📦 주문 처리 API 구축하기

주문 컨트롤러 작성

주문 라우트 설정

🔍 입력값 검증과 에러 처리

입력값 검증 미들웨어

전역 에러 핸들러

🚀 성능 최적화와 보안 강화

성능 최적화 기법

보안 강화 방법

📊 로깅과 모니터링

Winston으로 로깅 구현

Morgan으로 HTTP 요청 로깅

🧪 테스트 작성하기

테스트 환경 설정

API 테스트 예제

🚢 배포와 운영

환경 변수 설정

PM2로 프로세스 관리

Docker 컨테이너화

클라우드 배포 옵션

💡 실전 팁과 베스트 프랙티스

API 문서화

버전 관리

코드 구조화 팁

성능 모니터링

🎓 학습 리소스와 다음 단계

추가로 구현하면 좋은 기능들

추천 학습 자료

🎯 마무리하며

관련 키워드

댓글 작성

로그인이 필요합니다

댓글 0

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

해당 지식과 관련있는 인기재능

카페24,고도몰등 쇼핑몰 솔루션 디자인 및 기능구현,코딩, 합리적인 가격으로 수정해드립니다.

[카페24,메이크샵,고도몰,영카트] 제작/수정/코딩 리뉴얼해 드립니다

쇼핑몰 상품 가격 주문 엑셀 자동화 프로그램을 제작해 드립니다

해외 온라인 쇼핑몰 쇼피파이 구축대행 / 컨설팅 / 페북샵 / 구글샵

첫 방문부터 구매로 이끄는 반응형 최적화 카페24 고도몰 아임웹 쇼핑몰 제작

종합 렌탈 쇼핑몰 무한 분양 솔루션을 제작해 드립니다.

Shopee - 동남아 온라인 쇼핑몰 쇼피 입점 세팅 대행 및 컨설팅