NestJS és MongoDB használata GraphQL API létrehozásához

A GraphQL és a NestJS kiváló partnerséget alkot, szilárd alapot biztosítva az API-khoz, valamint egy könnyen használható keretrendszert a méretezhető webalkalmazások készítéséhez. A kombináció tökéletes gyártásra kész alkalmazások készítéséhez, és mindkettő nagyon releváns eszköz a mai technológiai ökoszisztémában.

Tudjon meg többet arról, hogyan hozhat létre API-t mindkét termék használatával.

Mi az a GraphQL?

A GraphQL egy adatlekérdezési és -kezelési nyelv segítségével precízebb és tömörebb módon építheti fel az API-kat. A GraphQL teljes és megfelelő leírást ad az API-ban létező adatokról, és felhatalmazza a klienst arra, hogy pontosan megkapja a szükséges adatokat.

A GraphQL számos olyan funkciót kínál, amelyek a REST API-kból hiányoznak, a pontos adatlekérdezésektől a jobb fejlesztői eszközökig, mint pl. graphiql szerkesztő. Lehetővé teszi több erőforrás lekérdezését is egyetlen kéréssel.

Mi az a NestJS?

A NestJS egy progresszív Node.js keretrendszer, amellyel méretezhető és hatékony szerveroldali alkalmazások hozhatók létre. A NestJS számos beépülő modult kínál a gyors és egyszerű fejlesztéshez szükséges eszközök mellett, beleértve a GraphQL támogatást, a GRPC-t, a WebSockets-et stb.

A NestJS jól ismert az ökoszisztémában a modulokat, vezérlőket, szolgáltatásokat és sémákat használó optimalizált projektstruktúrájáról. A beépített CLI lehetővé teszi strukturált API architektúra létrehozását. Te tudod használni függőségi injekció elvei annak szabályozására, hogy az alkalmazás részei hogyan kommunikáljanak egymással.

A GraphQL megvalósítása NestJS-sel és MongoDB-vel

Mielőtt API-t építene a NestJS és a GraphQL segítségével, rendelkeznie kell a megfelelő függőségekkel. Szükséged van a Node.js telepítéséhez és a NestJS, amelyet futtatással telepíthet npm i -g @nestjs/cli.

A következő példa egy egyszerű alkalmazás, amely könyvekkel kapcsolatos információkat tárol. Futtassa a következő parancsot a terminálon egy új NestJS alkalmazás létrehozásához:

fészek új 

Keresse meg a generált alkalmazás könyvtárát (), és telepítse a függőségeit a következő paranccsal:

$ npm telepítés -- mentés @nestjs/config @nestjs/graphql graphql-tools graphql \
 @nestjs/apollo apollo-server-express @nestjs/mongoose @types/graphql

Két fő megközelítés létezik a GraphQL API-k létrehozására, nevezetesen:

1. Séma-első megközelítés: ahol leírja az API-t sémadefiníciós fájlokban vagy SDL-ben, és a NestJS ezek alapján Typescript-definíciókat generál.
2. Kód-első megközelítés: ahol lekérdezéseket, mutációkat és egyéb GraphQL-funkciókat határozhat meg Typescript osztályok és dekorátorok segítségével, a NestJS pedig ezek alapján SDL-fájlokat állít elő.

A következő példa leírja, hogyan kell használni a kód-első megközelítést.

Először is inicializálnia kell a GraphQL-t AppModule és csatlakoztassa egy MongoDB adatbázishoz:

// app.module.ts
import { Modul } tól től"@nestjs/common";
import { GraphQLMmodul mint NestGraphQLMmodul } tól től"@nestjs/graphql";
import { ApolloDriver, ApolloDriverConfig } tól től"@nestjs/apollo";
import {csatlakozás } tól től'pálya';
import { MongooseModule } tól től"@nestjs/mongoose";
import { AppController } tól től"./app.controller";
import { AppService } tól től"./app.service";
import { ConfigModule, ConfigService } tól től"@nestjs/config";
import mongodbConfig tól től'./config/mongodb.config';
@Modul({
 import: [
 ConfigModule.forRoot({
 betöltés: [mongodbConfig],
 isGlobal: igaz
 }),
 NestGraphQLModule.forRootAsync({
 sofőr: ApolloDriver,
 inject: [ConfigService],
 useFactory: async (configService: ConfigService) => ({
 autoSchemaFile: csatlakozás (process.cwd(), "src/schema.gql"),
 installSubscriptionHandlers: igaz,
 sortSchema: igaz,
 játszótér: igaz,
 hibakeresés: configService.get<logikai érték>("DEBUG"),
 feltöltések: hamis,
 }),
 }),
 MongooseModule.forRootAsync({
 inject: [ConfigService],
 useFactory: async (configService: ConfigService) => ({
 uri: configService.get("MONGO_URI")
 })
 }),
 ],
 vezérlők: [AppController],
 szolgáltatók: [AppService],
})
exportosztály AppModule {}

Ez a modul importálja a GraphQLMmodul tól től @nestjs/graphql és a MongooseModule tól től @nestjs/mongoose amely segít csatlakozni a MongoDB-hez. A autoSchemaFile tulajdonság megadja a generált sémafájl helyét, és a sortSchema tulajdonság biztosítja, hogy a mezőket ábécé szerint rendezze.

Itt van a MongoDB-je config a fájlnak így kell kinéznie:

import { registerAs } tól től"@nestjs/config";
/**
 * Mongo adatbázis-kapcsolat konfigurációja
 */
exportalapértelmezett registerAs("mongodb", () => {
const {
 MONGO_URI
 } = process.env;
Visszatérés {
 uri: `${MONGO_URI}`,
 };
});

A GraphQL séma meghatározása

A GraphQL és a MongoDB kapcsolatok beállítása után meg kell határoznia a GraphQL lekérdezéseket és mutációkat a séma létrehozásához (schema.gql) fájl.

Lekérdezések írása

Ban,-ben kód-első megközelítés, akkor létrehoz egy modellt a ObjectType lakberendező. Később ezt a modellt GraphQL típussá alakítja át.

Például:

// book.model.ts
import { Mező, Objektumtípus } tól től"@nestjs/graphql";
import { Prop, Schema, SchemaFactory } tól től"@nestjs/mongoose";
import { Dokumentum } tól től'indiai menyét';
exporttípus BookDocument = Könyv és dokumentum;
@ObjectType()
@Séma()
exportosztály Könyv {
@Terület()
 cím: húr;
@Terület()
 szerző: húr;
@Terület()
 közzététel dátuma: logikai érték;
}
exportconst BookSchema = SchemaFactory.createForClass (Könyv);

A GraphQL alapértelmezés szerint nem tudja használni a létrehozott sémákat. Működésükhöz szükség van egy feloldó szolgáltatásra, amely tartalmazza a GraphQL típusok végrehajtásához szükséges funkciókat. Ezt megteheti a Megoldó lakberendező.

// books.resolver.ts
import { Feloldó, lekérdezés, mutáció, érvek, azonosító } tól től"@nestjs/graphql";
import { Könyv } tól től"./book.model";
import { Könyvszolgáltatás } tól től"./books.service";
@Megoldó(() => Könyv)
exportosztály BookResolver {
konstruktőr(magán csak olvasható könyvService: BookService) { }
@Lekérdezés(() => [Könyv])
async könyvek (): Ígéret {
Visszatérésez.bookService.findAll();
 }
@Lekérdezés(() => Könyv)
async könyv(@Args("azonosító", { típus: () => Én csináltam: húr): Ígéret {
Visszatérésez.bookService.findOne (id);
 }
}

Megvalósíthatja a BookService, fent importált, az alábbiak szerint:

// books.service.ts
import { Injekciós } tól től"@nestjs/common";
import { InjectModel } tól től"@nestjs/mongoose";
import { Modell } tól től'indiai menyét';
import { Könyv, könyvdokumentum } tól től"./book.model";
@Injektálható()
exportosztály BookService {
konstruktőr(@InjectModel(Book.name) magán könyvModell: Modell) { }
async Találd meg mindet(): Ígéret {
Visszatérésez.bookModel.find().exec();
 }
async findOne (azonosító: húr): Ígéret {
Visszatérésez.bookModel.findById (id).exec();
 }
}

Ezenkívül hozzá kell adnia a BookResolvert a szolgáltatók listájához könyvek.modul.ts.

import { Modul } tól től"@nestjs/common";
import { MongooseModule } tól től"@nestjs/mongoose";
import { Könyvszolgáltatás } tól től"./books.service";
import { BookResolver } tól től"./books.resolver";
import { Book, BookSchema } tól től"./book.model";
@Modul({
 szolgáltatók: [
 Könyvszerviz,
 BookResolver
 ],
 importok: [MongooseModule.forFeature([
 {
 név: könyv.név,
 séma: BookSchema,
 },
 ]),
 ],
})
exportosztály Könyvek modul {}

Munka mutációkkal

Miközben lekérdezést használ az adatok lekérésére a GraphQL-ben, a mutációk adatokat hoznak létre vagy frissítenek az adatbázisban. A mutációk létrehozásához adatokat kell elfogadnia a felhasználóktól. A InputType Itt jól jön a dekorátor, amely egy osztályt GraphQL bemeneti típussá alakít.

// book.input.ts
import { InputType, Field } tól től"@nestjs/graphql";
@InputType()
exportosztály BookInput {
@Terület()
 cím: húr;
@Terület()
 szerző: húr;
@Terület()
 közzététel dátuma: logikai érték
}

Most frissíthet könyvek.resolver.ts így néz ki:

import { Feloldó, lekérdezés, mutáció, érvek, azonosító } tól től"@nestjs/graphql";
import { Könyv } tól től"./book.model";
import { Könyvszolgáltatás } tól től"./books.service";
import { BookInput } tól től"./book.input";
@Megoldó(() => Könyv)
exportosztály BookResolver {
konstruktőr(magán csak olvasható könyvService: BookService) { }
@Mutáció(() => Könyv)
async CreateBook(@Args('bemenet') bemenet: BookInput): Ígéret {
Visszatérésez.bookService.create (bemenet);
 }
@Mutáció(() => Könyv)
async updateBook(
@Args("azonosító", { típus: () => Én csináltam: húr,
@Args('bemenet') bemenet: BookInput,
 ): Ígéret {
Visszatérésez.bookService.update (azonosító, bemenet);
 }
@Mutáció(() => Könyv)
async deleteBook(@Args("azonosító", { típus: () => Én csináltam: húr): Ígéret {
Visszatérésez.bookService.delete (id);
 }
}

És könyvek.szolgáltatás.ts mint ez:

import { Injekciós } tól től"@nestjs/common";
import { InjectModel } tól től"@nestjs/mongoose";
import { Modell } tól től'indiai menyét';
import { Könyv, könyvdokumentum } tól től"./book.model";
@Injektálható()
exportosztály BookService {
konstruktőr(@InjectModel(Book.name) magán könyvModell: Modell) { }
async létrehozás (könyv: Könyv): Ígéret {
const újkönyv = újez.bookModel (könyv);
Visszatérés newBook.save();
 }
async frissítés (id: húr, könyv: Könyv): Ígéret {
Visszatérésez.bookModel.findByIdAndUpdate (azonosító, könyv, { új: igaz }).exec();
 }
asynctöröl(azonosító: húr): Ígéret {
Visszatérésez.bookModel.findByIdAndDelete (id).exec();
 }
}

A @Mutáció dekorátor mutációtípusként jelöl funkciót és a @Args A dekorátor megragad minden, a funkcióba átadott bemenetet.

Végül importálnia kell a BooksModule -ba AppModule működőképessé tenni. Azt is át kell adni a BooksModule nak nek forRootAsync ahogy lentebb látható.

import { BooksModule } tól től"./books/books.module";
/**
 * egyéb import
*/
@Modul({
 import: [
 ConfigModule.forRoot({
 betöltés: [mongodbConfig],
 isGlobal: igaz
 }),
 NestGraphQLModule.forRootAsync({
 sofőr: ApolloDriver,
 inject: [ConfigService],
 useFactory: async (configService: ConfigService) => ({
 autoSchemaFile: csatlakozás (process.cwd(), "src/schema.gql"),
 installSubscriptionHandlers: igaz,
 sortSchema: igaz,
 játszótér: igaz,
 hibakeresés: configService.get<logikai érték>("DEBUG"),
 feltöltések: hamis,
 }),
 }),
 MongooseModule.forRootAsync({
 inject: [ConfigService],
 useFactory: async (configService: ConfigService) => ({
 uri: configService.get("MONGO_URI")
 })
 }),
 BooksModule,
 ],
 vezérlők: [AppController],
 szolgáltatók: [AppService],
})
exportosztály AppModule {}

A kódot futtatással tesztelheti npm futás indítása: dev a terminálban, és az alkalmazásnak sikeresen el kell indulnia a porton 3000.

Nyisd ki localhost: 3000/graphql a böngészőben, hogy megjelenjen a Graphiql felület, ahol lekérdezéseket és mutációkat tesztelhet. Íme egy példa, amely egy lekérdezést mutat be:

És itt van egy példa a mutációra:

Hatékony API-k létrehozása a NestJS és a GraphQL segítségével

A GraphQL API-nak a NestJS-ben MongoDB-vel Mongoose használatával történő felépítése magában foglalja egy séma meghatározását a GraphQL API számára, egy séma a Mongoose modellhez egy szolgáltatás az adatbázissal való interakcióhoz és egy feloldó a GraphQL műveletek szolgáltatáshoz való hozzárendeléséhez mód.

A NestJS beépített funkciókkal rendelkezik az API-k létrehozásához, beleértve az útvonalak meghatározására szolgáló dekorátorokat, az őket védő őröket, valamint a kérések és válaszok kezelésére szolgáló köztes szoftvereket. Más adatbázisokat is támogat, például a PostgreSQL-t, a MySQL-t és az SQLite-t, valamint más GraphQL-könyvtárakat, például az Apollo-t és a TypeGraphQL-t.