Apakah Anda siap untuk merevolusi cara Anda membangun API? Jika Anda sudah lama berkecimpung di dunia pengembangan, Anda mungkin pernah mendengar tentang GraphQL, Node.js, dan Express. Bersama-sama, teknologi ini menciptakan perangkat yang ampuh untuk membangun API modern dan efisien. Hari ini, kita akan menyelami dunia GraphQL dengan Node.js dan Express untuk membantu Anda memahami dan menerapkan kombinasi ini dalam proyek Anda.
Namun pertama-tama, izinkan saya memperkenalkan Anda pada alat yang akan membuat pengembangan API Anda semakin lancar: Apidog. Apidog adalah alat pengujian dan manajemen API gratis yang terintegrasi dengan mulus dengan GraphQL, Node.js, dan Express. Jika Anda ingin menyederhanakan proses pengembangan API Anda, unduh Apidog secara gratis dan lihat perbedaannya!
Pengantar GraphQL, Node.js, dan Express
Apa itu GraphQL?
GraphQL adalah bahasa kueri untuk API Anda, dan runtime sisi server untuk menjalankan kueri dengan menggunakan sistem tipe yang Anda tentukan untuk data Anda. Dikembangkan oleh Facebook, ini menyediakan alternatif yang lebih efisien, kuat, dan fleksibel untuk REST. Dengan GraphQL, Anda dapat meminta data yang Anda butuhkan, menghindari pengambilan data berlebihan atau kekurangan.
Apa itu Node.js?
Node.js adalah runtime JavaScript yang dibangun di atas mesin V8 JavaScript milik Chrome. Ini memungkinkan pengembang untuk membangun aplikasi jaringan yang dapat diskalakan menggunakan JavaScript di sisi server. Node.js dikenal karena model I/O non-pemblokiran berbasis peristiwa yang membuatnya ringan dan efisien.
Apa itu Express?
Express adalah kerangka kerja aplikasi web Node.js yang minimal dan fleksibel yang menyediakan serangkaian fitur yang kuat untuk mengembangkan aplikasi web dan seluler. Ini memfasilitasi pengembangan cepat aplikasi web berbasis Node dan sering digunakan sebagai tulang punggung untuk membangun API RESTful.
Menyiapkan Lingkungan Pengembangan Anda
Sebelum kita mulai membangun API kita, mari siapkan lingkungan pengembangan kita. Inilah yang Anda butuhkan:
- Node.js dan npm (Node Package Manager) terinstal
- Editor kode (seperti Visual Studio Code)
- Terminal atau command prompt
Menginstal Node.js dan npm
Unduh dan instal Node.js dari situs web Node.js resmi. npm sudah termasuk dalam Node.js, jadi Anda tidak perlu menginstalnya secara terpisah.
Menginisialisasi Proyek Node.js Baru
Buka terminal Anda dan buat direktori baru untuk proyek Anda. Navigasikan ke direktori proyek Anda dan jalankan perintah berikut untuk menginisialisasi proyek Node.js baru:
npm init -y
Perintah ini akan membuat file package.json di direktori proyek Anda.
Membuat Server Express Dasar
Sekarang proyek kita sudah diatur, mari buat server Express dasar.
Menginstal Express
Jalankan perintah berikut untuk menginstal Express:
npm install express
Membuat Server
Buat file baru bernama server.js dan tambahkan kode berikut:
const express = require('express');
const app = express();
const PORT = process.env.PORT || 4000;
app.get('/', (req, res) => {
res.send('Hello World!');
});
app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}`);
});
Kode ini menyiapkan server Express dasar yang mendengarkan di port 4000 dan merespons dengan "Hello World!" ketika diakses di URL root.
Untuk memulai server, jalankan:
node server.js
Kunjungi http://localhost:4000 di browser Anda untuk melihat pesan "Hello World!".
Mengintegrasikan GraphQL dengan Express
Dengan server dasar kita yang sudah berjalan, sekarang saatnya untuk mengintegrasikan GraphQL.
Menginstal GraphQL dan Apollo Server
Apollo Server adalah server GraphQL sumber terbuka yang dikelola komunitas yang kompatibel dengan klien GraphQL mana pun. Kita akan menggunakannya untuk menangani permintaan GraphQL kita.
Instal Apollo Server dan GraphQL:
npm install apollo-server-express graphql
Menyiapkan Apollo Server
Modifikasi server.js untuk menyiapkan Apollo Server dengan Express:
const express = require('express');
const { ApolloServer, gql } = require('apollo-server-express');
const app = express();
const PORT = process.env.PORT || 4000;
// Define the schema
const typeDefs = gql`
type Query {
hello: String
}
`;
// Define the resolvers
const resolvers = {
Query: {
hello: () => 'Hello World!',
},
};
// Create an instance of ApolloServer
const server = new ApolloServer({ typeDefs, resolvers });
// Apply middleware to connect ApolloServer with Express
server.applyMiddleware({ app });
app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}${server.graphqlPath}`);
});
Kode ini menyiapkan Apollo Server dasar dengan satu kueri hello yang mengembalikan "Hello World!".
Mendefinisikan Skema dan Resolver GraphQL
Sekarang kita memiliki server GraphQL dasar yang berjalan, mari selami lebih dalam skema dan resolver.
Apa itu Skema?
Skema GraphQL mendefinisikan tipe dan hubungan dalam API Anda. Ini menjelaskan kueri apa yang dapat dibuat dan data apa yang dapat diambil.
Apa itu Resolver?
Resolver adalah fungsi yang menangani pengambilan data untuk bidang tertentu dalam skema Anda. Mereka memberi tahu GraphQL cara mendapatkan data untuk setiap kueri.
Mendefinisikan Skema yang Lebih Kompleks
Perluas typeDefs dan resolvers Anda di server.js:
const typeDefs = gql`
type Book {
title: String
author: String
}
type Query {
books: [Book]
}
`;
const books = [
{
title: 'The Awakening',
author: 'Kate Chopin',
},
{
title: 'City of Glass',
author: 'Paul Auster',
},
];
const resolvers = {
Query: {
books: () => books,
},
};
Skema ini mendefinisikan tipe Book dan kueri books yang mengembalikan daftar buku.
Menghubungkan ke Database
Untuk aplikasi dunia nyata, Anda perlu menghubungkan API Anda ke database. Mari gunakan MongoDB untuk contoh ini.
Menyiapkan MongoDB
Daftar untuk akun MongoDB Atlas gratis atau siapkan instance MongoDB lokal. Kemudian, instal mongoose untuk berinteraksi dengan MongoDB dari Node.js:
npm install mongoose
Menghubungkan ke MongoDB
Modifikasi server.js untuk terhubung ke MongoDB:
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/graphql', {
useNewUrlParser: true,
useUnifiedTopology: true,
});
const db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', () => {
console.log('Connected to MongoDB');
});
// Define a Mongoose schema and model
const bookSchema = new mongoose.Schema({
title: String,
author: String,
});
const Book = mongoose.model('Book', bookSchema);
// Modify the resolver to fetch data from MongoDB
const resolvers = {
Query: {
books: async () => await Book.find(),
},
};
Sekarang, kueri books mengambil data dari MongoDB.
Mengoptimalkan API GraphQL Anda
Untuk memastikan API GraphQL Anda efisien dan berkinerja tinggi, pertimbangkan teknik optimasi berikut:
DataLoader untuk Pemuatan Batch yang Efisien
DataLoader adalah utilitas untuk membuat batch dan menyimpan cache pengambilan data. Ini membantu mengurangi jumlah permintaan database.
Instal DataLoader:
npm install dataloader
Gunakan DataLoader di resolver Anda:
const DataLoader = require('dataloader');
const bookLoader = new DataLoader(async (keys) => {
const books = await Book.find({ _id: { $in: keys } });
return keys.map((key) => books.find((book) => book.id === key));
});
const resolvers = {
Query: {
books: async () => await bookLoader.loadAll(),
},
};
Caching
Terapkan strategi caching untuk menghindari pengambilan data yang berlebihan. Anda dapat menggunakan cache dalam memori seperti Redis untuk menyimpan data yang sering diminta.
Pagination
Untuk kueri yang mengembalikan dataset besar, terapkan pagination untuk mengambil data dalam potongan. Gunakan parameter limit dan skip untuk memaginasi hasil.
Menguji API Anda dengan Apidog
Menguji API Anda sangat penting untuk memastikan API berfungsi seperti yang diharapkan. Apidog menyederhanakan proses ini dengan antarmuka intuitif dan fitur-fitur canggihnya.
Langkah 1: Buka Apidog dan buat permintaan baru.
Langkah 2: Temukan atau masukkan secara manual detail API untuk permintaan POST yang ingin Anda buat.
Langkah 3: Isi parameter yang diperlukan dan data apa pun yang ingin Anda sertakan dalam badan permintaan.
Dengan mengintegrasikan Apidog ke dalam alur kerja Anda, Anda dapat menghemat waktu dan menghindari kesalahan umum dalam pengembangan API. Selain itu, gratis untuk diunduh dan digunakan!
Apidog dengan GraphQL Anda
Setelah Anda menginstal Apidog, Anda dapat mengimpor skema GraphQL Anda untuk mengelola dan menguji API Anda dengan lebih efisien. Navigasikan ke bagian impor di Apidog dan unggah file schema.graphqls Anda.
​Masukkan kueri Anda di kotak Query pada tab "Run". Anda juga dapat mengklik tombol Fetch Schema manual di kotak input untuk mengaktifkan fitur "penyelesaian kode" untuk ekspresi Query, membantu dalam memasukkan pernyataan Query.
Dengan skema Anda yang diimpor, Anda dapat menggunakan Apidog untuk menguji kueri dan mutasi Anda, menghasilkan dokumentasi, dan bahkan mengejek respons. Ini akan membantu Anda memastikan API Anda berfungsi seperti yang diharapkan dan memberikan panduan komprehensif untuk pengguna API Anda.
Gunakan fitur pengujian otomatis Apidog untuk menjalankan kasus pengujian Anda sesuai jadwal. Ini membantu menangkap masalah apa pun sejak dini dan memastikan API Anda tetap andal.
Praktik Terbaik untuk Membangun API
Membangun API yang kuat dan dapat diskalakan membutuhkan mengikuti praktik terbaik. Berikut adalah beberapa tips utama:
Gunakan Pesan Kesalahan Deskriptif
Pastikan API Anda mengembalikan pesan kesalahan yang bermakna untuk membantu klien memahami apa yang salah.
Amankan API Anda
Terapkan mekanisme otentikasi dan otorisasi untuk melindungi API Anda dari akses yang tidak sah.
Dokumentasikan API Anda
Berikan dokumentasi yang jelas dan komprehensif untuk API Anda. Alat seperti Swagger dan GraphQL Playground dapat membantu menghasilkan dokumentasi interaktif.
Pantau Kinerja
Gunakan alat pemantauan untuk melacak kinerja API Anda. Identifikasi dan selesaikan hambatan kinerja dengan segera.
Jaga Kode Anda Tetap Terorganisir
Ikuti struktur kode dan konvensi penamaan yang konsisten untuk menjaga kode Anda tetap bersih dan mudah dipelihara.
Kesimpulan
Selamat! Anda telah mempelajari cara membangun API GraphQL yang kuat dengan Node.js dan Express. Kami telah membahas semuanya mulai dari menyiapkan lingkungan pengembangan Anda hingga mendefinisikan skema dan resolver, menghubungkan ke database, mengoptimalkan API Anda, dan mengujinya dengan Apidog.
Ingat, membangun API yang hebat adalah proses yang berkelanjutan. Terus asah keterampilan Anda, tetap perbarui dengan perkembangan terbaru dalam ekosistem GraphQL, dan terus bereksperimen dengan alat dan teknik baru.
