Node.js REST API Menggunakan Express, Sequelize, dan MySQL

Halo, selamat datang di Sandi Dharma Blog. Kali ini kita akan belajar bagaiaman Langkah Membangun REST API menggunakan Node.js, Express, Sequelize, dan MySQL.

Express adalah salah satu web framework Node.js yang banyak sekali digunakan Demi Membangun API server. Express mendukung routing, middleware, dan view system. Sequelize adalah ORM berbasis promise di Node.js yang mendukung Postgres, MySQL, SQL Server. Sequelize menyediakan Langkah yang mudah Demi mengelola data yang Eksis dalam database.

Sebelum mulai:

Pastikan Engkau sudah menginstall dan menjalankan MySQL server di komputer Engkau.
Pastikan Engkau sudah menginstall Node.js di komputer Engkau.
Pastikan Engkau sudah mengerti atau setidaknya pernah belajar bagaimana Langkah menggunakan database MySQL
Pastikan Engkau sudah mengerti atau setidaknya pernah belajar pemrogramman menggunakan javascript dan Node.js.
Pastikan Engkau sudah mengerti atau setidaknya pernah belajar tentang REST API

Apa Yang Akan Kita Buat?

Pada tutorial ini kita akan Membangun sebuah REST API server sederhana Demi mengelola data Naskah. Adapun beberapa endpoint yang akan kita buat adalah sebagai berikut:

Metode	Endpoint	Aksi
POST	`/api/books`	Menambah data Naskah
GET	`/api/books`	Mendapatkan Segala data Naskah
GET	`/api/books/:id`	Mendapatkan data Naskah berdasarkan id
PUT	`/api/books/:id`	Memperbarui data Naskah berdasarkan id
DELETE	`/api/books/:id`	Menghapus data Naskah berdasrkan id

Membangun Project Node.js

Membangun folder project:

mkdir node-book-api
cd node-book-api

Inisialisasi project Node.js

npm init

package name: (book-api)
version: (1.0.0)
description: Node.js Book REST API with Express, Sequelize, and MySQL
entry point: (index.js) ./src/app.js
test command:
git repository:
keywords: Node.js, Express, Sequelize, MySQL, REST, API
author: www.sandidharma.ac.id
license: (ISC)

Is this ok? (yes) yes

Setelah inisialisasi project maka akan Eksis sebuah file package.json dalam folder project Engkau yang terlihat kurang lebih seperti ini:

{
  "name": "book-api",
  "version": "1.0.0",
  "description": "Node.js Book REST API with Express, Sequelize, and MySQL",
  "main": "./src/app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": ["Node.js", "Express", "Sequelize", "MySQL", "REST", "API"],
  "author": "www.sandidharma.ac.id",
  "license": "ISC"
}

Install modul yang diperlukan:

npm install express sequelize mysql2

Membangun Express Web Server

Langkah berikutnya kita akan Membangun web server menggunakan Express. Pada root folder, buatlah sebuah folder bernama src dan di dalamnya buatlah file bernama app.js

Isi file app.js kurang lebih seperti ini:

const express = require("express");

const app = express();
const port = process.env.PORT || 3000;

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

app.get("/", (req, res) => {
  res.json({
    message: "Node.js Book REST API Server",
  });
});

app.listen(port, () => console.log(`Server up and running on port ${port}`));

Yang kita lakukan pada file tersebut adalah:

Import modul express yang akan kita gunakan Demi Membangun web server
Membangun aplikasi express, menambahkan middleware json parser dan urlencoded menggunakan method app.use()
Membangun route Demi root url menggunakan method app.get() Demi uji coba
Listen port 3000 Demi request yang masuk

Mari kita coba jalankan aplikasi menggunakan perintah node /src/app.js di terminal, Lewat buka browser Engkau pada url berikut:

http://127.0.0.1:3000/

Berikut ini adalah hasilnya di browser:

Membangun Konfigurasi

Dalam folder src, buat sebuah folder baru bernama configs Lewat di dalamnya buat file bernama database.config.js yang berisi kode seperti berikut ini:

module.exports = {
  HOST: "localhost",
  USER: "root",
  PASSWORD: "root",
  DB: "book_api",
  DIALECT: "mysql",
};

Sesuaikan HOST, USER, PASSWORD, dan DB dengan konfigurasi database Engkau ya.

Membangun Koneksi Database

Dalam folder src buatlah sebuah folder baru bernama database kemudian didalamnya buatlah sebuah file bernama index.js yang berisi kode seperti berikut ini:

const { Sequelize } = require("sequelize");
const {
  DB,
  USER,
  PASSWORD,
  HOST,
  DIALECT,
} = require("../configs/database.config");

const database = new Sequelize(DB, USER, PASSWORD, {
  host: HOST,
  dialect: DIALECT,
});

module.exports = database;

Pada file tersebut kita Membangun koneksi database menggunakan Sequelize berdasarkan konfigurasi database yang sebelumnya sudah kita buat.

READ Pengertian, Tujuan, Proses, & Manfaat

Selanjutnya kita perbarui file app.js yang Eksis di dalam folder src.
Tambahkan kode berikut:

// import model
const database = require("./database");

database
  .sync({ force: true })
  .then(() => {
    console.info("database synced");
  })
  .catch((err) => {
    console.error("failed to sync database: " + err.message);
  });

Fungsi dari kode ini adalah melakukan sinkronisasi tabel yang Eksis dalam database kita agar sesuai dengan skema model yang nantinya kita buat.

Seluruh file app.js akan menjadi seperti berikut:

const express = require("express");
const database = require("./database");

const app = express();
const port = process.env.PORT || 3000;

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

database
  .sync({ force: true })
  .then(() => {
    console.info("database synced");
  })
  .catch((err) => {
    console.error("failed to sync database: " + err.message);
  });

app.get("/", (req, res) => {
  res.json({
    message: "Node.js Book REST API Server",
  });
});

app.listen(port, () => console.log(`Server up and running on port ${port}`));

Perhatikan bahwa kode { force: true } akan Membangun tabel yang sudah Eksis di drop dan dibuat ulang. Dalam production mode, Engkau harus merubahnya menjadi false agar data yang Eksis di database Enggak hilang.

Membangun Model

Dalam folder src buatlah sebuah folder baru bernama models kemudian di dalamnya buatlah sebuah file bernama book.model.js yang berisi kode seperti berikut ini:

const { DataTypes } = require("sequelize");
const database = require("../database");

const Book = database.define("book", {
  title: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  author: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  summary: {
    type: DataTypes.TEXT,
    allowNull: false,
  },
  publisher: {
    type: DataTypes.STRING,
    allowNull: false,
  },
});

module.exports = Book;

Book model ini merepresentasikan tabel Naskah yang nanti dibuat secara Mekanis di dalam database kita. Sequelize telah menyediakan operasi CRUD sehingga kita Enggak perlu membuatnya secara manual Tengah. Beberpaa operasi yang disediakan adalah sebagai berikut:

Membangun data Naskah: create(object)
Mendapatkan Segala data Naskah: findAll()
Mendapatkan data Naskah berdasarkan id: findOne({where: {id:id}})
Memperbarui data Naskah berdasarkan id: update(data, where: {id:id})
Menghapus data Naskah berdasarkan id: destroy(where: {id:id})

Membangun Controller

Dalam folder src bualah sebuah folder baru bernama controllers dan di dalamnya buat file baru bernama book.controller.js yang berisi kode berikut:

const Book = require("../models/book.model");

exports.create = async (req, res) => {
  try {
    const { title, author, summary, publisher } = req.body;

    const book = await Book.create({
      title,
      author,
      summary,
      publisher,
    });

    return res.status(201).json({
      status: 201,
      success: true,
      message: "new book created",
      data: {
        book: book,
      },
      error: null,
    });
  } catch (error) {
    console.error(error);
    return res.status(500).json({
      status: 500,
      success: false,
      message: "internal server error",
      data: null,
      error: "Internal Server Error",
    });
  }
};

exports.all = async (req, res) => {
  try {
    const books = await Book.findAll();
    return res.status(200).json({
      status: 200,
      success: true,
      message: "ok",
      data: {
        books,
      },
      error: null,
    });
  } catch (error) {
    console.error(error);
    return res.status(500).json({
      status: 500,
      success: false,
      message: "internal server error",
      data: null,
      error: "Internal Server Error",
    });
  }
};

exports.find = async (req, res) => {
  try {
    const { id } = req.params;
    const book = await Book.findOne({
      where: {
        id: id,
      },
    });

    if (!book) {
      return res.status(404).json({
        status: 404,
        success: false,
        message: "book not found",
        data: null,
        error: "Book Not Found",
      });
    }

    return res.status(200).json({
      status: 200,
      success: true,
      message: "ok",
      data: {
        book: book,
      },
      error: null,
    });
  } catch (error) {
    console.error(error);
    return res.status(500).json({
      status: 500,
      success: false,
      message: "internal server error",
      data: null,
      error: "Internal Server Error",
    });
  }
};

exports.update = async (req, res) => {
  try {
    const { id } = req.params;

    const updated = await Book.update(req.body, {
      where: {
        id: id,
      },
    });

    if (!updated[0]) {
      return res.status(200).json({
        status: 200,
        success: false,
        message: "failed to update book",
        data: null,
        error: "Failed To Update Book",
      });
    }

    return res.status(200).json({
      status: 200,
      success: true,
      message: "book updated",
      data: null,
      error: null,
    });
  } catch (error) {
    console.error(error);
    return res.status(500).json({
      status: 500,
      success: false,
      message: "internal server error",
      data: null,
      error: "Internal Server Error",
    });
  }
};

exports.destroy = async (req, res) => {
  try {
    const { id } = req.params;

    const destroyed = await Book.destroy({
      where: {
        id: id,
      },
    });

    if (!destroyed) {
      return res.status(200).json({
        status: 200,
        success: false,
        message: "failed to delete book",
        data: null,
        error: "Failed To Delete Book",
      });
    }

    return res.status(200).json({
      status: 200,
      success: true,
      message: "book deleted",
      data: null,
      error: null,
    });
  } catch (error) {
    console.error(error);
    return res.status(500).json({
      status: 500,
      success: false,
      message: "internal server error",
      data: null,
      error: "Internal Server Error",
    });
  }
};

Dalam file controller tersebut kita Membangun beberapa fungsi Yakni sebagai berikut:

create: Membangun data Naskah baru
all: Mendapatkan Segala data Naskah
find: Mendapatkan data Naskah berdasarkan id
update: Memperbarui data Naskah berdasarkan id
destroy: Menghapus data Naskah berdasarkan id

READ Mengenal Pengertian Mind Mapping, Teladan dan Manfaatnya

Mendefinisikan Route

Dalam folder src buatlah sebuah folder baru bernama routes kemudian di dalamnya buat sebuah file bernama book.route.js yang berisi kode seperti berikut ini:

const router = require("express").Router();

const {
  all,
  find,
  create,
  update,
  destroy,
} = require("../controllers/book.controller");

router.post("/", create);
router.get("/", all);
router.get("/:id", find);
router.put("/:id", update);
router.delete("/:id", destroy);

module.exports = router;

Pada kode tersebut kita mendefinisikan beberapa endpoint yang sebelumnya Ingin kita buat.

Menambahkan Route Ke Express Server

Buka kembali file app.js dalam folder src kemudian tambahkan kode berikut ini:

// import book route
const bookRoute = require("./routes/book.route");

// tambahkan book route ke dalam aplikasi
app.use("/api/books", bookRoute);

Sekarang file app.js kita akan terlihat seperti berikut ini:

const express = require("express");
const database = require("./database");
const bookRoute = require("./routes/book.route");

const app = express();
const port = process.env.PORT || 3000;

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

database
  .sync({ force: true })
  .then(() => {
    console.info("database synced");
  })
  .catch((err) => {
    console.error("failed to sync database: " + err.message);
  });

app.get("/", (req, res) => {
  res.json({
    message: "Node.js Book REST API Server",
  });
});

app.use("/api/books", bookRoute);

app.listen(port, () => console.log(`Server up and running on port ${port}`));

Menguji REST API

Setelah semuanya selesai, saatnya kita menguji aplikasi kita. Demi menguji rest api Engkau Enggak Bisa hanya menggunakan browser ya. Engkau Bisa menggunakan tool REST Client seperti Postman atau Susah tidur. Kebetulan pada tutorial ini saya menggunakan aplikasi Susah tidur.

READ Definisi, Fungsi dan Langkah Kerjanya

Sebelum melakukan pengujian, pastikan server MySQL Engkau sudah aktifkan dan aplikasi sudah dijalankan.

Berikut ini adalah hasil pengujian saya menambahkan data Naskah

Mendapatkan Segala data Naskah

Mendapatkan data Naskah berdasarkan id

Memperbarui data Naskah berdasarkan id

Menghapus data Naskah berdasarkan id

(Tambahan) Menggunakan Middleware Demi Validasi Data

REST API Server kita sebenarnya sudah berfungsi sesuai rencana awal. Tetapi Lagi banyak yang belum kita selesaikan, salah satunya adalah validasi data yang diterima. Pada bagian ini dicontohkan bagaimana caranya menggunakan middleware Demi validasai data.

Kembali ke project, dalam folder src buatlah satu buah folder baru bernama middlewares dan didalamnya buatlah sebuah file baru bernama validation.middleware.js yang isinya seperti berikut ini:

exports.createBookValidation = (req, res, next) => {
  const { title, author, summary, publisher } = req.body;

  if (title === undefined || title == "") {
    return res.status(400).json({
      status: 400,
      success: false,
      message: "bad request",
      data: {
        original: req.body,
      },
      error: "Title field is required",
    });
  }

  if (author === undefined || author == "") {
    return res.status(400).json({
      status: 400,
      success: false,
      message: "bad request",
      data: {
        original: req.body,
      },
      error: "Author field is required",
    });
  }

  if (summary === undefined || summary == "") {
    return res.status(400).json({
      status: 400,
      success: false,
      message: "bad request",
      data: {
        original: req.body,
      },
      error: "Summary field is required",
    });
  }

  if (publisher === undefined || publisher == "") {
    return res.status(400).json({
      status: 400,
      success: false,
      message: "bad request",
      data: {
        original: req.body,
      },
      error: "Publisher field is required",
    });
  }

  next();
};

Dalam file tersebut kita Membangun satu buah middleware Demi melakukan validasi sederhana pada request body ketika Ingin menambahkan Naskah baru.

Membangun middleware di Express sangat mudah sekali, kita tinggal Membangun sebuah fungsi yang Mempunyai tiga buah parameter Yakni req, res, dan next. req adalah request object yang diterima, res adalah response object yang akan dikirimkan, dan next adalah sebuah fungsi yang harus kita panggil Kalau Ingin meneruskan request ke middleware atau handler berikutnya. Kalau Enggak memanggil fungsi next maka Engkau harus mengirimkan response pada dari middleware tersebut agar server Enggak hang.

Oke, langkah selanjutnya adalah menambahkan middleware ini pada route kita. Buka file book.route.js kemudian modifikasi route Demi create book menjadi seperti berikut ini:

router.post("/", createBookValidation, create);

Jangan lupa import middleware-nya.

const {
  createBookValidation,
} = require("../middlewares/validation.middleware");

File route kita sekarang menjadi seperti ini:

const router = require("express").Router();

const {
  all,
  find,
  create,
  update,
  destroy,
} = require("../controllers/book.controller");
const {
  createBookValidation,
} = require("../middlewares/validation.middleware");

router.post("/", createBookValidation, create);
router.get("/", all);
router.get("/:id", find);
router.put("/:id", update);
router.delete("/:id", destroy);

module.exports = router;

Langkah selanjutnya, jalankan kembali aplikasi, dan cobalah Demi mengirimkan post request tanpa mengirim body apapun. Maka respoonse yang didapatkan akan seperti ini:

{
  "status": 400,
  "success": false,
  "message": "bad request",
  "data": {
    "original": {}
  },
  "error": "Title field is required"
}

Response tersebut dikirimkan oleh middleware kita karena validasi gagal.

Silahkan bereksperimen Demi Membangun validasai lainnya sehingga Segala endpoint Mempunyai validasai yang sesuai ya. Engkau juga Bisa mencoba menggunakan library validasi yang banyak diemukan di npmjs.

Source Code:
Source code Demi tutorial ini dapat Engkau lihat di sini