फुल-स्टैक टाइपस्क्रिप्ट ऐप्स

नमस्कार, हेब्र! मैं आपको एना रिबेरो द्वारा लेख "फुल-स्टैक टाइपस्क्रिप्ट ऐप्स - भाग 1: विकासशील बैकएंड एपीआई विथ नेस्ट.जेएस" का अनुवाद पेश करता हूं।

भाग 1: Nest.JS का उपयोग कर सर्वर API का विकास करना

TL; DR: यह कैसे कोणीय और Nest.JS का उपयोग करके टाइपस्क्रिप्ट वेब अनुप्रयोग बनाने के बारे में लेखों की एक श्रृंखला है। पहले भाग में, हम Nest.JS का उपयोग करते हुए एक साधारण सर्वर एपीआई लिखेंगे। इस श्रृंखला का दूसरा हिस्सा कोणीय का उपयोग करते हुए फ्रंट-एंड एप्लिकेशन के लिए समर्पित है। आप इस GitHub भंडार में इस लेख में विकसित अंतिम कोड पा सकते हैं ।

Nest.Js और क्यों कोणीय है?

Nest.js Node.js वेब सर्वर अनुप्रयोगों के निर्माण के लिए एक रूपरेखा है।

एक विशिष्ट विशेषता यह है कि यह एक ऐसी समस्या को हल करता है जो कोई अन्य ढांचा हल नहीं करता है: नोड.जेएस परियोजना की संरचना। यदि आपने कभी भी नोड.जेएस के तहत विकसित किया है, तो आप जानते हैं कि आप एक मॉड्यूल के साथ बहुत कुछ कर सकते हैं (उदाहरण के लिए, एक्सप्रेस मिडवेवेयर प्रमाणीकरण से सत्यापन तक सब कुछ कर सकता है), जो अंत में, एक असमर्थित "गड़बड़" का कारण बन सकता है। । जैसा कि आप नीचे देखेंगे, nest.js विभिन्न मुद्दों के विशेषज्ञ वर्ग प्रदान करके हमारी सहायता करेंगे।

Nest.js कोणीय से काफी प्रेरित है। उदाहरण के लिए दोनों प्लेटफ़ॉर्म आपके अनुप्रयोगों के कुछ हिस्सों तक पहुंचने या उन्हें रोकने के लिए गार्ड का उपयोग करते हैं, और दोनों प्लेटफ़ॉर्म इन गार्डों को लागू करने के लिए एक CanActivate इंटरफ़ेस प्रदान करते हैं। हालांकि, यह ध्यान रखना महत्वपूर्ण है कि कुछ समान अवधारणाओं के बावजूद, दोनों संरचनाएं एक-दूसरे से स्वतंत्र हैं। यही है, इस लेख में, हम अपने फ्रंट-एंड के लिए एक स्वतंत्र एपीआई बनाएंगे, जिसका उपयोग किसी भी अन्य ढांचे (रिएक्ट, वीयू.जेएस और इसी तरह) के साथ किया जा सकता है।

ऑनलाइन ऑर्डर के लिए वेब एप्लिकेशन

इस गाइड में, हम एक साधारण एप्लिकेशन बनाएंगे जिसमें उपयोगकर्ता किसी रेस्तरां में ऑर्डर दे सकते हैं। यह इस तर्क को लागू करेगा:

• कोई भी उपयोगकर्ता मेनू देख सकता है;
• केवल एक अधिकृत उपयोगकर्ता टोकरी में सामान जोड़ सकता है (एक ऑर्डर करें)
• केवल व्यवस्थापक नए मेनू आइटम जोड़ सकते हैं।

सादगी के लिए, हम एक बाहरी डेटाबेस के साथ बातचीत नहीं करेंगे और हमारी स्टोर टोकरी की कार्यक्षमता को लागू नहीं करेंगे।

Nest.js परियोजना की फ़ाइल संरचना बनाना

Nest.js को स्थापित करने के लिए, हमें Node.js (v.8.9.x या उच्चतर) और NPM स्थापित करने की आवश्यकता है। आधिकारिक वेबसाइट से आपके ऑपरेटिंग सिस्टम के लिए Node.js डाउनलोड और इंस्टॉल करें (NPM शामिल है)। जब सब कुछ स्थापित हो जाए, तो संस्करणों की जाँच करें:

node -v # v12.11.1 npm -v # 6.11.3 

Nest.js के साथ एक परियोजना बनाने के विभिन्न तरीके हैं; वे प्रलेखन में पाए जा सकते हैं। हम nest-cli का उपयोग करेंगे। इसे स्थापित करें:

npm i -g @nestjs/cli

अगला, एक साधारण कमांड के साथ हमारी परियोजना बनाएं:

nest new nest-restaurant-api

इस प्रक्रिया में, घोंसला हमें एक पैकेज मैनेजर चुनने के लिए कहेगा: npm या yarn

यदि सब कुछ ठीक रहा, तो nest निम्नलिखित फ़ाइल संरचना बनाएगा:

 nest-restaurant-api ├── src │ ├── app.controller.spec.ts │ ├── app.controller.ts │ ├── app.module.ts │ ├── app.service.ts │ └── main.ts ├── test │ ├── app.e2e-spec.ts │ └── jest-e2e.json ├── .gitignore ├── .prettierrc ├── nest-cli.json ├── package.json ├── package-lock.json ├── README.md ├── tsconfig.build.json ├── tsconfig.json └── tslint.json 

बनाई गई निर्देशिका पर जाएं और विकास सर्वर शुरू करें:

  #    cd nest-restaurant-api #   npm run start:dev 

एक ब्राउज़र खोलें और http://localhost:3000 । स्क्रीन पर हम देखेंगे:

इस ट्यूटोरियल के भाग के रूप में, हम अपने एपीआई का परीक्षण नहीं करेंगे (हालाँकि आपको किसी भी तैयार-से-उपयोग के लिए परीक्षण लिखना चाहिए)। इस तरह आप test निर्देशिका को साफ़ कर सकते हैं और src/app.controller.spec.ts (जो परीक्षण एक है) को हटा सकते हैं। परिणामस्वरूप, हमारे स्रोत फ़ोल्डर में निम्न फ़ाइलें हैं:

• src/app.controller.ts और src/app.module.ts : ये फाइलें / मार्ग के साथ Hello world संदेश बनाने के लिए जिम्मेदार हैं। क्योंकि यह प्रविष्टि बिंदु इस एप्लिकेशन के लिए महत्वपूर्ण नहीं है जिसे हम उन्हें हटाते हैं। जल्द ही आप अधिक विस्तार से जानेंगे कि नियंत्रक और सेवाएं क्या हैं ।
• src/app.module.ts : में प्रकार मॉड्यूल के एक वर्ग का विवरण शामिल है, जो कि घोंसले के अनुप्रयोग के लिए नियंत्रकों और प्रदाताओं के आयात, निर्यात को घोषित करने के लिए जिम्मेदार है। प्रत्येक एप्लिकेशन में कम से कम एक मॉड्यूल होता है, लेकिन आप अधिक जटिल एप्लिकेशन ( प्रलेखन में अधिक) के लिए एक से अधिक मॉड्यूल बना सकते हैं। हमारा आवेदन केवल एक मॉड्यूल होगा।
• src/main.ts : यह सर्वर को शुरू करने के लिए जिम्मेदार फाइल है।

नोट: src/app.controller.ts और src/app.module.ts को हटाने के बाद src/app.module.ts आप अपना आवेदन शुरू नहीं कर पाएंगे। चिंता न करें, हम इसे जल्द ही ठीक कर देंगे।

प्रवेश बिंदु (समापन बिंदु) बनाएं

हमारा एपीआई /items मार्ग पर उपलब्ध होगा। इस प्रविष्टि बिंदु के माध्यम से, उपयोगकर्ता डेटा प्राप्त कर सकते हैं, और व्यवस्थापक मेनू का प्रबंधन करते हैं। चलो इसे बनाते हैं।

ऐसा करने के लिए, src अंदर items नामक एक निर्देशिका बनाएं। /items रूट से जुड़ी सभी फाइलें इस नई निर्देशिका में संग्रहीत की जाएंगी।

नियंत्रक बनाना

nest.js , कई अन्य रूपरेखाओं की तरह, नियंत्रक कार्यक्षमता वाले मानचित्रण मार्गों के लिए जिम्मेदार हैं। nest.js में एक नियंत्रक बनाने के लिए nest.js डेकोरेटर का उपयोग इस प्रकार करें: @Controller(${ENDPOINT}) । इसके अलावा, विभिन्न HTTP विधियों, जैसे GET और POST , को मैप करने के लिए सज्जाकार @Get , @Post , @Delete , आदि का उपयोग किया जाता है।

हमारे मामले में, हमें एक नियंत्रक बनाने की आवश्यकता है जो रेस्तरां में उपलब्ध व्यंजन लौटाता है, और जो व्यवस्थापक मेनू की सामग्री का प्रबंधन करने के लिए उपयोग करेंगे। आइए निम्नलिखित सामग्रियों के साथ src/items निर्देशिका में items.controller.tc नामक एक फ़ाइल बनाएँ:

  import { Get, Post, Controller } from '@nestjs/common'; @Controller('items') export class ItemsController { @Get() async findAll(): Promise<string[]> { return ['Pizza', 'Coke']; } @Post() async create() { return 'Not yet implemented'; } } 

हमारे नए नियंत्रक को हमारे एप्लिकेशन में उपलब्ध कराने के लिए, इसे मॉड्यूल में पंजीकृत करें:

  import { Module } from '@nestjs/common'; import { ItemsController } from './items/items.controller'; @Module({ imports: [], controllers: [ItemsController], providers: [], }) export class AppModule {} 

हमारे आवेदन को लॉन्च करें: npm run start:dev और ब्राउज़र में खोलें http: // localhost: 3000 / items , अगर आपने सब कुछ सही ढंग से किया है, तो हमें हमारे अनुरोध का जवाब देखना चाहिए: ['Pizza', 'Coke'] ।

अनुवादक का नोट: नए नियंत्रक, साथ ही nest.js अन्य तत्वों को nest.js के लिए। nest.js : सेवाएं, प्रदाता, आदि, यह nest-cli से nest generate कमांड का उपयोग करने के लिए अधिक सुविधाजनक है। उदाहरण के लिए, ऊपर वर्णित नियंत्रक बनाने के लिए, आप nest generate controller items कमांड nest generate controller items उपयोग कर सकते हैं, जिसके परिणामस्वरूप घोंसला निम्नलिखित सामग्री के src/items/items.controller.tc src/items/items.controller.spec.tc और src/items/items.controller.tc :

  import { Get, Post, Controller } from '@nestjs/common'; @Controller('items') export class ItemsController {} 

और app.molule.tc में इसे पंजीकृत करें

एक सेवा को जोड़ना

अब, जब /items एक्सेस करते हैं, तो हमारा आवेदन प्रत्येक अनुरोध के लिए एक ही सरणी देता है, जिसे हम बदल नहीं सकते हैं। डेटा को संसाधित करना और सहेजना नियंत्रक का व्यवसाय नहीं है, इस उद्देश्य के लिए सेवाओं का उद्देश्य n.js है
घोंसले में सेवाएँ @Injectable
डेकोरेटर का नाम स्वयं के लिए बोलता है, इस डेकोरेटर को कक्षा में जोड़ने से यह अन्य घटकों जैसे नियंत्रकों में इंजेक्टेबल हो जाता है।
चलो हमारी सेवा बनाएँ। निम्नलिखित सामग्री के साथ items.service.ts फ़ोल्डर में items.service.ts फ़ाइल बनाएँ:

  import { Injectable } from '@nestjs/common'; @Injectable() export class ItemsService { private readonly items: string[] = ['Pizza', 'Coke']; findAll(): string[] { return this.items; } create(item: string) { this.items.push(item); } } 

और हमारी सेवा का उपयोग करने के लिए items.controller.ts कंट्रोलर ( items.controller.ts में घोषित किया गया है। items.controller.ts ) items.controller.ts :

  import { Get, Post, Body, Controller } from '@nestjs/common'; import { ItemsService } from './items.service'; @Controller('items') export class ItemsController { constructor(private readonly itemsService: ItemsService) {} @Get() async findAll(): Promise<string[]> { return this.itemsService.findAll(); } @Post() async create(@Body() item: string) { this.itemsService.create(item); } } 

नियंत्रक के नए संस्करण में, हमने विधि विधि तर्क create लिए @Body डेकोरेटर को लागू किया। यह तर्क स्वचालित रूप से req.body ['item'] माध्यम से पास किए गए डेटा को तर्क से (इस मामले में, item ) में स्वचालित रूप से मिलान करने के लिए उपयोग किया जाता है।
इसके अलावा, हमारे नियंत्रक को ItemsService का एक उदाहरण प्राप्त होता है, जिसे कंस्ट्रक्टर के माध्यम से इंजेक्ट किया जाता है। ItemsService को ItemsService रूप में घोषित ItemsService private readonly तौर पर एक उदाहरण को ItemsService और केवल कक्षा के अंदर दृश्यमान बनाता है।
और app.module.ts में हमारी सेवा को पंजीकृत करना न भूलें:

  import { Module } from '@nestjs/common'; import { ItemsController } from './items/items.controller'; import { ItemsService } from './items/items.service'; @Module({ imports: [], controllers: [ItemsController], providers: [ItemsService], }) export class AppModule {} 

सभी परिवर्तनों के बाद, आइए मेनू में HTTP POST अनुरोध भेजें:

  curl -X POST -H 'content-type: application/json' -d '{"item": "Salad"}' localhost:3000/items 

फिर हम जांचेंगे कि क्या GET अनुरोध (या http: // localhost: 3000 / एक ब्राउज़र में आइटम ) करके हमारे मेनू पर नए व्यंजन दिखाई दिए हैं या नहीं

  curl localhost:3000/items 

शॉपिंग कार्ट रूट बनाना

अब जब हमारे पास हमारे एपीआई के प्रवेश बिंदु /items पहला संस्करण है, तो चलो शॉपिंग कार्ट की कार्यक्षमता को लागू करते हैं। इस कार्यक्षमता को बनाने की प्रक्रिया पहले से निर्मित एपीआई से बहुत अलग नहीं है। इसलिए, मैनुअल को अव्यवस्थित नहीं करने के लिए, हम एक घटक बनाएंगे जो एक्सेस करते समय ओके स्थिति के साथ प्रतिक्रिया करता है।

सबसे पहले, ./src/shopping-cart/ फ़ोल्डर में ./src/shopping-cart/ shoping-cart.controller.ts :

  import { Post, Controller } from '@nestjs/common'; @Controller('shopping-cart') export class ShoppingCartController { @Post() async addItem() { return 'This is a fake service :D'; } } 

इस कंट्रोलर को हमारे मॉड्यूल में पंजीकृत करें ( app.module.ts ):

  import { Module } from '@nestjs/common'; import { ItemsController } from './items/items.controller'; import { ShoppingCartController } from './shopping-cart/shopping-cart.controller'; import { ItemsService } from './items/items.service'; @Module({ imports: [], controllers: [ItemsController, ShoppingCartController], providers: [ItemsService], }) export class AppModule {} 

इस प्रविष्टि बिंदु को सत्यापित करने के लिए, निम्न कमांड को चलाएं, यह सुनिश्चित करने के बाद कि आवेदन चल रहा है:

  curl -X POST localhost:3000/shopping-cart 

आइटम के लिए एक इंटरफ़ेस टाइपस्क्रिप्ट जोड़ना

वापस हमारे items सेवा के लिए। अब हम केवल पकवान के नाम को बचाते हैं, लेकिन यह स्पष्ट रूप से पर्याप्त नहीं है, और, निश्चित रूप से, हम अधिक जानकारी (उदाहरण के लिए, पकवान की लागत) चाहते हैं। मुझे लगता है कि आप इस बात से सहमत होंगे कि इस डेटा को स्ट्रिंग्स की एक सरणी के रूप में संग्रहीत करना एक अच्छा विचार नहीं है?
इस समस्या को हल करने के लिए, हम वस्तुओं की एक सरणी बना सकते हैं। लेकिन वस्तुओं की संरचना को कैसे बचाया जाए? यहां टाइपस्क्रिप्ट इंटरफ़ेस हमारी मदद करेगा, जिसमें हम items ऑब्जेक्ट की संरचना को परिभाषित करते हैं। src/items फ़ोल्डर में item.interface.ts नामक एक नई फ़ाइल बनाएँ:

  export interface Items { readonly name: string; readonly price: number; } 

इसके बाद items.service.ts फ़ाइल

 import { Injectable } from '@nestjs/common'; import { Item } from './item.interface'; @Injectable() export class ItemsService { private readonly items: Item[] = []; findAll(): Item[] { return this.items; } create(item: Item) { this.items.push(item); } } 

और items.controller.ts में भी। items.controller.ts । items.controller.ts :

 import { Get, Post, Body, Controller } from '@nestjs/common'; import { ItemsService } from './items.service'; import { Item } from './item.interface'; @Controller('items') export class ItemsController { constructor(private readonly itemsService: ItemsService) {} @Get() async findAll(): Promise<Item[]> { return this.itemsService.findAll(); } @Post() async create(@Body() item: Item) { this.itemsService.create(item); } } 

Nest.js में इनपुट का सत्यापन

इस तथ्य के बावजूद कि हमने item ऑब्जेक्ट की संरचना निर्धारित की है, अगर हम एक अमान्य पोस्ट अनुरोध (इंटरफ़ेस में परिभाषित किसी भी प्रकार का डेटा नहीं) भेजते हैं, तो हमारा आवेदन एक त्रुटि नहीं लौटाएगा। उदाहरण के लिए, इस तरह के अनुरोध के लिए:

  curl -H 'Content-Type: application/json' -d '{ "name": 3, "price": "any" }' http://localhost:3000/items 

सर्वर को 400 (खराब अनुरोध) की स्थिति के साथ जवाब देना चाहिए, लेकिन इसके बजाय, हमारा आवेदन 200 (ओके) की स्थिति के साथ जवाब देगा।

इस समस्या को हल करने के लिए, एक डीटीओ (डेटा ट्रांसफर ऑब्जेक्ट) और एक पाइप घटक (चैनल) बनाएं।

डीटीओ एक ऑब्जेक्ट है जो परिभाषित करता है कि डेटा को प्रक्रियाओं के बीच कैसे स्थानांतरित किया जाना चाहिए। हम DTO को src/items/create-item.dto.ts में वर्णित करते हैं:

  import { IsString, IsInt } from 'class-validator'; export class CreateItemDto { @IsString() readonly name: string; @IsInt() readonly price: number; } 

Nest.js में पाइप सत्यापन के लिए उपयोग किए जाने वाले घटक हैं। हमारे एपीआई के लिए, एक चैनल बनाएं जिसमें यह जांचे कि विधि को भेजा गया डेटा डीटीओ से मेल खाता है या नहीं। एक चैनल का उपयोग विभिन्न नियंत्रकों द्वारा किया जा सकता है, इसलिए फ़ाइल validation.pipe.ts साथ src/common/ निर्देशिका बनाएं।

  import { ArgumentMetadata, BadRequestException, Injectable, PipeTransform, } from '@nestjs/common'; import { validate } from 'class-validator'; import { plainToClass } from 'class-transformer'; @Injectable() export class ValidationPipe implements PipeTransform<any> { async transform(value, metadata: ArgumentMetadata) { const { metatype } = metadata; if (!metatype || !this.toValidate(metatype)) { return value; } const object = plainToClass(metatype, value); const errors = await validate(object); if (errors.length > 0) { throw new BadRequestException('Validation failed'); } return value; } private toValidate(metatype): boolean { const types = [String, Boolean, Number, Array, Object]; return !types.find(type => metatype === type); } } 

नोट: हमें दो मॉड्यूल स्थापित करने की आवश्यकता है: class-validator और class-transformer । ऐसा करने के लिए, कंसोल में npm install class-validator class-transformer और सर्वर को पुनरारंभ करें।

हमारे नए पाइप और DTO के साथ उपयोग के लिए items.controller.ts को items.controller.ts :

  import { Get, Post, Body, Controller, UsePipes } from '@nestjs/common'; import { CreateItemDto } from './create-item.dto'; import { ItemsService } from './items.service'; import { Item } from './item.interface'; import { ValidationPipe } from '../common/validation.pipe'; @Controller('items') export class ItemsController { constructor(private readonly itemsService: ItemsService) {} @Get() async findAll(): Promise<Item[]> { return this.itemsService.findAll(); } @Post() @UsePipes(new ValidationPipe()) async create(@Body() createItemDto: CreateItemDto) { this.itemsService.create(createItemDto); } } 

आइए हमारे कोड को फिर से जांचें, अब प्रविष्टि /items केवल डेटा को स्वीकार करते हैं यदि वे डीटीओ में परिभाषित किए जाते हैं। उदाहरण के लिए:

  curl -H 'Content-Type: application/json' -d '{ "name": "Salad", "price": 3 }' http://localhost:3000/items 

अमान्य डेटा में चिपकाएँ (डेटा जो ValidationPipe में सत्यापित नहीं किया जा सकता है), परिणामस्वरूप हमें उत्तर मिलता है:

  {"statusCode":400,"error":"Bad Request","message":"Validation failed"} 

मिडिलवेयर बनाना

Auth0 क्विक स्टार्ट गाइड पेज के अनुसार , Auth0 द्वारा जारी JWT टोकन को सत्यापित करने के लिए अनुशंसित तरीका express-jwt द्वारा प्रदान एक्सप्रेस मिडलवेयर का उपयोग करना है। यह मिडिलवेयर काम का एक बड़ा हिस्सा स्वचालित करता है।

आइए निम्नलिखित कोड के साथ src / common निर्देशिका के अंदर एक authentication.middleware.ts फ़ाइल बनायें:

  import { NestMiddleware } from '@nestjs/common'; import * as jwt from 'express-jwt'; import { expressJwtSecret } from 'jwks-rsa'; export class AuthenticationMiddleware implements NestMiddleware { use(req, res, next) { jwt({ secret: expressJwtSecret({ cache: true, rateLimit: true, jwksRequestsPerMinute: 5, jwksUri: 'https://${DOMAIN}/.well-known/jwks.json', }), audience: 'http://localhost:3000', issuer: 'https://${DOMAIN}/', algorithm: 'RS256', })(req, res, err => { if (err) { const status = err.status || 500; const message = err.message || 'Sorry, we were unable to process your request.'; return res.status(status).send({ message, }); } next(); }); }; } 

Auth0 एप्लिकेशन की सेटिंग से डोमेन मूल्य के साथ ${DOMAIN} को बदलें

अनुवादक का ध्यान दें: एक वास्तविक एप्लिकेशन में, DOMAIN को एक स्थिरांक में बाहर DOMAIN , और env (आभासी वातावरण) के माध्यम से इसका मान सेट करें

express-jwt jwks-rsa और jwks-rsa स्थापित करें:

  npm install express-jwt jwks-rsa 

हमारे आवेदन के लिए बनाए गए मिडलवेयर (हैंडलर) को कनेक्ट करना आवश्यक है। ऐसा करने के लिए, ./src/app.module.ts फ़ाइल में:

  import { Module, MiddlewareConsumer, RequestMethod } from '@nestjs/common'; import { AuthenticationMiddleware } from './common/authentication.middleware'; import { ItemsController } from './items/items.controller'; import { ShoppingCartController } from './shopping-cart/shopping-cart.controller'; import { ItemsService } from './items/items.service'; @Module({ imports: [], controllers: [ItemsController, ShoppingCartController], providers: [ItemsService], }) export class AppModule { public configure(consumer: MiddlewareConsumer) { consumer .apply(AuthenticationMiddleware) .forRoutes( { path: '/items', method: RequestMethod.POST }, { path: '/shopping-cart', method: RequestMethod.POST }, ); } } 

उपरोक्त कोड का कहना है कि एक्सप्रेस मिडलवेयर द्वारा /items और /shopping-cart मार्गों के लिए POST अनुरोध सुरक्षित हैं, जो अनुरोध में पहुँच टोकन के लिए जाँच करता है।

विकास सर्वर को पुनः आरंभ करें ( npm run start:dev ) और Nest.js API पर कॉल करें:

  #     curl -X POST http://localhost:3000/shopping-cart #      TOKEN="eyJ0eXAiO...Mh0dpeNpg" # and issue a POST request with it curl -X POST -H 'authorization: Bearer '$TOKEN http://localhost:3000/shopping-cart 

Auth0 के साथ भूमिका प्रबंधन

फिलहाल, सत्यापित टोकन वाला कोई भी उपयोगकर्ता हमारे एपीआई में आइटम पोस्ट कर सकता है। हालाँकि, हम चाहेंगे कि केवल व्यवस्थापक अधिकारों वाले उपयोगकर्ता ही ऐसा कर सकते हैं। इस फ़ंक्शन को लागू करने के लिए, हम नियमों (नियमों) Auth0 का उपयोग करते हैं ।

तो, नियम अनुभाग में, Auth0 नियंत्रण कक्ष पर जाएं। वहां, + CREATE RULE और नियम मॉडल के रूप में "उपयोगकर्ता को भूमिकाएं सेट करें" चुनें।

ऐसा करने के बाद, हमें एक नियम टेम्पलेट के साथ एक जावास्क्रिप्ट फ़ाइल मिलती है जो किसी भी उपयोगकर्ता के लिए व्यवस्थापक भूमिका जोड़ती है जिसके पास एक ईमेल है जो एक निश्चित डोमेन से संबंधित है। चलिए इस टेम्पलेट में कुछ विवरण बदलकर एक कार्यात्मक उदाहरण प्राप्त करते हैं। हमारे आवेदन के लिए, हम केवल अपने स्वयं के ईमेल पते पर व्यवस्थापक को पहुंच प्रदान करेंगे। हमें व्यवस्थापक स्थिति जानकारी संग्रहीत करने के लिए स्थान बदलने की भी आवश्यकता होगी।

फिलहाल, यह जानकारी एक पहचान टोकन (उपयोगकर्ता के बारे में जानकारी प्रदान करने के लिए उपयोग की जाती है) में संग्रहीत है, लेकिन एपीआई में संसाधनों तक पहुंचने के लिए एक एक्सेस टोकन का उपयोग किया जाना चाहिए। परिवर्तनों के बाद का कोड इस तरह दिखना चाहिए:

  function (user, context, callback) { user.app_metadata = user.app_metadata || {}; if (user.email && user.email === '${YOUR_EMAIL}') { user.app_metadata.roles = ['admin']; } else { user.app_metadata.roles = ['user']; } auth0.users .updateAppMetadata(user.user_id, user.app_metadata) .then(function() { context.accessToken['http://localhost:3000/roles'] = user.app_metadata.roles; callback(null, user, context); }) .catch(function(err) { callback(err); }); } 

नोट: ${YOUR_EMAIL} को अपने ईमेल पते से बदलें। यह नोट करना महत्वपूर्ण है कि, एक नियम के रूप में, जब आप Auth0 नियमों में ईमेल से निपटते हैं, तो यह ईमेल सत्यापन के लिए मजबूर करने के लिए आदर्श है। इस मामले में, यह आवश्यक नहीं है क्योंकि हम अपने स्वयं के ईमेल पते का उपयोग करते हैं।

अनुवादक का नोट: उपरोक्त कोड टुकड़ा को Auth0 नियम कॉन्फ़िगरेशन पृष्ठ पर ब्राउज़र में दर्ज किया गया है

यह जांचने के लिए कि हमारे एपीआई में टोकन पारित किया गया है या नहीं, हमें टोकन की जरूरत है, हमें एक गार्ड Nest.js. src/common फ़ोल्डर में, admin.guard.ts फ़ाइल बनाएँ

  import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common'; @Injectable() export class AdminGuard implements CanActivate { canActivate(context: ExecutionContext): boolean { const user = context.getArgs()[0].user['http://localhost:3000/roles'] || ''; return user.indexOf('admin') > -1; } } 

अब, यदि हम ऊपर वर्णित लॉगिन प्रक्रिया को दोहराते हैं और नियम में परिभाषित ईमेल पते का उपयोग करते हैं, तो हमें एक नया access_token । इस access_token की सामग्री की जांच करने के लिए, साइट https://jwt.io/ के Encoded फ़ील्ड में टोकन को कॉपी और पेस्ट https://jwt.io/ । हम देखेंगे कि इस टोकन के पेलोड अनुभाग में निम्नलिखित सरणी हैं:

  "http://localhost:3000/roles": [ "admin" ] 

यदि हमारे टोकन में वास्तव में यह जानकारी शामिल है, तो हम Auth0 के साथ एकीकरण जारी रखते हैं। तो, items.controller.ts खोलें items.controller.ts और वहां हमारा नया गार्ड जोड़ें:

  import { Get, Post, Body, Controller, UsePipes, UseGuards, } from '@nestjs/common'; import { CreateItemDto } from './create-item.dto'; import { ItemsService } from './items.service'; import { Item } from './item.interface'; import { ValidationPipe } from '../common/validation.pipe'; import { AdminGuard } from '../common/admin.guard'; @Controller('items') export class ItemsController { constructor(private readonly itemsService: ItemsService) {} @Get() async findAll(): Promise<Item[]> { return this.itemsService.findAll(); } @Post() @UseGuards(new AdminGuard()) @UsePipes(new ValidationPipe()) async create(@Body() createItemDto: CreateItemDto) { this.itemsService.create(createItemDto); } } 

अब, हमारे नए टोकन के साथ, हम अपने एपीआई के माध्यम से नए आइटम जोड़ सकते हैं:

  #    npm run start:dev #  POST       curl -X POST -H 'Content-Type: application/json' \ -H 'authorization: Bearer '$TOKEN -d '{ "name": "Salad", "price": 3 }' http://localhost:3000/items 

अनुवादक का नोट: सत्यापन के लिए, आप देख सकते हैं कि हमारे पास क्या है:

 curl -X GET http://localhost:3000/items 

परिणाम

बधाई! हमने अभी अपना Nest.JS API बनाना शुरू किया और अब हम अपने एप्लिकेशन के फ्रंटेंड भाग को विकसित करने पर ध्यान केंद्रित कर सकते हैं! इस श्रृंखला के दूसरे भाग को देखना सुनिश्चित करें: फुल-स्टैक टाइपस्क्रिप्ट ऐप्स - भाग 2: फ्रंटिंग कोणीय कोणीय अनुप्रयोग विकसित करना।

अनुवादक का नोट: दूसरे भाग का अनुवाद जारी है।

संक्षेप में, इस लेख में हमने Nest.js और टाइपस्क्रिप्ट की विभिन्न विशेषताओं का उपयोग किया: मॉड्यूल, नियंत्रक, सेवाएं, इंटरफेस, पाइप, मिडलवेयर और गार्ड बनाने के लिए एपीआई। मुझे आशा है कि आपके पास एक अच्छा अनुभव है और हमारे आवेदन को विकसित करने के लिए जारी रखने के लिए तैयार हैं। यदि आपके लिए कुछ स्पष्ट नहीं है, तो आधिकारिक n.js प्रलेखन उत्तर के साथ एक अच्छा स्रोत है