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

Halo, selamat datang di Digimensia Blog. Kali ini kita akan belajar bagaiaman Metode Membikin REST API menggunakan Node.js, Express, Sequelize, dan MySQL.

Express adalah salah satu web framework Node.js yang banyak sekali digunakan Demi Membikin 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 Metode yang mudah Demi mengelola data yang Terdapat dalam database.

Sebelum mulai:

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

Apa Yang Akan Kita Buat?

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

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

Membikin Project Node.js

Membikin 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.Digimensia.com
license: (ISC)

Is this ok? (yes) yes

Setelah inisialisasi project maka akan Terdapat sebuah file package.json dalam folder project Anda 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.Digimensia.com",
  "license": "ISC"
}

Install modul yang diperlukan:

npm install express sequelize mysql2

Membikin Express Web Server

Langkah berikutnya kita akan Membikin 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 Membikin web server
Membikin aplikasi express, menambahkan middleware json parser dan urlencoded menggunakan method app.use()
Membikin 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, Lampau buka browser Anda pada url berikut:

http://127.0.0.1:3000/

Berikut ini adalah hasilnya di browser:

Membikin Konfigurasi

Dalam folder src, buat sebuah folder baru bernama configs Lampau 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 Anda ya.

Membikin 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 Membikin koneksi database menggunakan Sequelize berdasarkan konfigurasi database yang sebelumnya sudah kita buat.

READ: Web Marketing: Strategi Efektif Kepada Bisnis Online

Selanjutnya kita perbarui file app.js yang Terdapat 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 Terdapat 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 Membikin tabel yang sudah Terdapat di drop dan dibuat ulang. Dalam production mode, Anda harus merubahnya menjadi false agar data yang Terdapat di database Enggak hilang.

Membikin 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 Kitab yang nanti dibuat secara Mekanis di dalam database kita. Sequelize telah menyediakan operasi CRUD sehingga kita Enggak perlu membuatnya secara manual lagi. Beberpaa operasi yang disediakan adalah sebagai berikut:

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

Membikin 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 Membikin beberapa fungsi Adalah sebagai berikut:

create: Membikin data Kitab baru
all: Mendapatkan Segala data Kitab
find: Mendapatkan data Kitab berdasarkan id
update: Memperbarui data Kitab berdasarkan id
destroy: Menghapus data Kitab berdasarkan id

READ: Membikin Live Search Menggunakan Alpine.js

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 Anda Enggak Dapat hanya menggunakan browser ya. Anda Dapat menggunakan tool REST Client seperti Postman atau Enggak bisa tidur. Kebetulan pada tutorial ini saya menggunakan aplikasi Enggak bisa tidur.

READ: WordPress Kepada Pemula: Tips dan Plugin Krusial

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

Berikut ini adalah hasil pengujian saya menambahkan data Kitab

Mendapatkan Segala data Kitab

Mendapatkan data Kitab berdasarkan id

Memperbarui data Kitab berdasarkan id

Menghapus data Kitab berdasarkan id

(Tambahan) Menggunakan Middleware Demi Validasi Data

REST API Server kita sebenarnya sudah berfungsi sesuai rencana awal. Tetapi Tetap 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 Membikin satu buah middleware Demi melakukan validasi sederhana pada request body ketika Ingin menambahkan Kitab baru.

Membikin middleware di Express sangat mudah sekali, kita tinggal Membikin sebuah fungsi yang Mempunyai tiga buah parameter Adalah 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 Apabila Ingin meneruskan request ke middleware atau handler berikutnya. Apabila Enggak memanggil fungsi next maka Anda 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 Membikin validasai lainnya sehingga Segala endpoint Mempunyai validasai yang sesuai ya. Anda juga Dapat mencoba menggunakan library validasi yang banyak diemukan di npmjs.

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

Latest News