Nende populaarsete veebitehnoloogiate abil saate luua oma API.

GraphQL ja NestJS loovad suurepärase partnerluse, andes teile API-dele tugeva aluse ja hõlpsasti kasutatava raamistiku skaleeritavate veebirakenduste loomiseks. Kombinatsioon sobib suurepäraselt tootmisvalmis rakenduste loomiseks ja mõlemad on tänapäeva tehnoloogilises ökosüsteemis väga asjakohased tööriistad.

Vaadake lisateavet selle kohta, kuidas saate mõlemat toodet kasutades API luua.

Mis on GraphQL?

GraphQL on andmepäringu- ja manipuleerimiskeel saate API-de täpsemaks ja kokkuvõtlikumaks koostamiseks kasutada. GraphQL pakub API-s olemasolevate andmete täielikku ja adekvaatset kirjeldust ning annab kliendile õiguse hankida täpsed vajalikud andmed.

GraphQL pakub palju funktsioone, mis REST API-del puuduvad, alates täpsetest andmepäringutest kuni paremate arendaja tööriistadeni, nagu graphiql toimetaja. Samuti võimaldab see ühe päringu kaudu teha päringuid mitme ressursi kohta.

Mis on NestJS?

NestJS on progressiivne Node.js raamistik, mida saate kasutada skaleeritavate ja tõhusate serveripoolsete rakenduste loomiseks. NestJS pakub palju pistikprogramme ning tööriistu kiireks ja lihtsaks arendamiseks, sealhulgas GraphQL-i tugi, GRPC, WebSockets jne.

instagram viewer

NestJS on ökosüsteemis hästi tuntud oma optimeeritud projektistruktuuri poolest, mis kasutab mooduleid, kontrollereid, teenuseid ja skeeme. Selle sisseehitatud CLI võimaldab teil luua struktureeritud API arhitektuuri. Sa võid kasutada sõltuvuse süstimise põhimõtted et kontrollida, kuidas rakenduse osad omavahel suhtlevad.

GraphQL-i rakendamine NestJS-i ja MongoDB-ga

Enne API loomist NestJS-i ja GraphQL-iga peavad teil olema saadaval õiged sõltuvused. Sa vajad Node.js installimiseks ja NestJS, mille saate käivitades installida npm i -g @nestjs/cli.

Järgnev näide on lihtne rakendus, mis salvestab raamatute kohta teavet. Uue NestJS-i rakenduse loomiseks käivitage oma terminalis järgmine käsk:

pesa uus

Liikuge loodud rakenduse kataloogi () ja installige selle sõltuvused järgmise käsuga:

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

GraphQL API-de loomiseks on kaks peamist lähenemisviisi, nimelt:

  1. Skeemi esimene lähenemine: kus kirjeldate API-t skeemi definitsioonifailides või SDL-is ja NestJS genereerib nende põhjal Typescripti definitsioonid.
  2. Koodi esimene lähenemine: kus saate Typescripti klasse ja dekoraatoreid kasutades määratleda päringuid, mutatsioone ja muid GraphQL-i funktsioone ning NestJS genereerib nende põhjal SDL-faile.

Järgmises näites kirjeldatakse koodipõhise lähenemisviisi kasutamist.

Esiteks peate oma GraphQL-i lähtestama AppModule ja ühendage see MongoDB andmebaasiga:

// app.module.ts
importida { Moodul } alates„@nestjs/common”;
importida { GraafikQLMmoodul nagu NestGraphQLModul } alates'@nestjs/graphql';
importida { ApolloDriver, ApolloDriverConfig } alates'@nestjs/apollo';
importida {liitu} alates'tee';
importida { MongooseModule } alates„@nestjs/mongoose”;
importida { AppController } alates'./app.controller';
importida { AppService } alates'./app.service';
importida { ConfigModule, ConfigService } alates'@nestjs/config';
importida mongodbConfig alates'./config/mongodb.config';
@Moodul({
 import: [
 ConfigModule.forRoot({
 laadimine: [mongodbConfig],
 on ülemaailmne: tõsi
 }),
 NestGraphQLModule.forRootAsync({
 juht: ApolloDriver,
 süstige: [ConfigService],
 useFactory: asünkr (configService: ConfigService) => ({
 autoSchemaFile: liitu (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: tõsi,
 sortiskeem: tõsi,
 mänguväljak: tõsi,
 silumine: configService.get<tõeväärtus>("DEBUG"),
 üleslaadimised: vale,
 }),
 }),
 MongooseModule.forRootAsync({
 süstige: [ConfigService],
 useFactory: asünkr (configService: ConfigService) => ({
 uri: configService.get('MONGO_URI')
 })
 }),
 ],
 kontrollerid: [AppController],
 pakkujad: [AppService],
})
eksportidaklass AppModule {}

See moodul impordib GraafikQLMmoodul alates @nestjs/graphql ja Mongoose moodul alates @nestjs/mongoose mis aitab luua ühenduse MongoDB-ga. The autoSchemaFile atribuut määrab loodud skeemifaili asukoha ja sortiskeem omadus tagab, et see järjestab väljad tähestikulises järjekorras.

Siin on teie MongoDB konfig fail peaks välja nägema selline:

importida { registerAs } alates'@nestjs/config';
/**
 * Mongo andmebaasi ühenduse konfiguratsioon
 */
eksportidavaikimisi registerAs('mongodb', () => {
konst {
 MONGO_URI
 } = protsess.env;
tagasi {
 uri: `${MONGO_URI}`,
 };
});

GraphQL-i skeemi määratlemine

Pärast GraphQL-i ja MongoDB-ühenduste seadistamist peaksite skeemi loomiseks määratlema GraphQL-i päringud ja mutatsioonid (schema.gql) faili.

Päringute kirjutamine

Aastal kood-esimene lähenemine, loote mudeli kasutades Objekti tüüp dekoraator. Hiljem muudate selle mudeli GraphQL-i tüübiks.

Näiteks:

// book.model.ts
importida { Väli, objekti tüüp } alates'@nestjs/graphql';
importida { Prop, Schema, SchemaFactory } alates„@nestjs/mongoose”;
importida { dokument } alates"mongoose";
eksportidatüüp BookDocument = raamat ja dokument;


@ObjectType()
@Skeemi()
eksportidaklass raamat {
@Põld()
 pealkiri: string;


@Põld()
 autor: string;


@Põld()
 avaldamise kuupäev: tõeväärtus;
}
eksportidakonst BookSchema = SchemaFactory.createForClass (raamat);

GraphQL ei saa vaikimisi loodud skeeme kasutada. Nende funktsioneerimiseks vajate lahendamisteenust, mis sisaldab GraphQL-i tüüpide täitmise funktsioone. Seda saate teha rakendusega Lahendaja dekoraator.

// books.resolver.ts
importida { Lahendaja, päring, mutatsioon, argumendid, ID } alates'@nestjs/graphql';
importida { Raamat } alates'./book.modell';
importida { Raamatuteenus } alates'./books.service';
@Resolver(() => raamat)
eksportidaklass BookResolver {
konstruktor(privaatne kirjutuskaitstud raamatuteenus: BookService) { }


@päring(() => [Raamat])
asünkr raamatud (): Lubadus {
tagasisee.bookService.findAll();
 }
@päring(() => raamat)
asünkr raamat (@Args('id', { tüüp: () => Ma tegin: string): Lubadus {
tagasisee.bookService.findOne (id);
 }
}

Saate rakendada Raamatuteenus, imporditud eespool järgmiselt:

// books.service.ts
importida { Süstitav } alates„@nestjs/common”;
importida { InjectModel } alates„@nestjs/mongoose”;
importida { Mudel } alates"mongoose";
importida { Raamat, raamatudokument } alates'./book.modell';
@Süstitav()
eksportidaklass BookService {
konstruktor(@InjectModel(Book.name) privaatne raamatMudel: mudel) { }


asünkr leia kõik(): Lubadus {
tagasisee.bookModel.find().exec();
 }
asünkr findOne (id: string): Lubadus {
tagasisee.bookModel.findById (id).exec();
 }
}

Samuti peate lisama BookResolveri teenusepakkujate loendisse raamatud.moodul.ts.

importida { Moodul } alates"@nestjs/common";
importida { MongooseModule } alates"@nestjs/mongoose";
importida { Raamatuteenus } alates'./books.service';
importida { BookResolver } alates'./books.resolver';
importida { Raamat, BookSchema } alates'./book.modell';
@Moodul({
 pakkujad: [
 Raamatuteenus,
 BookResolver
 ],
 impordid: [MongooseModule.forFeature([
 {
 nimi: Book.name,
 skeem: BookSchema,
 },
 ]),
 ],
})
eksportidaklass Raamatute moodul {}

Mutatsioonidega töötamine

Kui kasutate GraphQL-is andmete toomiseks päringut, loovad või värskendavad mutatsioonid andmebaasis andmeid. Mutatsioonide loomiseks peate aktsepteerima kasutajate andmeid. The Sisendtüüp dekoraator, mis muudab klassi GraphQL-i sisenditüübiks, on siin kasulik.

// book.input.ts
importida { InputType, Field } alates'@nestjs/graphql';
@InputType()
eksportidaklass BookInput {
@Põld()
 pealkiri: string;


@Põld()
 autor: string;
@Põld()
 avaldamise kuupäev: tõeväärtus
}

Nüüd saate värskendada books.resolver.ts välja nägema selline:

importida { Lahendaja, päring, mutatsioon, argumendid, ID } alates'@nestjs/graphql';
importida { Raamat } alates'./book.modell';
importida { Raamatuteenus } alates'./books.service';
importida { BookInput } alates'./book.input';
@Resolver(() => raamat)
eksportidaklass BookResolver {
konstruktor(privaatne kirjutuskaitstud raamatuteenus: BookService) { }


@Mutatsioon(() => raamat)
asünkr looraamat(@Args('sisend') sisend: BookInput): Lubadus {
tagasisee.bookService.create (sisend);
 }


@Mutatsioon(() => raamat)
asünkr updateBook(
@Args('id', { tüüp: () => Ma tegin: string,
@Args('sisend') sisend: BookInput,
 ): Lubadus {
tagasisee.bookService.update (id, sisend);
 }
@Mutatsioon(() => raamat)
asünkr deleteBook(@Args('id', { tüüp: () => Ma tegin: string): Lubadus {
tagasisee.bookService.delete (id);
 }
}

Ja raamatud.teenus.ts nagu nii:

importida { Süstitav } alates„@nestjs/common”;
importida { InjectModel } alates„@nestjs/mongoose”;
importida { Mudel } alates"mongoose";
importida { Raamat, raamatudokument } alates'./book.modell';
@Süstitav()
eksportidaklass BookService {
konstruktor(@InjectModel(Book.name) privaatne raamatMudel: mudel) { }


asünkr loo (raamat: raamat): Lubadus {
konst uus raamat = uussee.bookModel (raamat);
tagasi newBook.save();
 }


asünkr värskendus (id: string, raamat: Raamat): Lubadus {
tagasisee.bookModel.findByIdAndUpdate (id, raamat, { uus: tõsi }).exec();
 }
asünkrkustutada(id: string): Lubadus {
tagasisee.bookModel.findByIdAndDelete (id).exec();
 }
}

The @Mutatsioon dekoraator märgib funktsiooni mutatsioonitüübina ja @Args dekoraator haarab kõik funktsioonile edastatud sisendid.

Lõpuks peaksite importima Raamatute moodul sisse AppModule et see oleks funktsionaalne. Samuti peaksite läbima Raamatute moodul juurde forRootAsync nagu allpool näha.

importida { BooksModule } alates'./books/books.module';
/**
 * muu import
*/
@Moodul({
 import: [
 ConfigModule.forRoot({
 laadimine: [mongodbConfig],
 on ülemaailmne: tõsi
 }),
 NestGraphQLModule.forRootAsync({
 juht: ApolloDriver,
 süstige: [ConfigService],
 useFactory: asünkr (configService: ConfigService) => ({
 autoSchemaFile: liitu (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: tõsi,
 sortiskeem: tõsi,
 mänguväljak: tõsi,
 silumine: configService.get<tõeväärtus>("DEBUG"),
 üleslaadimised: vale,
 }),
 }),
 MongooseModule.forRootAsync({
 süstige: [ConfigService],
 useFactory: asünkr (configService: ConfigService) => ({
 uri: configService.get('MONGO_URI')
 })
 }),
 Raamatute moodul,
 ],
 kontrollerid: [AppController],
 pakkujad: [AppService],
})
eksportidaklass AppModule {}

Saate koodi testida käivitades npm käivitamise algus: dev terminalis ja teie rakendus peaks pordis edukalt käivituma 3000.

Avatud localhost: 3000/graphql brauseris, et kuvada Graafika liides, kus saate päringuid ja mutatsioone testida. Siin on näide, mis näitab päringut:

Ja siin on näide mutatsioonist:

Tõhusate API-de loomine NestJS-i ja GraphQL-iga

GraphQL API loomine NestJS-is MongoDB-ga Mongoose'i abil hõlmab GraphQL API jaoks skeemi määratlemist, skeemi. Mongoose mudeli jaoks teenus andmebaasiga suhtlemiseks ja lahendaja GraphQL-i toimingute kaardistamiseks teenusega meetodid.

NestJS-il on API-de loomiseks sisseehitatud funktsioon, sealhulgas dekoraatorid marsruutide määratlemiseks, valvurid nende kaitsmiseks ning vahevara päringute ja vastuste käsitlemiseks. See toetab ka teisi andmebaase, nagu PostgreSQL, MySQL ja SQLite, aga ka muid GraphQL-i teeke, nagu Apollo ja TypeGraphQL.