NestJS un MongoDB izmantošana, lai izveidotu GraphQL API

GraphQL un NestJS veido izcilu sadarbību, sniedzot jums stabilu pamatu jūsu API un viegli lietojamu sistēmu, lai izveidotu mērogojamu tīmekļa lietojumprogrammas. Šī kombinācija ir lieliski piemērota ražošanai gatavu lietotņu izveidei, un abi ir ļoti svarīgi rīki mūsdienu tehnoloģiju ekosistēmā.

Uzziniet vairāk par to, kā izveidot API, izmantojot abus produktus.

Kas ir GraphQL?

GraphQL ir datu vaicājumu un manipulācijas valoda varat izmantot, lai izveidotu API precīzāk un kodolīgāk. GraphQL nodrošina pilnīgu un adekvātu API esošo datu aprakstu un nodrošina klientam tiesības iegūt precīzus nepieciešamos datus.

GraphQL nodrošina daudzas funkcijas, kuru REST API trūkst, sākot no precīziem datu vaicājumiem līdz labākiem izstrādātāju rīkiem, piemēram, graphiql redaktors. Tas arī ļauj vaicāt vairākiem resursiem, izmantojot vienu pieprasījumu.

Kas ir NestJS?

NestJS ir progresīvs Node.js ietvars, ko varat izmantot, lai izveidotu mērogojamas un efektīvas servera puses lietojumprogrammas. NestJS nodrošina daudzus spraudņus, kā arī rīkus ātrai un vienkāršai izstrādei, tostarp GraphQL atbalstu, GRPC, WebSockets utt.

NestJS ir labi pazīstams ekosistēmā ar savu optimizēto projektu struktūru, izmantojot moduļus, kontrollerus, pakalpojumus un shēmas. Tā iebūvētais CLI ļauj izveidot strukturētu API arhitektūru. Tu vari izmantot atkarības injekcijas principi lai kontrolētu, kā lietojumprogrammas daļas sazinās viena ar otru.

GraphQL ieviešana ar NestJS un MongoDB

Pirms API izveides ar NestJS un GraphQL, jums ir jābūt pieejamām pareizajām atkarībām. Tev vajag lai instalētu Node.js un NestJS, ko varat instalēt, palaižot npm i -g @nestjs/cli.

Tālāk sniegtais piemērs ir vienkārša lietotne, kas glabā informāciju par grāmatām. Terminālī palaidiet šo komandu, lai izveidotu jaunu NestJS lietojumprogrammu:

ligzda jauna 

Pārejiet uz ģenerētās lietojumprogrammas direktoriju () un instalējiet tās atkarības ar šādu komandu:

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

Ir divas galvenās pieejas GraphQL API izveidei, proti:

1. Shēmas pirmā pieeja: kur jūs aprakstāt API shēmas definīciju failos vai SDL, un NestJS ģenerē Typescript definīcijas, pamatojoties uz tiem.
2. Pirmā koda pieeja: kur jūs definējat vaicājumus, mutācijas un citas GraphQL funkcijas, izmantojot Typescript klases un dekoratorus, un NestJS ģenerē SDL failus, pamatojoties uz tiem.

Nākamajā piemērā ir aprakstīts, kā izmantot pieeju vispirms kodam.

Pirmkārt, jums ir jāinicializē GraphQL savā AppModule un savienojiet to ar MongoDB datu bāzi:

// app.module.ts
imports { Modulis } no"@nestjs/common";
imports { GraphQLMmodule kā NestGraphQLMmodule } no'@nestjs/graphql';
imports { ApolloDriver, ApolloDriverConfig } no'@nestjs/apollo';
imports {pievienoties} no'ceļš';
imports { MongooseModule } no"@nestjs/mangoose";
imports { AppController } no'./app.controller';
imports { AppService } no'./app.service';
imports { ConfigModule, ConfigService } no"@nestjs/config";
imports mongodbConfig no'./config/mongodb.config';
@Modulis({
 imports: [
 ConfigModule.forRoot({
 ielāde: [mongodbConfig],
 isGlobal: taisnība
 }),
 NestGraphQLModule.forRootAsync({
 vadītājs: ApolloDriver,
 inject: [ConfigService],
 useFactory: asinhrons (configService: ConfigService) => ({
 autoSchemaFile: pievienojieties (process.cwd(), "src/schema.gql"),
 installSubscriptionHandlers: taisnība,
 šķirošanas shēma: taisnība,
 rotaļu laukums: taisnība,
 atkļūdošana: configService.get<Būla>("ATkļūdošana"),
 augšupielādes: viltus,
 }),
 }),
 MongooseModule.forRootAsync({
 inject: [ConfigService],
 useFactory: asinhrons (configService: ConfigService) => ({
 uri: configService.get("MONGO_URI")
 })
 }),
 ],
 kontrolieri: [AppController],
 pakalpojumu sniedzēji: [AppService],
})
eksportētklasē AppModule {}

Šis modulis importē GraphQLMmodulis no @nestjs/graphql un MongooseModule no @nestjs/mangoose kas palīdz izveidot savienojumu ar MongoDB. The autoSchemaFile rekvizīts norāda ģenerētā shēmas faila atrašanās vietu un kārtotshēmu rekvizīts nodrošina, ka tas sakārto laukus alfabētiskā secībā.

Lūk, kāds ir jūsu MongoDB konfigurācija failam vajadzētu izskatīties šādi:

imports { registerAs } no"@nestjs/config";
/**
 * Mongo datu bāzes savienojuma konfigurācija
 */
eksportētnoklusējuma registerAs("mongodb", () => {
konst {
 MONGO_URI
 } = process.env;
atgriezties {
 uri: `${MONGO_URI}`,
 };
});

GraphQL shēmas definēšana

Pēc GraphQL un MongoDB savienojumu iestatīšanas jums jādefinē GraphQL vaicājumi un mutācijas, lai ģenerētu shēmu (schema.gql) failu.

Vaicājumu rakstīšana

Iekš koda pirmā pieeja, jūs izveidojat modeli, izmantojot Objekta tips dekorators. Jūs vēlāk pārveidosit šo modeli par GraphQL tipu.

Piemēram:

// grāmata.modelis.ts
imports { Lauks, objekta tips } no'@nestjs/graphql';
imports { Prop, Schema, SchemaFactory } no"@nestjs/mangoose";
imports {Dokuments} no'mangusts';
eksportētveids BookDocument = Grāmata un dokuments;
@ObjectType()
@Shēma()
eksportētklasē Grāmata {
@lauks()
 virsraksts: virkne;
@lauks()
 autors: virkne;
@lauks()
 publicēšanas datums: Būla;
}
eksportētkonst BookSchema = SchemaFactory.createForClass (grāmata);

GraphQL pēc noklusējuma nevar izmantot izveidotās shēmas. Lai padarītu tos funkcionālus, jums ir nepieciešams atrisinātāja pakalpojums, kas satur GraphQL tipu izpildes funkcijas. To var izdarīt ar Atrisinātājs dekorators.

// books.resolver.ts
imports { Atrisinātājs, Vaicājums, Mutācija, Args, ID } no'@nestjs/graphql';
imports { Grāmata } no'./book.model';
imports { BookService } no'./books.service';
@Resolver(() => Grāmata)
eksportētklasē BookResolver {
konstruktors(Privāts Readonly bookService: BookService) { }
@Vaicājums(() => [Grāmata])
asinhrons grāmatas (): Apsolīt {
atgrieztiesšis.bookService.findAll();
 }
@Vaicājums(() => Grāmata)
asinhrons grāmata (@Args('id', { veids: () => ES izdarīju: virkne): Apsolīt {
atgrieztiesšis.bookService.findOne (id);
 }
}

Jūs varat īstenot Grāmatu serviss, importēts iepriekš, šādi:

// books.service.ts
imports {Injicējams} no"@nestjs/common";
imports { InjectModel } no"@nestjs/mangoose";
imports { Modelis } no'mangusts';
imports { Grāmata, Grāmatu dokuments } no'./book.model';
@Injicējams()
eksportētklasē BookService {
konstruktors(@InjectModel(Book.name) Privāts grāmataModelis: modelis) { }
asinhrons atrast visu (): Apsolīt {
atgrieztiesšis.bookModel.find().exec();
 }
asinhrons findOne (id: virkne): Apsolīt {
atgrieztiesšis.bookModel.findById (id).exec();
 }
}

Jums arī jāpievieno BookResolver pakalpojumu sniedzēju sarakstam grāmatas.modulis.ts.

imports { Modulis } no"@nestjs/common";
imports { MongooseModule } no"@nestjs/mangoose";
imports { BookService } no'./books.service';
imports { BookResolver } no'./books.resolver';
imports { Grāmata, grāmatu shēma } no'./book.model';
@Modulis({
 pakalpojumu sniedzēji: [
 Grāmatu serviss,
 BookResolver
 ],
 imports: [MongooseModule.forFeature([
 {
 nosaukums: Book.name,
 shēma: BookSchema,
 },
 ]),
 ],
})
eksportētklasē Grāmatu modulis {}

Darbs ar mutācijām

Kamēr izmantojat vaicājumu, lai izgūtu datus programmā GraphQL, mutācijas izveido vai atjaunina datus datu bāzē. Lai izveidotu mutācijas, jums ir jāpieņem dati no lietotājiem. The Ievades veids Šeit noderēs dekorators, kas pārvērš klasi par GraphQL ievades veidu.

// book.input.ts
imports { Ievades veids, lauks } no'@nestjs/graphql';
@InputType()
eksportētklasē BookInput {
@lauks()
 virsraksts: virkne;
@lauks()
 autors: virkne;
@lauks()
 publicēšanas datums: Būla
}

Tagad varat atjaunināt books.resolver.ts lai izskatās šādi:

imports { Atrisinātājs, Vaicājums, Mutācija, Args, ID } no'@nestjs/graphql';
imports { Grāmata } no'./book.model';
imports { BookService } no'./books.service';
imports { BookInput } no'./book.input';
@Resolver(() => Grāmata)
eksportētklasē BookResolver {
konstruktors(Privāts Readonly bookService: BookService) { }
@Mutācija(() => Grāmata)
asinhrons izveidot grāmatu (@Args('ievade') ievade: BookInput): Apsolīt {
atgrieztiesšis.bookService.create (ievade);
 }
@Mutācija(() => Grāmata)
asinhrons updateBook(
@Args('id', { veids: () => ES izdarīju: virkne,
@Args('ievade') ievade: BookInput,
 ): Apsolīt {
atgrieztiesšis.bookService.update (id, ievade);
 }
@Mutācija(() => Grāmata)
asinhrons deleteBook(@Args('id', { veids: () => ES izdarīju: virkne): Apsolīt {
atgrieztiesšis.bookService.delete (id);
 }
}

Un grāmatas.pakalpojums.ts kā šis:

imports {Injicējams} no"@nestjs/common";
imports { InjectModel } no"@nestjs/mangoose";
imports { Modelis } no'mangusts';
imports { Grāmata, Grāmatu dokuments } no'./book.model';
@Injicējams()
eksportētklasē BookService {
konstruktors(@InjectModel(Book.name) Privāts grāmataModelis: modelis) { }
asinhrons izveidot (grāmata: grāmata): Apsolīt {
konst jauna grāmata = jaunsšis.bookModel (grāmata);
atgriezties newBook.save();
 }
asinhrons atjaunināt (id: virkne, grāmata: Grāmata): Apsolīt {
atgrieztiesšis.bookModel.findByIdAndUpdate (id, book, { jauns: taisnība }).exec();
 }
asinhronsdzēst(id: virkne): Apsolīt {
atgrieztiesšis.bookModel.findByIdAndDelete (id).exec();
 }
}

The @Mutācija dekorators iezīmē funkciju kā mutācijas veidu un @Args dekorators satver visas funkcijai nodotās ievades.

Visbeidzot, jums vajadzētu importēt Grāmatu modulis iekšā AppModule lai tas būtu funkcionāls. Jums vajadzētu arī nokārtot Grāmatu modulis uz forRootAsync kā redzams zemāk.

imports { BooksModule } no'./books/books.module';
/**
 * cits imports
*/
@Modulis({
 imports: [
 ConfigModule.forRoot({
 ielāde: [mongodbConfig],
 isGlobal: taisnība
 }),
 NestGraphQLModule.forRootAsync({
 vadītājs: ApolloDriver,
 inject: [ConfigService],
 useFactory: asinhrons (configService: ConfigService) => ({
 autoSchemaFile: pievienojieties (process.cwd(), "src/schema.gql"),
 installSubscriptionHandlers: taisnība,
 šķirošanas shēma: taisnība,
 rotaļu laukums: taisnība,
 atkļūdošana: configService.get<Būla>("ATkļūdošana"),
 augšupielādes: viltus,
 }),
 }),
 MongooseModule.forRootAsync({
 inject: [ConfigService],
 useFactory: asinhrons (configService: ConfigService) => ({
 uri: configService.get("MONGO_URI")
 })
 }),
 Grāmatu modulis,
 ],
 kontrolieri: [AppController],
 pakalpojumu sniedzēji: [AppService],
})
eksportētklasē AppModule {}

Jūs varat pārbaudīt kodu, palaižot npm palaišanas sākums: dev terminālī, un lietojumprogrammai vajadzētu veiksmīgi startēt portā 3000.

Atvērt localhost: 3000/graphql pārlūkprogrammā, lai parādītu Graphiql saskarne, kurā varat pārbaudīt vaicājumus un mutācijas. Šeit ir piemērs, kas parāda vaicājumu:

Un šeit ir mutācijas piemērs:

Izveidojiet efektīvas API, izmantojot NestJS un GraphQL

GraphQL API izveide NestJS ar MongoDB, izmantojot Mongoose, ietver GraphQL API shēmas, shēmas definēšanu. Mongoose modelim pakalpojums mijiedarbībai ar datu bāzi un atrisinātājs GraphQL operāciju kartēšanai pakalpojumā metodes.

NestJS ir iebūvēta funkcionalitāte API izveidei, tostarp dekoratori maršrutu noteikšanai, aizsargi to aizsardzībai un starpprogrammatūra pieprasījumu un atbilžu apstrādei. Tā atbalsta arī citas datu bāzes, piemēram, PostgreSQL, MySQL un SQLite, kā arī citas GraphQL bibliotēkas, piemēram, Apollo un TypeGraphQL.