Uporaba NestJS in MongoDB za izdelavo API-ja GraphQL

GraphQL in NestJS predstavljata odlično partnerstvo, ki vam daje trdne temelje za vaše API-je in ogrodje, ki je preprosto za uporabo, za gradnjo razširljivih spletnih aplikacij. Kombinacija je popolna za ustvarjanje aplikacij, pripravljenih za proizvodnjo, obe pa sta zelo relevantni orodji v današnjem tehnološkem ekosistemu.

Izvedite več o tem, kako lahko zgradite API z uporabo obeh izdelkov.

Kaj je GraphQL?

GraphQL je jezik za poizvedovanje in obdelavo podatkov lahko uporabite za izdelavo API-jev na bolj natančen in jedrnat način. GraphQL zagotavlja popoln in ustrezen opis podatkov, ki obstajajo v API-ju, in daje odjemalcu moč, da pridobi natančne podatke, ki jih potrebuje.

GraphQL ponuja številne funkcije, ki jih REST API-ji nimajo, od natančnih podatkovnih poizvedb do boljših orodij za razvijalce, kot je graphiql urednik. Omogoča tudi poizvedovanje po več virih z eno samo zahtevo.

Kaj je NestJS?

NestJS je progresivno ogrodje Node.js, ki ga lahko uporabite za izdelavo razširljivih in učinkovitih aplikacij na strani strežnika. NestJS ponuja številne vtičnike, poleg orodij za hiter in enostaven razvoj, vključno s podporo za GraphQL, GRPC, WebSockets itd.

NestJS je v ekosistemu dobro znan po svoji optimizirani projektni strukturi z uporabo modulov, krmilnikov, storitev in shem. Njegov vgrajen CLI vam omogoča ustvarjanje strukturirane arhitekture API. Lahko uporabiš načela vbrizgavanja odvisnosti za nadzor nad tem, kako deli aplikacije komunicirajo med seboj.

Implementacija GraphQL z NestJS in MongoDB

Preden zgradite API z NestJS in GraphQL, boste morali imeti na voljo prave odvisnosti. Potrebujete za namestitev Node.js in NestJS, ki ju lahko namestite z zagonom npm i -g @nestjs/cli.

Primer, ki sledi, je preprosta aplikacija, ki shranjuje informacije o knjigah. Zaženite naslednji ukaz v svojem terminalu, da ustvarite novo aplikacijo NestJS:

gnezdo novo 

Pomaknite se do imenika ustvarjene aplikacije () in namestite njegove odvisnosti z naslednjim ukazom:

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

Obstajata dva glavna pristopa k izdelavi API-jev GraphQL, in sicer:

1. Prvi pristop sheme: kjer opisujete API v datotekah z definicijo sheme ali SDL, NestJS pa na njihovi podlagi ustvari definicije Typescript.
2. Prvi pristop kode: kjer definirate poizvedbe, mutacije in druge funkcionalnosti GraphQL z uporabo razredov in dekoratorjev Typescript, NestJS pa na njihovi podlagi ustvari datoteke SDL.

Naslednji primer opisuje, kako uporabiti pristop najprej kode.

Najprej morate inicializirati GraphQL v svojem AppModule in ga povežite z bazo podatkov MongoDB:

// app.module.ts
uvoz { Modul } od'@nestjs/common';
uvoz {GraphQLModul kot NestGraphQLModule } od'@nestjs/graphql';
uvoz { ApolloDriver, ApolloDriverConfig } od'@nestjs/apollo';
uvoz {pridruži se} od'pot';
uvoz { MongooseModule } od'@nestjs/mongoose';
uvoz { AppController } od'./app.controller';
uvoz { AppService } od'./app.service';
uvoz {ConfigModule, ConfigService} od'@nestjs/config';
uvoz mongodbConfig od'./config/mongodb.config';
@Modul({
 uvoz: [
 ConfigModule.forRoot({
 nalaganje: [mongodbConfig],
 isGlobal: prav
 }),
 NestGraphQLModule.forRootAsync({
 voznik: ApolloDriver,
 inject: [ConfigService],
 useFactory: asinh (configService: ConfigService) => ({
 autoSchemaFile: pridruži se (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: prav,
 sortSchema: prav,
 igrišče: prav,
 odpravljanje napak: configService.get<logično>("DEBUG"),
 nalaganja: lažno,
 }),
 }),
 MongooseModule.forRootAsync({
 inject: [ConfigService],
 useFactory: asinh (configService: ConfigService) => ({
 uri: configService.get('MONGO_URI')
 })
 }),
 ],
 krmilniki: [AppController],
 ponudniki: [AppService],
})
izvozrazred AppModule {}

Ta modul uvozi GraphQLModule od @nestjs/graphql in MongooseModule od @nestjs/mongos ki pomaga pri povezovanju z MongoDB. The autoSchemaFile lastnost določa lokacijo ustvarjene datoteke sheme in sortSchema Lastnost zagotavlja, da razporedi polja po abecedi.

Tukaj je vaš MongoDB konfiguracija datoteka bi morala izgledati takole:

uvoz { registerAs } od'@nestjs/config';
/**
 * Konfiguracija povezave z bazo podatkov Mongo
 */
izvozprivzeto registerAs('mongodb', () => {
konst {
 MONGO_URI
 } = proces.env;
vrnitev {
 uri: `${MONGO_URI}`,
 };
});

Definiranje sheme GraphQL

Ko nastavite povezave GraphQL in MongoDB, morate definirati poizvedbe in mutacije GraphQL za ustvarjanje sheme (schema.gql) mapa.

Pisanje poizvedb

V pristop na prvem mestu koda, ustvarite model z uporabo ObjectType dekorater. Ta model boste pozneje preoblikovali v tip GraphQL.

Na primer:

// book.model.ts
uvoz { Field, ObjectType } od'@nestjs/graphql';
uvoz {Prop, Schema, SchemaFactory} od'@nestjs/mongoose';
uvoz {Dokument} od'mungos';
izvozvrsta BookDocument = Knjiga in dokument;
@ObjectType()
@Shema()
izvozrazred knjiga {
@Field()
 naslov: vrvica;
@Field()
 avtor: vrvica;
@Field()
 objavljeni datum: logično;
}
izvozkonst BookSchema = SchemaFactory.createForClass (Knjiga);

GraphQL privzeto ne more uporabiti ustvarjenih shem. Da bodo funkcionalni, potrebujete storitev razreševalnika, ki vsebuje funkcije za izvajanje vrst GraphQL. To lahko storite z Reševalec dekorater.

// books.resolver.ts
uvoz { Razreševalec, poizvedba, mutacija, argumenti, ID } od'@nestjs/graphql';
uvoz { Knjiga } od'./book.model';
uvoz { BookService } od'./books.service';
@Razreševalec(() => knjiga)
izvozrazred BookResolver {
konstruktor(zasebno readonly bookService: BookService) { }
@Poizvedba(() => [Knjiga])
asinh knjige(): Obljuba {
vrnitevto.bookService.findAll();
 }
@Poizvedba(() => knjiga)
asinh knjiga(@Args('id', { vrsta: () => Jaz sem: vrvica): Obljuba {
vrnitevto.bookService.findOne (id);
 }
}

Lahko izvajate BookService, uvoženo zgoraj, kot sledi:

// books.service.ts
uvoz { Za injiciranje } od'@nestjs/common';
uvoz {InjectModel} od'@nestjs/mongoose';
uvoz { Model } od'mungos';
uvoz { Knjiga, knjižni dokument } od'./book.model';
@Za injiciranje()
izvozrazred BookService {
konstruktor(@InjectModel(ime.knjige) zasebno bookModel: Model) { }
asinh poiščiVse(): Obljuba {
vrnitevto.bookModel.find().exec();
 }
asinh findOne (id: vrvica): Obljuba {
vrnitevto.bookModel.findById (id).exec();
 }
}

Dodati morate tudi BookResolver na seznam ponudnikov v knjige.modul.ts.

uvoz { Modul } od"@nestjs/skupno";
uvoz { MongooseModule } od"@nestjs/mongoose";
uvoz { BookService } od'./books.service';
uvoz { BookResolver } od'./books.resolver';
uvoz { Knjiga, BookSchema } od'./book.model';
@Modul({
 ponudniki: [
 BookService,
 BookResolver
 ],
 uvozi: [MongooseModule.forFeature([
 {
 ime: ime.knjige,
 shema: BookSchema,
 },
 ]),
 ],
})
izvozrazred BooksModule {}

Delo z mutacijami

Medtem ko uporabljate poizvedbo za pridobivanje podatkov v GraphQL, mutacije ustvarijo ali posodobijo podatke v bazi podatkov. Če želite ustvariti mutacije, morate sprejeti podatke od uporabnikov. The InputType dekorater, ki spremeni razred v vnosni tip GraphQL, pride tukaj prav.

// book.input.ts
uvoz { InputType, Field } od'@nestjs/graphql';
@InputType()
izvozrazred BookInput {
@Field()
 naslov: vrvica;
@Field()
 avtor: vrvica;
@Field()
 objavljeni datum: logično
}

Zdaj lahko posodobite books.resolver.ts da izgleda takole:

uvoz { Razreševalec, poizvedba, mutacija, argumenti, ID } od'@nestjs/graphql';
uvoz { Knjiga } od'./book.model';
uvoz { BookService } od'./books.service';
uvoz { BookInput } od'./book.input';
@Razreševalec(() => knjiga)
izvozrazred BookResolver {
konstruktor(zasebno readonly bookService: BookService) { }
@Mutacija(() => knjiga)
asinh ustvari knjigo(@Args('vhod') vnos: BookInput): Obljuba {
vrnitevto.bookService.create (vnos);
 }
@Mutacija(() => knjiga)
asinh posodobi knjigo(
@Args('id', { vrsta: () => Jaz sem: vrvica,
@Args('vhod') vnos: BookInput,
 ): Obljuba {
vrnitevto.bookService.update (id, vnos);
 }
@Mutacija(() => knjiga)
asinh izbrišiKnjigo(@Args('id', { vrsta: () => Jaz sem: vrvica): Obljuba {
vrnitevto.bookService.delete (id);
 }
}

in books.service.ts Všečkaj to:

uvoz { Za injiciranje } od'@nestjs/common';
uvoz {InjectModel} od'@nestjs/mongoose';
uvoz { Model } od'mungos';
uvoz { Knjiga, knjižni dokument } od'./book.model';
@Za injiciranje()
izvozrazred BookService {
konstruktor(@InjectModel(ime.knjige) zasebno bookModel: Model) { }
asinh ustvari (knjiga: knjiga): Obljuba {
konst nova knjiga = novoto.bookModel (knjiga);
vrnitev novaKnjiga.save();
 }
asinh posodobitev (id: vrvica, knjiga: Knjiga): Obljuba {
vrnitevto.bookModel.findByIdAndUpdate (id, knjiga, { novo: prav }).exec();
 }
asinhizbrisati(id: vrvica): Obljuba {
vrnitevto.bookModel.findByIdAndDelete (id).exec();
 }
}

The @Mutacija dekorater označi funkcijo kot vrsto mutacije in @Args dekorater zgrabi vse vnose, posredovane v funkcijo.

Končno bi morali uvoziti BooksModule v AppModule da bo funkcionalen. Moral bi tudi opraviti BooksModule do zaRootAsync kot je prikazano spodaj.

uvoz { BooksModule } od'./knjige/knjige.modul';
/**
 * ostali uvozi
*/
@Modul({
 uvoz: [
 ConfigModule.forRoot({
 nalaganje: [mongodbConfig],
 isGlobal: prav
 }),
 NestGraphQLModule.forRootAsync({
 voznik: ApolloDriver,
 inject: [ConfigService],
 useFactory: asinh (configService: ConfigService) => ({
 autoSchemaFile: pridruži se (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: prav,
 sortSchema: prav,
 igrišče: prav,
 odpravljanje napak: configService.get<logično>("DEBUG"),
 nalaganja: lažno,
 }),
 }),
 MongooseModule.forRootAsync({
 inject: [ConfigService],
 useFactory: asinh (configService: ConfigService) => ({
 uri: configService.get('MONGO_URI')
 })
 }),
 BooksModule,
 ],
 krmilniki: [AppController],
 ponudniki: [AppService],
})
izvozrazred AppModule {}

Kodo lahko preizkusite z zagonom npm run start: dev v vašem terminalu in vaša aplikacija bi se morala uspešno zagnati na vratih 3000.

Odprto lokalni gostitelj: 3000/graphql v brskalniku, da prikažete Graphiql vmesnik, kjer lahko testirate poizvedbe in mutacije. Tu je primer, ki prikazuje poizvedbo:

In tukaj je primer mutacije:

Ustvarite učinkovite API-je z NestJS in GraphQL

Gradnja GraphQL API v NestJS z MongoDB z uporabo Mongoose vključuje definiranje sheme za GraphQL API, shemo za model Mongoose storitev za interakcijo z bazo podatkov in razreševalec za preslikavo operacij GraphQL v storitev metode.

NestJS ima vgrajeno funkcionalnost za gradnjo API-jev, vključno z dekoratorji za definiranje poti, zaščitami za njihovo zaščito in vmesno programsko opremo za obdelavo zahtev in odgovorov. Podpira tudi druge zbirke podatkov, kot so PostgreSQL, MySQL in SQLite, ter druge knjižnice GraphQL, kot sta Apollo in TypeGraphQL.