Vytvořte si vlastní API pomocí těchto populárních webových technologií.

GraphQL a NestJS tvoří vynikající partnerství, které vám poskytuje pevný základ pro vaše API a snadno použitelný rámec pro vytváření škálovatelných webových aplikací. Tato kombinace je ideální pro vytváření aplikací připravených k produkci a oba jsou velmi relevantními nástroji v dnešním technologickém ekosystému.

Zjistěte více o tom, jak můžete vytvořit API pomocí obou produktů.

Co je GraphQL?

GraphQL je jazyk pro dotazování a manipulaci s daty můžete použít k vytvoření rozhraní API přesnějším a stručnějším způsobem. GraphQL poskytuje úplný a adekvátní popis dat existujících v API a dává klientovi moc získat přesná potřebná data.

GraphQL poskytuje mnoho funkcí, které REST API postrádají, od přesných datových dotazů po lepší vývojářské nástroje, jako je např. graphiql editor. Umožňuje také dotazovat se na více zdrojů prostřednictvím jednoho požadavku.

Co je NestJS?

NestJS je progresivní framework Node.js, který můžete použít k vytváření škálovatelných a efektivních aplikací na straně serveru. NestJS poskytuje mnoho pluginů spolu s nástroji pro rychlý a snadný vývoj včetně podpory GraphQL, GRPC, WebSockets atd.

instagram viewer

NestJS je v ekosystému dobře známý pro svou optimalizovanou strukturu projektů využívající moduly, řadiče, služby a schémata. Jeho vestavěné CLI vám umožňuje vytvořit strukturovanou architekturu API. Můžeš použít principy vstřikování závislosti ovládat, jak spolu části aplikace komunikují.

Implementace GraphQL pomocí NestJS a MongoDB

Než vytvoříte API s NestJS a GraphQL, musíte mít k dispozici správné závislosti. Potřebuješ k instalaci Node.js a NestJS, které můžete nainstalovat spuštěním npm i -g @nestjs/cli.

Následující příklad je jednoduchá aplikace, která ukládá informace o knihách. Spusťte ve svém terminálu následující příkaz a vytvořte novou aplikaci NestJS:

hnízdo nové

Přejděte do adresáře vygenerované aplikace () a nainstalujte jeho závislosti pomocí následujícího příkazu:

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

Existují dva hlavní přístupy k vytváření GraphQL API, a to:

  1. Schema-first přístup: kde popisujete API v souborech definic schématu nebo SDL a NestJS na jejich základě generuje definice Typescript.
  2. Přístup založený na kódu: kde pomocí tříd Typescript a dekorátorů definujete dotazy, mutace a další funkce GraphQL a NestJS na jejich základě generuje soubory SDL.

Následující příklad popisuje, jak používat přístup založený na kódu.

Nejprve musíte inicializovat GraphQL ve vašem AppModule a připojte jej k databázi MongoDB:

// app.module.ts
import { Modul } z'@nestjs/common';
import { GraphQLModule tak jako NestGraphQLModule } z'@nestjs/graphql';
import { ApolloDriver, ApolloDriverConfig } z'@nestjs/apollo';
import { připojit se } z'cesta';
import { MongooseModule } z'@nestjs/mongoose';
import { AppController } z'./app.controller';
import { AppService } z'./app.service';
import { ConfigModule, ConfigService } z'@nestjs/config';
import mongodbConfig z'./config/mongodb.config';
@Modul({
 dovoz: [
 ConfigModule.forRoot({
 načíst: [mongodbConfig],
 isGlobal: skutečný
 }),
 NestGraphQLModule.forRootAsync({
 řidič: ApolloDriver,
 vložit: [ConfigService],
 useFactory: asynchronní (configService: ConfigService) => ({
 autoSchemaFile: join (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: skutečný,
 sortSchema: skutečný,
 hřiště: skutečný,
 ladění: configService.get<booleovský>("LADIT"),
 nahrané soubory: Nepravdivé,
 }),
 }),
 MongooseModule.forRootAsync({
 vložit: [ConfigService],
 useFactory: asynchronní (configService: ConfigService) => ({
 uri: configService.get(„MONGO_URI“)
 })
 }),
 ],
 ovladače: [AppController],
 poskytovatelé: [AppService],
})
vývoznítřída AppModule {}

Tento modul importuje GraphQLModule z @nestjs/graphql a MongooseModule z @nestjs/mongoose který pomáhá připojit se k MongoDB. The autoSchemaFile vlastnost určuje umístění vygenerovaného souboru schématu a sortSchema vlastnost zajišťuje, že pole seřadí abecedně.

Zde je váš MongoDB config soubor by měl vypadat takto:

import { zaregistrovat jako } z'@nestjs/config';
/**
 * Konfigurace připojení databáze Mongo
 */
vývoznívýchozí registrovat jako('mongodb', () => {
konst {
 MONGO_URI
 } = process.env;
vrátit se {
 uri: `${MONGO_URI}`,
 };
});

Definování schématu GraphQL

Po nastavení připojení GraphQL a MongoDB byste měli definovat dotazy a mutace GraphQL pro generování schématu (schema.gql) soubor.

Psaní dotazů

V kód-first přístup, vytvoříte model pomocí ObjectType dekoratér. Později tento model převedete na typ GraphQL.

Například:

// book.model.ts
import { Field, ObjectType } z'@nestjs/graphql';
import { Prop, Schema, SchemaFactory } z'@nestjs/mongoose';
import { Dokument } z'mangusta';
vývoznítyp BookDocument = Kniha a dokument;


@ObjectType()
@Schéma()
vývoznítřída Rezervovat {
@Pole()
 titul: tětiva;


@Pole()
 autor: tětiva;


@Pole()
 datum zveřejnění: booleovský;
}
vývozníkonst BookSchema = SchemaFactory.createForClass (kniha);

GraphQL ve výchozím nastavení nemůže použít vytvořená schémata. Aby byly funkční, potřebujete službu resolveru, která obsahuje funkce pro spouštění typů GraphQL. Můžete tak učinit pomocí Řešitel dekoratér.

// books.resolver.ts
import { Resolver, Query, Mutation, Args, ID } z'@nestjs/graphql';
import { Rezervovat } z'./book.model';
import { BookService } z'./books.service';
@Resolver(() => Rezervovat)
vývoznítřída BookResolver {
konstruktér(soukromé readonly bookService: BookService) { }


@Dotaz(() => [Rezervovat])
asynchronní knihy(): Slib {
vrátit setento.bookService.findAll();
 }
@Dotaz(() => Rezervovat)
asynchronní rezervovat(@Args('id', { typ: () => Udělal jsem: tětiva): Slib {
vrátit setento.bookService.findOne (id);
 }
}

Můžete implementovat BookService, dovezené výše, takto:

// books.service.ts
import { Injekční } z'@nestjs/common';
import { InjectModel } z'@nestjs/mongoose';
import { Modelka } z'mangusta';
import { Book, BookDocument } z'./book.model';
@Injekční()
vývoznítřída BookService {
konstruktér(@InjectModel(název knihy) soukromé knihaModel: Model) { }


asynchronní najít vše(): Slib {
vrátit setento.bookModel.find().exec();
 }
asynchronní findOne (id: tětiva): Slib {
vrátit setento.bookModel.findById (id).exec();
 }
}

Musíte také přidat BookResolver do seznamu poskytovatelů v books.module.ts.

import { Modul } z"@nestjs/common";
import { MongooseModule } z"@nestjs/mongoose";
import { BookService } z'./books.service';
import { BookResolver } z'./books.resolver';
import { Book, BookSchema } z'./book.model';
@Modul({
 poskytovatelé: [
 knižní služba,
 BookResolver
 ],
 importuje: [MongooseModule.forFeature([
 {
 jméno: Book.name,
 schéma: BookSchema,
 },
 ]),
 ],
})
vývoznítřída BooksModule {}

Práce s mutacemi

Zatímco používáte dotaz k načítání dat v GraphQL, mutace vytvářejí nebo aktualizují data v databázi. Chcete-li vytvořit mutace, musíte přijmout data od uživatelů. The Typ vstupu Zde se hodí dekorátor, který změní třídu na vstupní typ GraphQL.

// book.input.ts
import { InputType, Field } z'@nestjs/graphql';
@Typ vstupu()
vývoznítřída BookInput {
@Pole()
 titul: tětiva;


@Pole()
 autor: tětiva;
@Pole()
 datum zveřejnění: booleovský
}

Nyní můžete aktualizovat books.resolver.ts vypadat takto:

import { Resolver, Query, Mutation, Args, ID } z'@nestjs/graphql';
import { Rezervovat } z'./book.model';
import { BookService } z'./books.service';
import { BookInput } z'./book.input';
@Resolver(() => Rezervovat)
vývoznítřída BookResolver {
konstruktér(soukromé readonly bookService: BookService) { }


@Mutace(() => Rezervovat)
asynchronní vytvořit knihu(@Args('vstup') vstup: BookInput): Slib {
vrátit setento.bookService.create (vstup);
 }


@Mutace(() => Rezervovat)
asynchronní aktualizace knihy(
@Args('id', { typ: () => Udělal jsem: tětiva,
@Args('vstup') vstup: BookInput,
 ): Slib {
vrátit setento.bookService.update (id, vstup);
 }
@Mutace(() => Rezervovat)
asynchronní deleteBook(@Args('id', { typ: () => Udělal jsem: tětiva): Slib {
vrátit setento.bookService.delete (id);
 }
}

A books.service.ts takhle:

import { Injekční } z'@nestjs/common';
import { InjectModel } z'@nestjs/mongoose';
import { Modelka } z'mangusta';
import { Book, BookDocument } z'./book.model';
@Injekční()
vývoznítřída BookService {
konstruktér(@InjectModel(název knihy) soukromé knihaModel: Model) { }


asynchronní vytvořit (kniha: Kniha): Slib {
konst nová kniha = Novýtento.bookModel (kniha);
vrátit se newBook.save();
 }


asynchronní aktualizace (id: tětiva, kniha: Kniha): Slib {
vrátit setento.bookModel.findByIdAndUpdate (id, kniha, { Nový: skutečný }).exec();
 }
asynchronnívymazat(id: tětiva): Slib {
vrátit setento.bookModel.findByIdAndDelete (id).exec();
 }
}

The @Mutace dekoratér označí funkci jako typ mutace a @Args dekoratér zachytí všechny vstupy předané do funkce.

Nakonec byste měli importovat BooksModule do AppModule aby to bylo funkční. Měli byste také projít BooksModule na forRootAsync jak je vidět níže.

import { BooksModule } z'./books/books.module';
/**
 * ostatní dovozy
*/
@Modul({
 dovoz: [
 ConfigModule.forRoot({
 načíst: [mongodbConfig],
 isGlobal: skutečný
 }),
 NestGraphQLModule.forRootAsync({
 řidič: ApolloDriver,
 vložit: [ConfigService],
 useFactory: asynchronní (configService: ConfigService) => ({
 autoSchemaFile: join (process.cwd(), 'src/schema.gql'),
 installSubscriptionHandlers: skutečný,
 sortSchema: skutečný,
 hřiště: skutečný,
 ladění: configService.get<booleovský>("LADIT"),
 nahrané soubory: Nepravdivé,
 }),
 }),
 MongooseModule.forRootAsync({
 vložit: [ConfigService],
 useFactory: asynchronní (configService: ConfigService) => ({
 uri: configService.get(„MONGO_URI“)
 })
 }),
 BooksModule,
 ],
 ovladače: [AppController],
 poskytovatelé: [AppService],
})
vývoznítřída AppModule {}

Kód můžete otestovat spuštěním npm spuštění spuštění: dev ve vašem terminálu a vaše aplikace by se měla úspěšně spustit na portu 3000.

OTEVŘENO localhost: 3000/graphql ve vašem prohlížeči zobrazit Graphiql rozhraní, kde můžete testovat dotazy a mutace. Zde je příklad, který ukazuje dotaz:

A zde je příklad mutace:

Vytvářejte efektivní rozhraní API s NestJS a GraphQL

Vytvoření GraphQL API v NestJS s MongoDB pomocí Mongoose zahrnuje definování schématu pro GraphQL API, schéma pro model Mongoose služba pro interakci s databází a resolver pro mapování operací GraphQL na službu metody.

NestJS má vestavěnou funkcionalitu pro vytváření API, včetně dekorátorů pro definování tras, strážců pro jejich ochranu a middlewaru pro zpracování požadavků a odpovědí. Podporuje také další databáze jako PostgreSQL, MySQL a SQLite, stejně jako další knihovny GraphQL, jako je Apollo a TypeGraphQL.