Menggunakan NestJS dan MongoDB untuk Membangun API GraphQL

GraphQL dan NestJS membuat kemitraan yang sangat baik, memberi Anda dasar yang kuat untuk API Anda dan kerangka kerja yang mudah digunakan untuk membangun aplikasi web yang dapat diskalakan. Kombinasi ini sempurna untuk membuat aplikasi siap produksi, dan keduanya merupakan alat yang sangat relevan dalam ekosistem teknologi saat ini.

Cari tahu lebih lanjut tentang cara membuat API menggunakan kedua produk.

Apa itu GraphQL?

GraphQL adalah permintaan data dan bahasa manipulasi dapat Anda gunakan untuk membangun API dengan cara yang lebih tepat dan ringkas. GraphQL memberikan deskripsi lengkap dan memadai tentang data yang ada di API dan memberikan kekuatan kepada klien untuk mendapatkan data yang tepat yang dibutuhkan.

GraphQL menyediakan banyak fitur yang tidak dimiliki REST API, mulai dari kueri data yang akurat hingga alat pengembang yang lebih baik, seperti graphiql editor. Ini juga memungkinkan Anda untuk meminta banyak sumber daya melalui satu permintaan.

Apa itu NestJS?

NestJS adalah kerangka kerja Node.js progresif yang dapat Anda gunakan untuk membangun aplikasi sisi server yang dapat diskalakan dan efisien. NestJS menyediakan banyak plugin, di samping alat untuk pengembangan yang cepat dan mudah termasuk dukungan GraphQL, GRPC, WebSockets, dll.

NestJS terkenal di ekosistem karena struktur proyeknya yang dioptimalkan menggunakan modul, pengontrol, layanan, dan skema. CLI bawaannya memungkinkan Anda membuat arsitektur API terstruktur. Anda dapat gunakan prinsip injeksi ketergantungan untuk mengontrol bagaimana bagian-bagian dari aplikasi berkomunikasi satu sama lain.

Menerapkan GraphQL Dengan NestJS dan MongoDB

Sebelum membuat API dengan NestJS dan GraphQL, Anda harus memiliki dependensi yang tepat. Anda membutuhkan untuk menginstal Node.js dan NestJS, yang dapat Anda instal dengan menjalankan npm i -g @nestjs/cli.

Contoh berikut adalah aplikasi sederhana yang menyimpan info tentang buku. Jalankan perintah berikut di terminal Anda untuk membuat aplikasi NestJS baru:

sarang baru 

Arahkan ke direktori aplikasi yang dihasilkan () dan instal dependensinya dengan perintah berikut:

$ npm install --save @nestjs/config @nestjs/graphql graphql-tools graphql \
 @nestjs/apollo apollo-server-express @nestjs/mongoose @types/graphql

Ada dua pendekatan utama untuk membangun API GraphQL, yaitu:

1. Pendekatan skema-pertama: di mana Anda mendeskripsikan API dalam file definisi skema atau SDL, dan NestJS menghasilkan definisi TypeScript berdasarkan pada mereka.
2. Pendekatan kode pertama: di mana Anda menentukan kueri, mutasi, dan fungsionalitas GraphQL lainnya menggunakan kelas dan dekorator TypeScript, dan NestJS menghasilkan file SDL berdasarkan pada mereka.

Contoh berikut menjelaskan cara menggunakan pendekatan code-first.

Pertama, Anda perlu menginisialisasi GraphQL di file AppModule Dan menghubungkannya ke database MongoDB:

// aplikasi.modul.ts
impor { Modul } dari'@nestjs/umum';
impor {Modul GraphQL sebagai Modul NestGraphQL } dari'@nestjs/graphql';
impor { ApolloDriver, ApolloDriverConfig } dari'@nestjs/apollo';
impor { bergabung } dari'jalur';
impor {MongooseModule} dari'@nestjs/mongoose';
impor { Pengontrol Aplikasi } dari'./app.controller';
impor { Layanan Aplikasi } dari'./app.service';
impor { ConfigModule, ConfigService } dari'@nestjs/config';
impor mongodbConfig dari'./config/mongodb.config';
@Modul({
 impor: [
 ConfigModule.forRoot({
 memuat: [mongodbConfig],
 global: BENAR
 }),
 NestGraphQLModul.forRootAsync({
 pengemudi: Pengemudi Apollo,
 menyuntikkan: [ConfigService],
 gunakanPabrik: asinkron (configService: ConfigService) => ({
 autoSchemaFile: gabung (process.cwd(), 'src/skema.gql'),
 pasang SubscriptionHandlers: BENAR,
 sortSchema: BENAR,
 tempat bermain: BENAR,
 debug: configService.get<boolean>("DEBUG"),
 upload: PALSU,
 }),
 }),
 MongooseModule.forRootAsync({
 menyuntikkan: [ConfigService],
 gunakanPabrik: asinkron (configService: ConfigService) => ({
 uri: configService.get('MONGO_URI')
 })
 }),
 ],
 pengontrol: [AppController],
 penyedia: [AppService],
})
eksporkelas AppModul {}

Modul ini mengimpor file Modul GraphQL dari @nestjs/graphql dan MongooseModule dari @nestjs/mongoose yang membantu terhubung ke MongoDB. Itu AutoSchemaFile properti menentukan lokasi file skema yang dihasilkan, dan sortSchema properti memastikan bahwa ia mengurutkan bidang menurut abjad.

Inilah yang MongoDB Anda config file akan terlihat seperti:

impor { daftar Sebagai } dari'@nestjs/config';
/**
 * Konfigurasi koneksi database Mongo
 */
eksporbawaan daftarA('mongodb', () => {
const {
 MONGO_URI
 } = proses.env;
kembali {
 uri: `${MONGO_URI}`,
 };
});

Mendefinisikan Skema GraphQL

Setelah menyiapkan koneksi GraphQL dan MongoDB, Anda harus menentukan kueri dan mutasi GraphQL untuk menghasilkan skema (skema.gql) berkas.

Menulis Pertanyaan

Dalam pendekatan kode pertama, Anda membuat model menggunakan Tipe Objek penghias. Anda nantinya akan mengubah model ini menjadi tipe GraphQL.

Contohnya:

// buku.model.ts
impor { Bidang, Tipe Objek } dari'@nestjs/graphql';
impor { Prop, Skema, Pabrik Skema } dari'@nestjs/mongoose';
impor { Dokumen } dari'luwak';
eksporjenis BookDocument = Buku & Dokumen;
@ObjectType()
@Skema()
eksporkelas Buku {
@Bidang()
 judul: rangkaian;
@Bidang()
 pengarang: rangkaian;
@Bidang()
 Tanggal publikasi: boolean;
}
eksporconst BookSchema = SchemaFactory.createForClass (Buku);

GraphQL, secara default, tidak dapat menggunakan skema yang dibuat. Untuk membuatnya berfungsi, Anda memerlukan layanan penyelesai yang berisi fungsi untuk mengeksekusi tipe GraphQL. Anda dapat melakukannya dengan Penyelesai penghias.

// buku.penyelesai.ts
impor { Resolver, Kueri, Mutasi, Args, ID } dari'@nestjs/graphql';
impor { Buku } dari'./buku.model';
impor { Layanan Buku } dari'./buku.layanan';
@penyelesai(() => Buku)
eksporkelas Penyelesai Buku {
konstruktor(pribadi readonly bookService: Layanan Buku) { }
@Pertanyaan(() => [Buku])
asinkron buku(): Janji {
kembaliini.bookService.findAll();
 }
@Pertanyaan(() => Buku)
asinkron buku(@Args('pengenal', { jenis: () => Ya: rangkaian): Janji {
kembaliini.bookService.findOne (id);
 }
}

Anda dapat menerapkan Layanan Buku, diimpor di atas, sebagai berikut:

// buku.layanan.ts
impor { Dapat disuntikkan } dari'@nestjs/umum';
impor { Model Injeksi } dari'@nestjs/mongoose';
impor { Model } dari'luwak';
impor { Buku, Dokumen Buku } dari'./buku.model';
@Injeksi()
eksporkelas Layanan Buku {
konstruktor(@InjectModel(Buku.nama) pribadi bookModel: Model) { }
asinkron Temukan semua(): Janji {
kembaliini.bookModel.find().exec();
 }
asinkron findOne (id: rangkaian): Janji {
kembaliini.bookModel.findById (id).exec();
 }
}

Anda juga perlu menambahkan BookResolver ke daftar penyedia di buku.modul.ts.

impor { Modul } dari"@nestjs/umum";
impor {MongooseModule} dari"@nestjs/mongoose";
impor { Layanan Buku } dari'./buku.layanan';
impor { Penyelesai Buku } dari'./buku.resolver';
impor { Buku, Skema Buku } dari'./buku.model';
@Modul({
 penyedia: [
 Layanan Buku,
 BookResolver
 ],
 impor: [MongooseModule.forFeature([
 {
 nama: Buku.nama,
 skema: Skema Buku,
 },
 ]),
 ],
})
eksporkelas BukuModul {}

Bekerja Dengan Mutasi

Saat Anda menggunakan kueri untuk mengambil data di GraphQL, mutasi membuat atau memperbarui data di database. Untuk membuat mutasi, Anda perlu menerima data dari pengguna. Itu Tipe masukan dekorator, yang mengubah kelas menjadi tipe input GraphQL, sangat berguna di sini.

// buku.input.ts
impor { Jenis Masukan, Bidang } dari'@nestjs/graphql';
@Tipe masukan()
eksporkelas Masukan Buku {
@Bidang()
 judul: rangkaian;
@Bidang()
 pengarang: rangkaian;
@Bidang()
 Tanggal publikasi: boolean
}

Anda sekarang dapat memperbarui buku.penyelesai.ts untuk terlihat seperti ini:

impor { Resolver, Kueri, Mutasi, Args, ID } dari'@nestjs/graphql';
impor { Buku } dari'./buku.model';
impor { Layanan Buku } dari'./buku.layanan';
impor { Input Buku } dari'./buku.input';
@penyelesai(() => Buku)
eksporkelas Penyelesai Buku {
konstruktor(pribadi readonly bookService: Layanan Buku) { }
@Mutasi(() => Buku)
asinkron buatBuku(@Args('memasukkan') masukan: Masukan Buku): Janji {
kembaliini.bookService.create (masukan);
 }
@Mutasi(() => Buku)
asinkron perbaruiBuku(
@Args('pengenal', { jenis: () => Ya: rangkaian,
@Args('memasukkan') masukan: Input Buku,
 ): Janji {
kembaliini.bookService.update (id, masukan);
 }
@Mutasi(() => Buku)
asinkron hapusBuku(@Args('pengenal', { jenis: () => Ya: rangkaian): Janji {
kembaliini.bookService.delete (id);
 }
}

Dan buku.layanan.ts seperti ini:

impor { Dapat disuntikkan } dari'@nestjs/umum';
impor { Model Injeksi } dari'@nestjs/mongoose';
impor { Model } dari'luwak';
impor { Buku, Dokumen Buku } dari'./buku.model';
@Injeksi()
eksporkelas Layanan Buku {
konstruktor(@InjectModel(Buku.nama) pribadi bookModel: Model) { }
asinkron buat (buku: Buku): Janji {
const Buku baru = baruini.bookModel (buku);
kembali BukuBaru.save();
 }
asinkron perbarui (id: rangkaian, buku buku): Janji {
kembaliini.bookModel.findByIdAndUpdate (id, buku, { baru: BENAR }).exec();
 }
asinkronmenghapus(pengenal: rangkaian): Janji {
kembaliini.bookModel.findByIdAndDelete (id).exec();
 }
}

Itu @Mutasi dekorator menandai fungsi sebagai jenis mutasi dan @Args dekorator mengambil input apa pun yang diteruskan ke fungsi.

Terakhir, Anda harus mengimpor file BooksModule ke dalam AppModule untuk membuatnya fungsional. Anda juga harus lulus BooksModule ke untuk RootAsync seperti yang terlihat di bawah ini.

impor { Modul Buku } dari'./buku/buku.modul';
/**
 * impor lainnya
*/
@Modul({
 impor: [
 ConfigModule.forRoot({
 memuat: [mongodbConfig],
 global: BENAR
 }),
 NestGraphQLModul.forRootAsync({
 pengemudi: Pengemudi Apollo,
 menyuntikkan: [ConfigService],
 gunakanPabrik: asinkron (configService: ConfigService) => ({
 autoSchemaFile: gabung (process.cwd(), 'src/skema.gql'),
 pasang SubscriptionHandlers: BENAR,
 sortSchema: BENAR,
 tempat bermain: BENAR,
 debug: configService.get<boolean>("DEBUG"),
 upload: PALSU,
 }),
 }),
 MongooseModule.forRootAsync({
 menyuntikkan: [ConfigService],
 gunakanPabrik: asinkron (configService: ConfigService) => ({
 uri: configService.get('MONGO_URI')
 })
 }),
 Modul Buku,
 ],
 pengontrol: [AppController],
 penyedia: [AppService],
})
eksporkelas AppModul {}

Anda dapat menguji kode dengan menjalankan npm jalankan mulai: dev di terminal Anda, dan aplikasi Anda akan mulai dengan sukses di port 3000.

Membuka localhost: 3000/graphql di browser Anda untuk menampilkan Graphiql antarmuka tempat Anda dapat menguji kueri dan mutasi. Berikut adalah contoh yang menampilkan kueri:

Dan inilah contoh mutasi:

Bangun API yang Efisien Dengan NestJS dan GraphQL

Membangun API GraphQL di NestJS dengan MongoDB menggunakan Mongoose melibatkan pendefinisian skema untuk API GraphQL, sebuah skema untuk model Mongoose, sebuah layanan untuk berinteraksi dengan database, dan sebuah resolver untuk memetakan operasi GraphQL ke layanan metode.

NestJS memiliki fungsionalitas bawaan untuk membuat API, termasuk dekorator untuk menentukan rute, penjaga untuk melindunginya, dan middleware untuk menangani permintaan dan respons. Ini juga mendukung database lain seperti PostgreSQL, MySQL, dan SQLite, serta perpustakaan GraphQL lainnya seperti Apollo dan TypeGraphQL.