Vytvorte si vlastné API pomocou týchto populárnych webových technológií.

GraphQL a NestJS tvoria vynikajúce partnerstvo a poskytujú vám pevný základ pre vaše rozhrania API a ľahko použiteľný rámec na vytváranie škálovateľných webových aplikácií. Táto kombinácia je ideálna na vytváranie aplikácií pripravených na výrobu a obe sú veľmi dôležitými nástrojmi v dnešnom technologickom ekosystéme.

Zistite viac o tom, ako môžete vytvoriť API pomocou oboch produktov.

Čo je GraphQL?

GraphQL je jazyk dopytovania a manipulácie s údajmi môžete použiť na vytváranie rozhraní API presnejším a stručnejším spôsobom. GraphQL poskytuje úplný a primeraný popis údajov existujúcich v rozhraní API a poskytuje klientovi možnosť získať presné potrebné údaje.

GraphQL poskytuje mnoho funkcií, ktoré REST API chýbajú, od presných dátových dotazov až po lepšie nástroje pre vývojárov, ako napr. graphiql editor. Umožňuje vám tiež dotazovať sa na viacero zdrojov prostredníctvom jednej požiadavky.

Čo je NestJS?

NestJS je progresívny rámec Node.js, ktorý môžete použiť na vytváranie škálovateľných a efektívnych aplikácií na strane servera. NestJS poskytuje mnoho doplnkov spolu s nástrojmi na rýchly a jednoduchý vývoj vrátane podpory GraphQL, GRPC, WebSockets atď.

instagram viewer

NestJS je v ekosystéme dobre známy pre svoju optimalizovanú štruktúru projektov využívajúcu moduly, ovládače, služby a schémy. Jeho vstavané CLI vám umožňuje vytvoriť štruktúrovanú architektúru API. Môžeš použiť princípy injekcie závislosti na ovládanie toho, ako časti aplikácie medzi sebou komunikujú.

Implementácia GraphQL pomocou NestJS a MongoDB

Pred vytvorením rozhrania API s NestJS a GraphQL musíte mať k dispozícii správne závislosti. Potrebuješ na inštaláciu Node.js a NestJS, ktoré si môžete nainštalovať spustením npm i -g @nestjs/cli.

Nasledujúci príklad je jednoduchá aplikácia, ktorá ukladá informácie o knihách. Spustite nasledujúci príkaz vo svojom termináli a vytvorte novú aplikáciu NestJS:

hniezdo nové

Prejdite do adresára vygenerovanej aplikácie () a nainštalujte jeho závislosti pomocou nasledujúceho príkazu:

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

Existujú dva hlavné prístupy k budovaniu GraphQL API, a to:

  1. Schema-first prístup: kde popisujete API v súboroch definície schém alebo SDL a NestJS na nich generuje definície Typescript.
  2. Prístup založený na kóde: kde definujete dotazy, mutácie a ďalšie funkcie GraphQL pomocou tried Typescript a dekorátorov a NestJS na ich základe generuje súbory SDL.

Nasledujúci príklad popisuje, ako používať prístup založený na kóde.

Najprv musíte inicializovať GraphQL vo svojom AppModule a pripojte ho k databáze MongoDB:

// app.module.ts
importovať { Modul } od'@nestjs/common';
importovať { GraphQLModule ako NestGraphQLModule } od'@nestjs/graphql';
importovať { ApolloDriver, ApolloDriverConfig } od'@nestjs/apollo';
importovať { pripojiť sa } od'cesta';
importovať { MongooseModule } od'@nestjs/mongoose';
importovať { AppController } od'./app.controller';
importovať { AppService } od'./app.service';
importovať { ConfigModule, ConfigService } od'@nestjs/config';
importovať mongodbConfig od'./config/mongodb.config';
@Modul({
 dovoz: [
 ConfigModule.forRoot({
 zaťaženie: [mongodbConfig],
 isGlobal: pravda
 }),
 NestGraphQLModule.forRootAsync({
 vodič: ApolloDriver,
 vložiť: [ConfigService],
 useFactory: async (configService: ConfigService) => ({
 autoSchemaFile: join (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: pravda,
 sortSchema: pravda,
 ihrisko: pravda,
 ladenie: configService.get<boolovská hodnota>("LADENIE"),
 nahrané videá: falošný,
 }),
 }),
 MongooseModule.forRootAsync({
 vložiť: [ConfigService],
 useFactory: async (configService: ConfigService) => ({
 uri: configService.get(„MONGO_URI“)
 })
 }),
 ],
 ovládače: [AppController],
 poskytovatelia: [AppService],
})
exporttrieda AppModule {}

Tento modul importuje GraphQLModule od @nestjs/graphql a MongooseModule od @nestjs/mongoose ktorý pomáha pripojiť sa k MongoDB. The autoSchemaFile vlastnosť určuje umiestnenie vygenerovaného súboru schémy a sortSchema vlastnosť zabezpečuje, že zoradí polia podľa abecedy.

Tu je váš MongoDB config súbor by mal vyzerať takto:

importovať { registerAs } od'@nestjs/config';
/**
 * Konfigurácia pripojenia k databáze Mongo
 */
exportpredvolená registerAs('mongodb', () => {
konšt {
 MONGO_URI
 } = process.env;
vrátiť {
 uri: `${MONGO_URI}`,
 };
});

Definovanie schémy GraphQL

Po nastavení pripojení GraphQL a MongoDB by ste mali definovať dotazy a mutácie GraphQL na vytvorenie schémy (schema.gql) súbor.

Písanie otázok

V prístup založený na kóde, vytvoríte model pomocou ObjectType dekoratér. Tento model neskôr transformujete na typ GraphQL.

Napríklad:

// book.model.ts
importovať { Field, ObjectType } od'@nestjs/graphql';
importovať { Prop, Schema, SchemaFactory } od'@nestjs/mongoose';
importovať { Dokument } od"mongoose";
exporttypu BookDocument = Kniha a dokument;


@ObjectType()
@Schema()
exporttrieda Kniha {
@Lúka()
 názov: reťazec;


@Lúka()
 autor: reťazec;


@Lúka()
 Dátum zverejnenia: boolovská hodnota;
}
exportkonšt BookSchema = SchemaFactory.createForClass (kniha);

GraphQL štandardne nemôže použiť vytvorené schémy. Aby boli funkčné, potrebujete službu resolvera, ktorá obsahuje funkcie na vykonávanie typov GraphQL. Môžete tak urobiť pomocou Resolver dekoratér.

// books.resolver.ts
importovať { Resolver, Query, Mutation, Args, ID } od'@nestjs/graphql';
importovať { Kniha } od'./book.model';
importovať { BookService } od'./books.service';
@Resolver(() => kniha)
exporttrieda BookResolver {
konštruktér(súkromné readonly bookService: BookService) { }


@Dopyt(() => [kniha])
async knihy(): Sľub {
vrátiťtoto.bookService.findAll();
 }
@Dopyt(() => kniha)
async kniha (@Args('id', { typu: () => Urobil som: reťazec): Sľub {
vrátiťtoto.bookService.findOne (id);
 }
}

Môžete implementovať BookService, dovezené vyššie, takto:

// books.service.ts
importovať { Injekčné } od'@nestjs/common';
importovať { InjectModel } od'@nestjs/mongoose';
importovať { Model } od"mongoose";
importovať { Book, BookDocument } od'./book.model';
@Injekčné()
exporttrieda BookService {
konštruktér(@InjectModel(názov knihy) súkromné knihaModel: Modelka) { }


async findAll(): Sľub {
vrátiťtoto.bookModel.find().exec();
 }
async findOne (id: reťazec): Sľub {
vrátiťtoto.bookModel.findById (id).exec();
 }
}

Musíte tiež pridať BookResolver do zoznamu poskytovateľov v books.module.ts.

importovať { Modul } od"@nestjs/common";
importovať { MongooseModule } od"@nestjs/mongoose";
importovať { BookService } od'./books.service';
importovať { BookResolver } od'./books.resolver';
importovať { Book, BookSchema } od'./book.model';
@Modul({
 poskytovatelia: [
 knižný servis,
 BookResolver
 ],
 importuje: [MongooseModule.forFeature([
 {
 meno: Book.name,
 schéma: BookSchema,
 },
 ]),
 ],
})
exporttrieda BooksModul {}

Práca s mutáciami

Zatiaľ čo používate dotaz na získanie údajov v GraphQL, mutácie vytvárajú alebo aktualizujú údaje v databáze. Ak chcete vytvoriť mutácie, musíte prijať údaje od používateľov. The InputType tu príde vhod dekorátor, ktorý triedu zmení na typ vstupu GraphQL.

// book.input.ts
importovať { InputType, Field } od'@nestjs/graphql';
@InputType()
exporttrieda BookInput {
@Lúka()
 názov: reťazec;


@Lúka()
 autor: reťazec;
@Lúka()
 Dátum zverejnenia: boolovská hodnota
}

Teraz môžete aktualizovať books.resolver.ts vyzerať takto:

importovať { Resolver, Query, Mutation, Args, ID } od'@nestjs/graphql';
importovať { Kniha } od'./book.model';
importovať { BookService } od'./books.service';
importovať { BookInput } od'./book.input';
@Resolver(() => kniha)
exporttrieda BookResolver {
konštruktér(súkromné readonly bookService: BookService) { }


@Mutácia(() => kniha)
async vytvoriť knihu(@Args('vstup') vstup: BookInput): Sľub {
vrátiťtoto.bookService.create (vstup);
 }


@Mutácia(() => kniha)
async updateBook(
@Args('id', { typu: () => Urobil som: reťazec,
@Args('vstup') vstup: BookInput,
 ): Sľub {
vrátiťtoto.bookService.update (id, vstup);
 }
@Mutácia(() => kniha)
async deleteBook(@Args('id', { typu: () => Urobil som: reťazec): Sľub {
vrátiťtoto.bookService.delete (id);
 }
}

A books.service.ts Páči sa ti to:

importovať { Injekčné } od'@nestjs/common';
importovať { InjectModel } od'@nestjs/mongoose';
importovať { Model } od"mongoose";
importovať { Book, BookDocument } od'./book.model';
@Injekčné()
exporttrieda BookService {
konštruktér(@InjectModel(názov knihy) súkromné knihaModel: Modelka) { }


async vytvoriť (kniha: kniha): Sľub {
konšt nová kniha = Novýtoto.knihaModel (kniha);
vrátiť newBook.save();
 }


async aktualizácia (id: reťazec, kniha: Kniha): Sľub {
vrátiťtoto.bookModel.findByIdAndUpdate (id, kniha, { Nový: pravda }).exec();
 }
asyncvymazať(id: reťazec): Sľub {
vrátiťtoto.bookModel.findByIdAndDelete (id).exec();
 }
}

The @Mutácia dekoratér označuje funkciu ako typ mutácie a @Args dekoratér zachytáva všetky vstupy odovzdané do funkcie.

Nakoniec by ste mali importovať BooksModule do AppModule aby to bolo funkčné. Mali by ste tiež prejsť BooksModule do forRootAsync ako je vidieť nižšie.

importovať { BooksModule } od'./books/books.module';
/**
 * iný dovoz
*/
@Modul({
 dovoz: [
 ConfigModule.forRoot({
 zaťaženie: [mongodbConfig],
 isGlobal: pravda
 }),
 NestGraphQLModule.forRootAsync({
 vodič: ApolloDriver,
 vložiť: [ConfigService],
 useFactory: async (configService: ConfigService) => ({
 autoSchemaFile: join (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: pravda,
 sortSchema: pravda,
 ihrisko: pravda,
 ladenie: configService.get<boolovská hodnota>("LADENIE"),
 nahrané videá: falošný,
 }),
 }),
 MongooseModule.forRootAsync({
 vložiť: [ConfigService],
 useFactory: async (configService: ConfigService) => ({
 uri: configService.get(„MONGO_URI“)
 })
 }),
 BooksModule,
 ],
 ovládače: [AppController],
 poskytovatelia: [AppService],
})
exporttrieda AppModule {}

Kód môžete otestovať spustením štart chodu npm: dev vo vašom termináli a vaša aplikácia by sa mala úspešne spustiť na porte 3000.

OTVORENÉ localhost: 3000/graphql vo vašom prehliadači, aby ste zobrazili Graphiql rozhranie, kde môžete testovať dotazy a mutácie. Tu je príklad, ktorý zobrazuje dopyt:

A tu je príklad mutácie:

Vytvárajte efektívne rozhrania API s NestJS a GraphQL

Vytvorenie rozhrania GraphQL API v NestJS s MongoDB pomocou Mongoose zahŕňa definovanie schémy pre GraphQL API, schému pre model Mongoose služba na interakciu s databázou a resolver na mapovanie operácií GraphQL na službu metódy.

NestJS má vstavanú funkciu na vytváranie API, vrátane dekorátorov na definovanie trás, strážcov na ich ochranu a middleware na spracovanie požiadaviek a odpovedí. Podporuje aj iné databázy ako PostgreSQL, MySQL a SQLite, ako aj ďalšie knižnice GraphQL ako Apollo a TypeGraphQL.