Sukurkite savo API naudodami šias populiarias žiniatinklio technologijas.

„GraphQL“ ir „NestJS“ sudaro puikią partnerystę, suteikdamos tvirtą pagrindą jūsų API ir lengvai naudojamą sistemą, kuriant keičiamo dydžio žiniatinklio programas. Šis derinys puikiai tinka gamybai paruoštoms programėlėms kurti ir abi yra labai svarbios priemonės šiandieninėje technologijų ekosistemoje.

Sužinokite daugiau apie tai, kaip galite sukurti API naudodami abu produktus.

Kas yra GraphQL?

GraphQL yra duomenų užklausų ir manipuliavimo kalba Galite naudoti kurdami API tiksliau ir glausčiau. GraphQL pateikia išsamų ir adekvatų API esamų duomenų aprašymą ir suteikia klientui galią gauti tikslius reikalingus duomenis.

GraphQL suteikia daug funkcijų, kurių trūksta REST API, pradedant nuo tikslių duomenų užklausų iki geresnių kūrėjo įrankių, tokių kaip grafinis redaktorius. Tai taip pat leidžia pateikti užklausą dėl kelių išteklių per vieną užklausą.

Kas yra NestJS?

NestJS yra progresyvi Node.js sistema, kurią galite naudoti kurdami keičiamo dydžio ir efektyvias serverio programas. „NestJS“ teikia daugybę papildinių, taip pat greito ir lengvo kūrimo įrankius, įskaitant „GraphQL“ palaikymą, GRPC, „WebSockets“ ir kt.

instagram viewer

„NestJS“ yra gerai žinomas ekosistemoje dėl optimizuotos projektų struktūros, naudojant modulius, valdiklius, paslaugas ir schemas. Jo integruotas CLI leidžia sukurti struktūrizuotą API architektūrą. Tu gali naudoti priklausomybės injekcijos principai valdyti, kaip programos dalys susisiekia viena su kita.

„GraphQL“ diegimas naudojant „NestJS“ ir „MongoDB“.

Prieš kurdami API su NestJS ir GraphQL, turėsite turėti tinkamas priklausomybes. Tau reikia Norėdami įdiegti Node.js ir NestJS, kuriuos galite įdiegti paleisdami npm i -g @nestjs/cli.

Toliau pateiktas pavyzdys yra paprasta programa, kurioje saugoma informacija apie knygas. Paleiskite šią komandą savo terminale, kad sukurtumėte naują NestJS programą:

lizdas naujas

Eikite į sukurtos programos katalogą () ir įdiekite jo priklausomybes naudodami šią komandą:

$ npm įdiegti – išsaugoti @nestjs/config @nestjs/graphql graphql-tools graphql \
 @nestjs/apollo apollo-server-express @nestjs/mongoose @types/graphql

Yra du pagrindiniai GraphQL API kūrimo būdai, būtent:

  1. Pirmas schemos metodas: kur aprašote API schemos apibrėžimo failuose arba SDL, o „NestJS“ generuoja „Typescript“ apibrėžimus pagal juos.
  2. Pirmasis kodas: kur apibrėžiate užklausas, mutacijas ir kitas „GraphQL“ funkcijas naudodami „Typescript“ klases ir dekoratorius, o „NestJS“ generuoja SDL failus pagal juos.

Toliau pateiktame pavyzdyje aprašoma, kaip naudoti kodą pirmiausia.

Pirmiausia turite inicijuoti GraphQL savo AppModule ir prijunkite jį prie MongoDB duomenų bazės:

// app.module.ts
importuoti { Modulis } iš„@nestjs/common“;
importuoti { GraphQLMmodulis kaip NestGraphQLMmodulis } iš„@nestjs/graphql“;
importuoti { ApolloDriver, ApolloDriverConfig } iš„@nestjs/apollo“;
importuoti { prisijungti } iš'kelias';
importuoti { MongooseModule } iš„@nestjs/mangoose“;
importuoti { AppController } iš„./app.controller“;
importuoti { AppService } iš„./app.service“;
importuoti { ConfigModule, ConfigService } iš„@nestjs/config“;
importuoti mongodbConfig iš'./config/mongodb.config';
@Modulis({
 importas: [
 ConfigModule.forRoot({
 įkelti: [mongodbConfig],
 isGlobal: tiesa
 }),
 NestGraphQLModule.forRootAsync({
 vairuotojas: ApolloDriver,
 inject: [ConfigService],
 Naudokite gamyklą: async (configService: ConfigService) => ({
 autoSchemaFile: prisijungti (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: tiesa,
 rūšiavimo schema: tiesa,
 žaidimų aikštelė: tiesa,
 derinimas: configService.get<loginis>("DEBUG"),
 įkėlimai: klaidinga,
 }),
 }),
 MongooseModule.forRootAsync({
 inject: [ConfigService],
 Naudokite gamyklą: async (configService: ConfigService) => ({
 uri: configService.get(„MONGO_URI“)
 })
 }),
 ],
 valdikliai: [AppController],
 teikėjai: [AppService],
})
eksportuotiklasė AppModule {}

Šis modulis importuoja GraphQLMmodulis iš @nestjs/graphql ir MongooseModule iš @nestjs/mongoose kuri padeda prisijungti prie MongoDB. The autoSchemaFile ypatybė nurodo sugeneruoto schemos failo vietą ir rūšiuotischema nuosavybė užtikrina, kad laukai būtų išdėstyti abėcėlės tvarka.

Štai koks yra jūsų MongoDB konfig failas turėtų atrodyti taip:

importuoti {registruotis kaip } iš„@nestjs/config“;
/**
 * Mongo duomenų bazės ryšio konfigūracija
 */
eksportuotinumatytas registerAs("mongodb", () => {
konst {
 MONGO_URI
 } = procesas.env;
grąžinti {
 uri: `${MONGO_URI}`,
 };
});

GraphQL schemos apibrėžimas

Nustatę GraphQL ir MongoDB ryšius, turėtumėte apibrėžti GraphQL užklausas ir mutacijas, kad sukurtumėte schemą (schema.gql) failą.

Užklausų rašymas

Viduje pirmasis kodas, sukuriate modelį naudodami Objekto tipas dekoratorius. Vėliau šį modelį pakeisite į GraphQL tipą.

Pavyzdžiui:

// knyga.modelis.ts
importuoti { Laukas, objekto tipas } iš„@nestjs/graphql“;
importuoti { Prop, Schema, SchemaFactory } iš„@nestjs/mangoose“;
importuoti { dokumentas } iš"mangustas";
eksportuotitipo BookDocument = knyga ir dokumentas;


@ObjectType()
@Schema()
eksportuotiklasė Knyga {
@laukas()
 pavadinimas: styga;


@laukas()
 autorius: styga;


@laukas()
 paskelbimo data: loginis;
}
eksportuotikonst BookSchema = SchemaFactory.createForClass (knyga);

GraphQL pagal numatytuosius nustatymus negali naudoti sukurtų schemų. Kad jie veiktų, jums reikia sprendimo paslaugos, kurioje yra GraphQL tipų vykdymo funkcijos. Tai galite padaryti su Sprendimas dekoratorius.

// books.resolver.ts
importuoti { Resolver, Query, Mutation, Args, ID } iš„@nestjs/graphql“;
importuoti { Knyga } iš'./book.model';
importuoti { Knygų paslauga } iš„./books.service“;
@Resolver(() => Knyga)
eksportuotiklasė BookResolver {
konstruktorius(privatus Readonly bookService: BookService) { }


@Užklausa(() => [Knyga])
async knygos (): Pažadas {
grąžintitai.bookService.findAll();
 }
@Užklausa(() => Knyga)
async knyga(@Args('id', { tipo: () => Aš padariau: styga): Pažadas {
grąžintitai.bookService.findOne (id);
 }
}

Galite įgyvendinti Knygų tarnyba, importuotas aukščiau, kaip nurodyta toliau:

// books.service.ts
importuoti { Injekcinis } iš„@nestjs/common“;
importuoti { InjectModel } iš„@nestjs/mangoose“;
importuoti { Modelis } iš"mangustas";
importuoti { knyga, knygos dokumentas } iš'./book.model';
@Injekcinis()
eksportuotiklasė BookService {
konstruktorius(@InjectModel(knyga.pavadinimas) privatus knygaModelis: modelis) { }


async rasti viską (): Pažadas {
grąžintitai.bookModel.find().exec();
 }
async findOne (id: styga): Pažadas {
grąžintitai.bookModel.findById (id).exec();
 }
}

Taip pat turite įtraukti „BookResolver“ į paslaugų teikėjų sąrašą knygos.modulis.ts.

importuoti { Modulis } iš„@nestjs/common“;
importuoti { MongooseModule } iš„@nestjs/mongoose“;
importuoti { Knygų paslauga } iš„./books.service“;
importuoti { BookResolver } iš„./books.resolver“;
importuoti { Knyga, knygų schema } iš'./book.model';
@Modulis({
 teikėjai: [
 Knygų tarnyba,
 BookResolver
 ],
 importai: [MongooseModule.forFeature([
 {
 vardas: knyga.vardas,
 schema: BookSchema,
 },
 ]),
 ],
})
eksportuotiklasė Knygų modulis {}

Darbas su mutacijomis

Kai naudojate užklausą duomenims gauti GraphQL, mutacijos sukuria arba atnaujina duomenis duomenų bazėje. Norėdami sukurti mutacijas, turite priimti duomenis iš vartotojų. The Įvesties tipas Čia pravers dekoratorius, kuris klasę paverčia GraphQL įvesties tipu.

// book.input.ts
importuoti { Įvesties tipas, laukas } iš„@nestjs/graphql“;
@InputType()
eksportuotiklasė BookInput {
@laukas()
 pavadinimas: styga;


@laukas()
 autorius: styga;
@laukas()
 paskelbimo data: loginis
}

Dabar galite atnaujinti knygos.resolver.ts atrodyti taip:

importuoti { Resolver, Query, Mutation, Args, ID } iš„@nestjs/graphql“;
importuoti { Knyga } iš'./book.model';
importuoti { Knygų paslauga } iš„./books.service“;
importuoti { BookInput } iš'./book.input';
@Resolver(() => Knyga)
eksportuotiklasė BookResolver {
konstruktorius(privatus Readonly bookService: BookService) { }


@Mutacija(() => Knyga)
async sukurti knygą (@Args("įvestis") įvestis: BookInput): Pažadas {
grąžintitai.bookService.create (įvestis);
 }


@Mutacija(() => Knyga)
async atnaujinti knygą (
@Args('id', { tipo: () => Aš padariau: styga,
@Args("įvestis") įvestis: BookInput,
 ): Pažadas {
grąžintitai.bookService.update (id, įvestis);
 }
@Mutacija(() => Knyga)
async ištrinti knygą (@Args('id', { tipo: () => Aš padariau: styga): Pažadas {
grąžintitai.bookService.delete (id);
 }
}

Ir knygos.paslaugos.ts kaip šitas:

importuoti { Injekcinis } iš„@nestjs/common“;
importuoti { InjectModel } iš„@nestjs/mangoose“;
importuoti { Modelis } iš"mangustas";
importuoti { knyga, knygos dokumentas } iš'./book.model';
@Injekcinis()
eksportuotiklasė BookService {
konstruktorius(@InjectModel(knyga.pavadinimas) privatus knygaModelis: modelis) { }


async sukurti (knyga: knyga): Pažadas {
konst nauja knyga = naujastai.bookModel (knyga);
grąžinti newBook.save();
 }


async atnaujinti (id: styga, knyga: knyga): Pažadas {
grąžintitai.bookModel.findByIdAndUpdate (id, knyga, { naujas: tiesa }).exec();
 }
asyncIštrinti(id: styga): Pažadas {
grąžintitai.bookModel.findByIdAndDelete (id).exec();
 }
}

The @Mutacija dekoratorius pažymi funkciją kaip mutacijos tipą ir @Args dekoratorius sugriebia visus įvestį, perduotą funkcijai.

Galiausiai turėtumėte importuoti Knygų modulis į AppModule kad jis būtų funkcionalus. Taip pat turėtumėte praeiti Knygų modulis į forRootAsync kaip matyti žemiau.

importuoti { BooksModule } iš„./books/books.module“;
/**
 * kitas importas
*/
@Modulis({
 importas: [
 ConfigModule.forRoot({
 įkelti: [mongodbConfig],
 isGlobal: tiesa
 }),
 NestGraphQLModule.forRootAsync({
 vairuotojas: ApolloDriver,
 inject: [ConfigService],
 Naudokite gamyklą: async (configService: ConfigService) => ({
 autoSchemaFile: prisijungti (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: tiesa,
 rūšiavimo schema: tiesa,
 žaidimų aikštelė: tiesa,
 derinimas: configService.get<loginis>("DEBUG"),
 įkėlimai: klaidinga,
 }),
 }),
 MongooseModule.forRootAsync({
 inject: [ConfigService],
 Naudokite gamyklą: async (configService: ConfigService) => ({
 uri: configService.get(„MONGO_URI“)
 })
 }),
 Knygų modulis,
 ],
 valdikliai: [AppController],
 teikėjai: [AppService],
})
eksportuotiklasė AppModule {}

Galite išbandyti kodą paleisdami npm paleisties pradžia: dev terminale, o programa turėtų sėkmingai paleisti prievadą 3000.

Atviras localhost: 3000/graphql naršyklėje, kad būtų rodoma Graphiql sąsaja, kurioje galite išbandyti užklausas ir mutacijas. Štai pavyzdys, rodantis užklausą:

Ir čia yra mutacijos pavyzdys:

Kurkite efektyvias API naudodami „NestJS“ ir „GraphQL“.

Kuriant GraphQL API NestJS su MongoDB naudojant Mongoose, reikia apibrėžti GraphQL API schemą, schemą Mongoose modeliui – paslauga, skirta sąveikai su duomenų baze, ir sprendiklis, skirtas GraphQL operacijoms susieti su paslauga metodus.

„NestJS“ turi integruotas API kūrimo funkcijas, įskaitant dekoratorius, skirtas maršrutams apibrėžti, apsaugas, skirtas juos apsaugoti, ir tarpinę programinę įrangą, skirtą užklausoms ir atsakymams tvarkyti. Ji taip pat palaiko kitas duomenų bazes, tokias kaip PostgreSQL, MySQL ir SQLite, taip pat kitas GraphQL bibliotekas, tokias kaip Apollo ir TypeGraphQL.