Membangun REST API dengan Node.js & Express: Dari Nol hingga Production

Di era modern web development, REST API menjadi tulang punggung komunikasi antara frontend dan backend. Baik kamu membangun aplikasi mobile, SPA (Single Page Application), atau integrasi layanan microservices, memahami cara membangun REST API yang solid adalah skill fundamental bagi setiap developer.

Dalam artikel ini, kita akan membangun REST API task management lengkap menggunakan Node.js dan Express.js dari inisialisasi project hingga siap deploy ke production.

---

1. Mengapa Node.js & Express untuk REST API?

Node.js unggul untuk membangun API karena beberapa alasan kunci:

• Non-blocking I/O: Cocok untuk menangani ribuan request bersamaan tanpa overhead thread
• Ekosistem NPM: Akses ke lebih dari 2 juta package untuk mempercepat development
• JavaScript Full-stack: Satu bahasa untuk frontend dan backend
• Express.js: Framework minimalis yang memberikan kebebasan penuh dalam arsitektur

Catatan: Express.js bukan satu-satunya pilihan. Framework seperti Fastify, Koa, dan Hono juga populer. Namun Express tetap menjadi standar industri dengan komunitas terbesar.

---

2. Setup Project dan Struktur Folder

Pertama, inisialisasi project dan install dependencies yang dibutuhkan:

mkdir task-api && cd task-api
npm init -y
npm install express cors helmet morgan dotenv express-validator
npm install -D nodemon

Struktur folder yang direkomendasikan mengikuti pola separation of concerns:

task-api/
├── src/
│   ├── controllers/     # Request handler logic
│   ├── middleware/       # Custom middleware (auth, validation, error)
│   ├── routes/           # Route definitions
│   ├── services/         # Business logic layer
│   ├── models/           # Data models / DB schemas
│   ├── utils/            # Helper functions
│   └── app.js            # Express app configuration
├── .env
├── .gitignore
├── package.json
└── server.js             # Entry point

---

3. Konfigurasi Express App

File app.js adalah jantung konfigurasi Express. Di sini kita mendaftarkan semua middleware dan routes:

// src/app.js
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const { errorHandler, notFound } = require('./middleware/errorMiddleware');
const taskRoutes = require('./routes/taskRoutes');

const app = express();

// Security & utility middleware
app.use(helmet());                          // Security headers
app.use(cors({ origin: process.env.CORS_ORIGIN || '*' }));
app.use(morgan('combined'));                // Request logging
app.use(express.json({ limit: '10kb' }));   // Body parser dengan limit
app.use(express.urlencoded({ extended: true }));

// Health check endpoint
app.get('/api/health', (req, res) => {
  res.json({ 
    status: 'OK', 
    timestamp: new Date().toISOString(),
    uptime: process.uptime() 
  });
});

// API Routes
app.use('/api/v1/tasks', taskRoutes);

// Error handling
app.use(notFound);
app.use(errorHandler);

module.exports = app;

Perhatikan beberapa best practice yang diterapkan:

• Helmet untuk mengamankan HTTP headers secara otomatis
• CORS dikonfigurasi dari environment variable
• Body parser limit mencegah payload terlalu besar (serangan DoS)
• API versioning (/api/v1/) untuk backward compatibility

---

4. Membuat Controller & Service Layer

Pisahkan request handling (controller) dari business logic (service) agar kode lebih testable:

Service Layer Business Logic

// src/services/taskService.js
let tasks = [];
let idCounter = 1;

class TaskService {
  getAll(filters = {}) {
    let result = [...tasks];

    if (filters.status) {
      result = result.filter(t => t.status === filters.status);
    }
    if (filters.search) {
      const query = filters.search.toLowerCase();
      result = result.filter(t => 
        t.title.toLowerCase().includes(query)
      );
    }

    return result;
  }

  getById(id) {
    const task = tasks.find(t => t.id === id);
    if (!task) throw new AppError('Task tidak ditemukan', 404);
    return task;
  }

  create(data) {
    const newTask = {
      id: idCounter++,
      title: data.title,
      description: data.description || '',
      status: 'pending',
      priority: data.priority || 'medium',
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };
    tasks.push(newTask);
    return newTask;
  }

  update(id, data) {
    const task = this.getById(id);
    Object.assign(task, {
      ...data,
      updatedAt: new Date().toISOString(),
    });
    return task;
  }

  delete(id) {
    const index = tasks.findIndex(t => t.id === id);
    if (index === -1) throw new AppError('Task tidak ditemukan', 404);
    tasks.splice(index, 1);
    return { message: 'Task berhasil dihapus' };
  }
}

module.exports = new TaskService();

Controller Request Handler

// src/controllers/taskController.js
const taskService = require('../services/taskService');
const { asyncHandler } = require('../utils/asyncHandler');

exports.getAllTasks = asyncHandler(async (req, res) => {
  const { status, search } = req.query;
  const tasks = taskService.getAll({ status, search });

  res.json({
    success: true,
    count: tasks.length,
    data: tasks,
  });
});

exports.getTask = asyncHandler(async (req, res) => {
  const task = taskService.getById(Number(req.params.id));
  res.json({ success: true, data: task });
});

exports.createTask = asyncHandler(async (req, res) => {
  const task = taskService.create(req.body);
  res.status(201).json({ success: true, data: task });
});

exports.updateTask = asyncHandler(async (req, res) => {
  const task = taskService.update(Number(req.params.id), req.body);
  res.json({ success: true, data: task });
});

exports.deleteTask = asyncHandler(async (req, res) => {
  const result = taskService.delete(Number(req.params.id));
  res.json({ success: true, ...result });
});

---

5. Validation & Error Handling

Input validation sangat krusial untuk mencegah data tidak valid masuk ke sistem. Gunakan express-validator untuk deklaratif validation:

// src/middleware/validators.js
const { body, param, validationResult } = require('express-validator');

const handleValidation = (req, res, next) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({
      success: false,
      errors: errors.array().map(err => ({
        field: err.path,
        message: err.msg,
      })),
    });
  }
  next();
};

exports.validateCreateTask = [
  body('title')
    .trim()
    .notEmpty().withMessage('Title wajib diisi')
    .isLength({ min: 3, max: 100 })
    .withMessage('Title harus 3-100 karakter'),
  body('priority')
    .optional()
    .isIn(['low', 'medium', 'high'])
    .withMessage('Priority harus: low, medium, atau high'),
  body('description')
    .optional()
    .isLength({ max: 500 })
    .withMessage('Deskripsi maksimal 500 karakter'),
  handleValidation,
];

exports.validateIdParam = [
  param('id')
    .isInt({ min: 1 })
    .withMessage('ID harus berupa angka positif'),
  handleValidation,
];

Untuk error handling global, buat custom error class dan middleware:

// src/middleware/errorMiddleware.js
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true;
  }
}

const notFound = (req, res, next) => {
  const error = new AppError(
    `Endpoint ${req.method} ${req.originalUrl} tidak ditemukan`, 
    404
  );
  next(error);
};

const errorHandler = (err, req, res, next) => {
  const statusCode = err.statusCode || 500;
  const message = err.isOperational 
    ? err.message 
    : 'Terjadi kesalahan internal server';

  console.error(`[ERROR] ${statusCode}: ${err.message}`);

  res.status(statusCode).json({
    success: false,
    error: message,
    ...(process.env.NODE_ENV === 'development' && { 
      stack: err.stack 
    }),
  });
};

module.exports = { AppError, notFound, errorHandler };

---

6. Route Definitions

Gabungkan semua controller dan validator ke dalam router:

// src/routes/taskRoutes.js
const { Router } = require('express');
const taskController = require('../controllers/taskController');
const { validateCreateTask, validateIdParam } = require('../middleware/validators');

const router = Router();

router.route('/')
  .get(taskController.getAllTasks)
  .post(validateCreateTask, taskController.createTask);

router.route('/:id')
  .get(validateIdParam, taskController.getTask)
  .put(validateIdParam, validateCreateTask, taskController.updateTask)
  .delete(validateIdParam, taskController.deleteTask);

module.exports = router;

Tips: Gunakan router.route() untuk mengelompokkan HTTP method pada path yang sama. Ini membuat kode lebih bersih dan mudah dibaca dibanding menulis router.get(), router.post() satu per satu.

---

7. Tips Production-Ready

Sebelum deploy, pastikan API kamu sudah menerapkan checklist berikut:

1. Rate Limiting Gunakan express-rate-limit untuk mencegah abuse
2. Compression Aktifkan gzip/brotli response dengan compression
3. Environment Variables Jangan hardcode secrets, gunakan .env
4. Graceful Shutdown Handle SIGTERM signal untuk menutup koneksi DB dengan benar
5. Logging Gunakan structured logging dengan winston atau pino

// server.js   Graceful shutdown
const app = require('./src/app');
const PORT = process.env.PORT || 3000;

const server = app.listen(PORT, () => {
  console.log(`🚀 Server berjalan di port ${PORT}`);
});

process.on('SIGTERM', () => {
  console.log('SIGTERM diterima. Menutup server...');
  server.close(() => {
    console.log('Server ditutup dengan aman');
    process.exit(0);
  });
});

---

Kesimpulan

Membangun REST API dengan Node.js dan Express tidak harus rumit, tetapi perlu disiplin dalam arsitektur. Dengan memisahkan tanggung jawab ke dalam controller, service, dan middleware, kamu mendapatkan codebase yang mudah di-test, di-maintain, dan di-scale.

Pola yang kita bahas di artikel ini mulai dari layered architecture, input validation, centralized error handling, hingga graceful shutdown merupakan fondasi yang digunakan di banyak production API di industri. Selanjutnya, kamu bisa mengintegrasikan database (PostgreSQL/MongoDB), authentication (JWT/OAuth), dan automated testing untuk membangun API yang benar-benar production-grade.