नेस्टजेएस के एबीसी:मोंगोडीबी (मोंगोज) के साथ एक शुरुआती गाइड।

NestJS क्या है?

NestJS एक आधुनिक NodeJS ढांचा है जो लोकप्रिय NodeJS फ्रेमवर्क का उपयोग करता है जैसे कि एक्सप्रेस और Fastify हुड के तहत। NestJS काफी हद तक एंगुलर से प्रेरित था, और इसके परिणामस्वरूप, यह एक एंगुलर-स्टाइल मॉड्यूल सिस्टम को नियोजित करता है। NestJS टाइपस्क्रिप्ट में लिखा गया है, हालांकि यह देशी जावास्क्रिप्ट का भी समर्थन करता है।

पूर्वापेक्षाएँ

इस ट्यूटोरियल का अनुसरण करने के लिए, आपको निम्नलिखित आवश्यकताओं को पूरा करना होगा

पोस्टमैन या किसी अन्य एपीआई परीक्षण उपकरण में योग्यता।
नोडजेएस और एक्सप्रेस ऐप्स का बुनियादी ज्ञान।
टाइपस्क्रिप्ट का बुनियादी ज्ञान।
MongoDB (नेवला) में योग्यता।

आपके सिस्टम पर निम्नलिखित संस्थापित होना चाहिए

NodeJS v.14 और इसके बाद के संस्करण।
विजुअल स्टूडियो कोड (अनुशंसित) या कोई अन्य आईडीई।
पोस्टमैन या कोई अन्य एपीआई परीक्षण उपकरण।

NestJS में उपयोग की जाने वाली सामान्य शब्दावली;

यहां NestJS में सबसे अधिक नियमित रूप से उपयोग किए जाने वाले कुछ शब्द दिए गए हैं, जिनका आप इस लेख में बहुत कुछ सामना करेंगे।

इंटरफेस

एक इंटरफ़ेस एक प्रकार की परिभाषा है। नतीजतन, इसका उपयोग कार्यों, कक्षाओं आदि में एक प्रकार के चेकर/प्रवर्तक के रूप में किया जाता है।

interface humanInterface{
  name:string;
  gender:string;
  age:number;
}

const kevin: humanInterface={
  name:'Kevin Sunders',
  gender:'Male',
  age: 25,
}

humanInterface ऊपर kevin . पर सख्त प्रकार की जाँच करता है वस्तु। यदि आप कोई अन्य फ़ील्ड जोड़ते हैं या किसी ऑब्जेक्ट गुण के प्रकार को बदलते हैं तो टाइपस्क्रिप्ट एक त्रुटि उत्पन्न करेगा।

नियंत्रक

नियंत्रक आने वाले अनुरोधों को प्राप्त करने और ग्राहक को जवाब देने के प्रभारी हैं। एक नियंत्रक अपनी संबद्ध सेवा के साथ सहयोग करता है।

सेवाएं

एक सेवा एक प्रदाता है जो डेटा को संग्रहीत और पुनर्प्राप्त करता है और इसके संबंधित नियंत्रक के साथ प्रयोग किया जाता है।

डेकोरेटर

डेकोरेटर एक फ़ंक्शन-रिटर्निंग एक्सप्रेशन है जो target . को स्वीकार करता है , name , और property descriptor वैकल्पिक तर्क के रूप में। डेकोरेटर्स को @decorator-name . के रूप में लिखा जाता है . वे आमतौर पर वर्ग घोषणाओं, विधियों और मापदंडों से जुड़े होते हैं।

@Get()
   getAll(): Model[] {
    return this.testService.getAll();
  }

@Get ऊपर डेकोरेटर इसके नीचे कोड ब्लॉक को GET . के रूप में चिह्नित करता है गुजारिश। उसके बारे में और बाद में।

मॉड्यूल

एक मॉड्यूल एक प्रोग्राम का एक हिस्सा है जो किसी विशेष कार्य को संभालता है। NestJS में एक मॉड्यूल को @Module() के साथ एनोटेट किए गए वर्ग को एनोटेट करके चिह्नित किया जाता है डेकोरेटर Nest @Module() . द्वारा दिए गए मेटाडेटा का इस्तेमाल करता है डेकोरेटर एप्लिकेशन संरचना को व्यवस्थित करने के लिए।

CLI इंस्टॉल करना

आरंभ करने के लिए आपको NestJS CLI **** को npm . के साथ स्थापित करना होगा . यदि आपके सिस्टम पर NestJS CLI पहले से स्थापित है, तो आप इस चरण को छोड़ सकते हैं।

npm i -g @nestjs/cli

ऊपर दिया गया यह कोड ब्लॉक आपके सिस्टम पर विश्व स्तर पर नेस्ट सीएलआई स्थापित करेगा।

एक नया प्रोजेक्ट बनाना

नया प्रोजेक्ट बनाने के लिए nest new run चलाएं आपके इच्छित प्रोजेक्ट नाम के बाद। इस लेख के लिए, हम RESTful मानकों का पालन करते हुए CRUD कार्यक्षमता के साथ एक साधारण ब्लॉग API लिखेंगे।

nest new Blog-Api

यह कमांड आपको पैकेज मैनेजर चुनने के लिए कहेगा, npm . चुनें ।

इसके बाद यह पूरे प्रोजेक्ट स्ट्रक्चर को टेस्ट एपीआई एंडपॉइंट के साथ मचा देगा जिसका पोर्ट 3000 . पर सेट है डिफ़ॉल्ट रूप से। आप इसका परीक्षण http://localhost:3000 . पर कर सकते हैं npm run start:dev . चलाने के बाद कमांड जो सर्वर को वॉच मोड में शुरू करेगा जैसा कि नोडमॉन एक्सप्रेस ऐप्स में करता है।

समापन बिंदु का परीक्षण करने के बाद, आपको कुछ डिफ़ॉल्ट फ़ाइलों को हटाना होगा क्योंकि अब आपको उनकी आवश्यकता नहीं होगी। ऐसा करने के लिए;

src फ़ोल्डर और अंदर खोलें,
हटाएं app.controller.spec.ts ,
हटाएं app.controller.ts ,
हटाएं app.service.ts ,
खोलें app.module.ts ,
AppController का संदर्भ हटाएं controllers . में सरणी और आयात,
AppService का संदर्भ हटा दें providers . में सरणी और आयात।

आपको README.md . को भी बदलना पड़ सकता है अपने विनिर्देशों को पूरा करने के लिए।

आपका app.module.ts फ़ाइल इस तरह दिखनी चाहिए,

//app.module.ts

import { Module } from '@nestjs/common';

@Module({
  imports: [],
  controllers: [],
  providers: [],
})
export class AppModule {}

पर्यावरण चर

अच्छे अभ्यास के रूप में, आपके कोड की कुछ संवेदनशील जानकारी को सार्वजनिक नहीं किया जाना चाहिए। उदाहरण के लिए आपका PORT और आपका MongoDB URI ।

आइए इसे आपके कोड में ठीक करें।

आपके टर्मिनल रन पर

npm i dotenv

फिर एक .env बनाएं अपनी निर्देशिका में फ़ाइल करें और इसे अपने .gitignore . में जोड़ें फ़ाइल। अपना PORT स्टोर करें वेरिएबल, आपको अपना MongoDB URI भी स्टोर करना होगा बाद में उसी स्थान पर। अब एक्सपोज़्ड PORT . को बदलें आपके main.ts . में फ़ाइल। ऐसा करने के लिए, dotenv import आयात करें पैकेज करें और .config() . पर कॉल करें उस पर विधि।

import * as dotenv from 'dotenv';
dotenv.config();

यह आपका main.ts होना चाहिए ऊपर दिए गए चरणों का पालन करने के बाद फ़ाइल करें।

//main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as dotenv from 'dotenv';
dotenv.config();

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(process.env.PORT);
}
bootstrap();

जनरेटिंग मॉड्यूल

NestJS CLI का उपयोग करके NestJS मॉड्यूल जेनरेट करने के लिए नीचे दिए गए कोड स्निपेट को चलाएँ।

nest generate module blogs

यह आदेश एक blogs बनाता है फ़ोल्डर जिसमें एक blogs.module.ts . है फ़ाइल और रजिस्टर BlogsModule आपके app.module.ts . में फ़ाइल।

इंटरफ़ेस बनाना

ऑब्जेक्ट के लिए टाइप चेकिंग करने के लिए NestJS CLI का उपयोग करके एक इंटरफ़ेस जेनरेट करें जो आपके ब्लॉग पोस्ट का प्रतिनिधित्व करेगा। इसे हासिल करने के लिए आपको पहले cd . करना होगा blogs . में फ़ोल्डर क्योंकि यह अनुशंसा की जाती है कि उन्हें उन डोमेन ऑब्जेक्ट्स के पास संग्रहीत किया जाए जिनसे वे संबद्ध हैं।

cd src/blogs

फिर इंटरफ़ेस उत्पन्न करने के लिए नीचे दिए गए कोड स्निपेट को चलाएँ।

nest generate interface blogs

यह एक blogs.interface.ts बनाता है फ़ाइल। यह वह जगह है जहाँ हम अपने इंटरफ़ेस को परिभाषित करेंगे। हम इंटरफ़ेस को नाम देंगे BlogsInterface .

export interface BlogsInterface {
  title: string;
  body: string;
  category: string;
  dateCreated: Date;
}

अपने टर्मिनल पर कोई और कमांड चलाने से पहले, cd . को याद रखें src . से बाहर फ़ोल्डर और वापस अपने रूट फ़ोल्डर में चलाकर

cd ../..

सेवाएं और नियंत्रक बनाना

आपको डेटा को संग्रहीत और पुनर्प्राप्त करने के लिए एक सेवा वर्ग उत्पन्न करना होगा और सभी आने वाले अनुरोधों और आउटगोइंग प्रतिक्रियाओं को संभालने के लिए सभी तर्क और नियंत्रक वर्ग को संभालना होगा।

सेवा

सेवा उत्पन्न करने के लिए नीचे दी गई कमांड चलाएँ,

nest generate service blogs

यह कमांड दो फाइलें बनाता है blogs.service.spec.ts और blogs.service.ts और सेवा को providers . में पंजीकृत करता है blogs.module.ts . में सरणी ।

नियंत्रक

कंट्रोलर जेनरेट करने के लिए नीचे कमांड चलाएँ,

nest generate controller blogs

यह कमांड दो फाइलें बनाता है blogs.controller.spec.ts और blogs.controller.ts और नियंत्रक को controllers . में पंजीकृत करता है blogs.module.ts . में सरणी ।

इनके साथ आपके ब्लॉग की संरचना लगभग पूरी हो चुकी है, आपको बस BlogsService . बनाने की आवश्यकता है आपके कार्यक्रम के अन्य भागों के लिए सुलभ। आप इसे exports creating बनाकर प्राप्त कर सकते हैं blogs.module.ts . में सरणी फाइल करना और BlogsService को पंजीकृत करना उस सरणी में।

//blogs.module.ts

import { Module } from '@nestjs/common';
import { BlogsService } from './blogs.service';
import { BlogsController } from './blogs.controller';

@Module({
  providers: [BlogsService],
  controllers: [BlogsController],
  exports: [BlogsService],
})
export class BlogsModule {}

MongoDB (नेवला)।

चलकर नेवला स्थापित करें,

npm install --save @nestjs/mongoose mongoose

स्थापना के बाद, आयात करें {MongooseModule} '@nestjs/mongoose’ . से अपने app.module.ts . में फ़ाइल। फिर अपना MongoDB URI लें और इसे अपने .env . में स्टोर करें फ़ाइल। आयात करने के लिए चरणों को दोहराएं dotenv app.module.ts . में फ़ाइल। फिर imports . में सरणी कॉल .forRoot() विधि जो आपके MongoDB URI . लेती है MongooseModule . पर एक तर्क के रूप में . mongoose.connect() के समान नियमित एक्सप्रेस ऐप्स में।

@Module({
  imports: [BlogsModule, MongooseModule.forRoot(process.env.MONGODB_URI)],

एक स्कीमा बनाना।

आइए हमारे संग्रह में ब्लॉग के आकार को परिभाषित करने के लिए एक स्कीमा बनाएं। ऐसा करने के लिए,

अपने blogs के अंदर एक फ़ोल्डर बनाएं फ़ोल्डर, इसे नाम दें schemas ,
schemas के अंदर फ़ोल्डर, एक फ़ाइल बनाएँ और इसे blogs.schema.ts . कहें ।

फिर,

सबसे पहले, आपको करना होगा,

propआयात करें डेकोरेटर, schemas डेकोरेटर, और SchemaFactory @nestjs/mongoose . से ,
एक वर्ग बनाएं blogs और इसे निर्यात करें,
@Schema() . डालकर कक्षा को एक स्कीमा में बदलें कक्षा से ऊपर का डेकोरेटर,
स्थिर BlogSchema बनाएं , .createForClass(Blog) . को कॉल करने का रिटर्न वैल्यू असाइन करें SchemaFactory . पर तर्क के रूप में अपनी कक्षा के नाम के साथ जिसे आपने पहले आयात किया था।

//blogs.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';

@Schema()
export class Blog {}

export const BlogSchema = SchemaFactory.createForClass(Blog);

फिर आपको स्कीमा के गुणों को परिभाषित करना होगा।

स्कीमा में किसी प्रॉपर्टी को परिभाषित करने के लिए आपको उनमें से प्रत्येक को @prop() . से चिह्नित करना होगा डेकोरेटर @prop डेकोरेटर एक विकल्प वस्तु या एक जटिल प्रकार की घोषणा को स्वीकार करता है। जटिल प्रकार की घोषणाएँ सरणियाँ और नेस्टेड वस्तु प्रकार की घोषणाएँ हो सकती हैं।

//blogs.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';

@Schema()
export class Blog {
  @Prop({ required: true })
  title: string;

  @Prop({ required: true })
  body: string;

  @Prop({ required: true })
  category: string;

  @Prop({ required: true })
  dateCreated: Date;
}

export const BlogSchema = SchemaFactory.createForClass(Blog);

अगला आयात { Document } 'mongoose' . से ।

फिर स्कीमा वर्ग और आयातित Document . के साथ एक संघ प्रकार बनाएं . इस तरह,

//blogs.schema.ts

import { Document } from 'mongoose';

export type BlogDocument = Blog & Document;

आपका अंतिम blogs.schema.ts फ़ाइल इस तरह दिखनी चाहिए,

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type BlogDocument = Blog & Document;

@Schema()
export class Blog {
  @Prop({ required: true })
  title: string;

  @Prop({ required: true })
  body: string;

  @Prop({ required: true })
  category: string;

  @Prop({ required: true })
  dateCreated: Date;
}

export const BlogSchema = SchemaFactory.createForClass(Blog);

स्कीमा पंजीकृत करना

आपको अपने blogs.module.ts . में सब कुछ आयात करना होगा फ़ाइल। इसे प्राप्त करने के लिए आपको,

. की आवश्यकता होगी

आयात करें {MongooseModule} '@nestjs/mongoose’ . से ,
आयात करें {Blog, BlogSchema} './schemas/blogs.schema’ . से
एक imports बनाएं @module . के अंदर सरणी डेकोरेटर
कॉल करें .forFeature() MongooseModule . पर विधि . यह एक ऐसी सरणी लेता है जिसमें एक ऑब्जेक्ट होता है जो name . को परिभाषित करता है और एक schemas संपत्ति जो आपके Blog.name . पर सेट की जानी चाहिए और आपका BlogSchema क्रमशः।

@Module({
  imports: [
    MongooseModule.forFeature([{ name: Blog.name, schema: BlogSchema }]),
  ],

स्कीमा इंजेक्ट करना

आपको blogs को इंजेक्ट करना होगा blogs.service.ts . में मॉडल @InjectModel() . का उपयोग करके डेकोरेटर इसे हासिल करने के लिए आपको

. करना होगा

आयात { Model } 'mongoose' . से ,
आयात { InjectModel } '@nestjs/mongoose’ . से ,
आयात करें {Blog, BlogDocument} './schemas/blogs.schema’ . से ,
एक constructor BlogsService के अंदर कक्षा,
एक privateघोषित करें वेरिएबल और इसे blogModel . कहते हैं और एक प्रकार का Model<BlogDocument> assign असाइन करें इसके लिए। सभी नेवला विधियों को इस चर पर बुलाया जाएगा।

याद रखें कि, BlogDocument blogs . का संघ प्रकार है वर्ग और नेवला Model जो आपने पहले बनाया था। यह आपके चर के लिए सामान्य प्रकार के रूप में प्रयोग किया जाता है।

सजाने blogModel @InjectModel() . के साथ और Blog.name . पास करें एक तर्क के रूप में।

constructor(
    @InjectModel(Blog.name)
    private blogModel: Model<BlogDocument>,
  ) {}

रूटिंग कैसे काम करती है

अब तक आपने देखा होगा कि @Controller डेकोरेटर में स्ट्रिंग है 'blogs' इसमें पारित किया। इसका मतलब है कि नियंत्रक सभी प्रतिक्रियाएं भेज देगा और http://localhost/3000/blogs पर किए गए सभी अनुरोधों को संभालेगा। ।

आगे आप सेवा और नियंत्रक तर्क को लागू करेंगे।

सेवा और नियंत्रक तर्क।

अंत में आपकी सीआरयूडी कार्यक्षमता को लागू करने का समय आ गया है।

इससे पहले कि हम शुरू करें, आपको अपना कंट्रोलर सेट करना होगा। कुछ HTTP आयात करके प्रारंभ करें अपने नियंत्रक में विधि सज्जाकार।

//blogs.controller.ts

import {
  Controller,
  Body,
  Delete,
  Get,
  Post,
  Put,
  Param,
} from '@nestjs/common';

फिर, आपको सेवा को आयात करने और इसे पंजीकृत करने की आवश्यकता होगी ताकि आप इसे एक्सेस कर सकें और टाइप-चेकिंग के लिए इंटरफ़ेस आयात कर सकें।

//blogs.controller.ts

import { BlogsInterface } from './blogs.interface';
import { BlogsService } from './blogs.service';

अपनी सेवा पंजीकृत करने के लिए एक constructor बनाएं BlogsController . के अंदर वर्ग और एक private readonly . घोषित करें परिवर्तनीय service और इसके प्रकार को BlogsService . पर सेट करें .

constructor(private readonly service: BlogsService) {}

अब जब आप पूरी तरह से तैयार हो गए हैं, तो चलिए शुरू करते हैं।

बनाएं

सेवा तर्क

आयात { BlogsInterface } './blogs.interface' . से और एक asyncजोड़ें BlogsService . पर काम करता है createBlog . नामक वर्ग , जो एक पैरामीटर लेगा blogs , इसके प्रकार के साथ BlogInterface , और इसका रिटर्न प्रकार Promise . के रूप में एक सामान्य <Blog> के साथ प्रकार।

async createBlog(blog: BlogsInterface): Promise<Blog> {
    return await new this.blogModel({
      ...blog,
      dateCreated: new Date(),
    }).save();
  }

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

आपके BlogsController . में वर्ग एक asyncजोड़ें कक्षा के लिए कार्य। इसे createBlog Call कहें और इसे @Post . से चिह्नित करें डेकोरेटर जो इसे POST . के रूप में परिभाषित करता है अनुरोध करें।createBlog एक पैरामीटर लेता है blogs , इसके प्रकार के साथ BlogInterface . पैरामीटर को @Body with से चिह्नित करें डेकोरेटर जो संपूर्ण body को निकालता है req . से ऑब्जेक्ट ऑब्जेक्ट करता है और सजाए गए पैरामीटर को body . के मान से भरता है .

@Post()
  async createBlog(
    @Body()
    blog: BlogsInterface,
  ) {
    return await this.service.createBlog(blog);
  }

पढ़ें

दो asyncजोड़ें विधियाँ, एक एकल ब्लॉग पोस्ट लौटाने के लिए और दूसरी सभी ब्लॉग पोस्ट वापस करने के लिए।

सेवा तर्क

async getAllBlogs(): Promise<Blog[]> {
    return await this.blogModel.find().exec();
  }

  async getBlog(id: string): Promise<Blog> {
    return await this.blogModel.findById(id);
  }

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

  @Get()
  async getAllBlogs() {
    return await this.service.getAllBlogs();
  }

  @Get(':id')
  async getBlog(@Param('id') id: string) {
    return await this.service.getBlog(id);
  }

async फ़ंक्शन @Get . के साथ चिह्नित हैं डेकोरेटर जो इसे GET . के रूप में परिभाषित करता है अनुरोध।

दूसरा async फ़ंक्शन के डेकोरेटर के पास एक तर्क है ':id' . जिसे आप @Param . में पास करेंगे डेकोरेटर पैरामीटर को @Param('id') . से चिह्नित किया गया है जो params . को निकालता है req . से संपत्ति ऑब्जेक्ट करता है और सजाए गए पैरामीटर को params . के मान से भरता है ।

अपडेट करें

आइए PUT . के लॉजिक को लागू करें अनुरोध।

सेवा तर्क

async updateBlog(id: string, body: BlogsInterface): Promise<Blog> {
    return await this.blogModel.findByIdAndUpdate(id, body);
  }

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

@Put(':id')
  async updateBlog(
    @Param('id')
    id: string,
    @Body()
    blog: BlogsInterface,
  ) {
    return await this.service.updateBlog(id, blog);
  }

async फ़ंक्शन का दूसरा पैरामीटर @Body() . के साथ चिह्नित है डेकोरेटर जो संपूर्ण body को निकालता है req . से ऑब्जेक्ट ऑब्जेक्ट करता है और सजाए गए पैरामीटर को body . के मान से भरता है ।

हटाएं

आइए delete . के लॉजिक को लागू करें अनुरोध।

सेवा तर्क

async deleteBlog(id: string): Promise<void> {
    return await this.blogModel.findByIdAndDelete(id);
  }

Promise सामान्य प्रकार void है क्योंकि एक Delete अनुरोध एक खाली वादा लौटाता है।

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

@Delete(':id')
  async deleteBlog(@Param('id') id: string) {
    return await this.service.deleteBlog(id);
  }

API का परीक्षण करना

इस एपीआई का परीक्षण करने के लिए, आपको एपीआई परीक्षण उपकरण का उपयोग करना चाहिए। इस लेख के लिए, मैं पोस्टमैन नामक एक लोकप्रिय एपीआई परीक्षण उपकरण का उपयोग करूँगा। मैं परीक्षण के लिए लोकप्रिय विषयों के बारे में यादृच्छिक डेटा का उपयोग करूंगा।

बनाएं

एक POST http://localhost/3000/blogs के लिए अनुरोध करें निम्नलिखित JSON ऑब्जेक्ट्स के साथ, यह आपके डेटाबेस में सभी डेटा जोड़ देगा।

{
  "title": "jeen-yuhs",
  "body": "The life of superstar rapper Kanye West is currently streaming on Netflix - and according to our jeen-yuhs review, it's a fascinating watch. -credit:Radio Times",
  "category":"Music"
}

{
  "title": "Why You Should Always Wash Your Hands",
  "body": "Germs from unwashed hands can be transferred to other objects, like handrails, tabletops, or toys, and then transferred to another person's hands.-credit cdc.gov",
  "category":"Health"
}

{
  "title": "Why You Should Follow me on Twitter",
  "body": "Well, Because I asked nicely",
  "category":"Random"
}

आपको एक 201 मिलना चाहिए प्रतिक्रिया और एक दिनांक और एक _id . के साथ बनाया गया ब्लॉग जोड़ा गया।

पढ़ें

एक GET बनाएं http://localhost/3000/blogs के लिए अनुरोध करें . इसे वापस करना चाहिए एक

200 आपके द्वारा पहले जोड़े गए सभी डेटा की एक सरणी के साथ प्रतिक्रिया। _id कॉपी करें सरणी वस्तुओं में से एक की संपत्ति।

एक और GET बनाएं http://localhost/3000/blogs/id के लिए अनुरोध करें पहले कॉपी की गई आईडी के साथ। यह एक 200 return लौटाना चाहिए उस वस्तु के डेटा के साथ प्रतिक्रिया जिसकी आईडी का उपयोग अनुरोध करने के लिए किया गया था।

अपडेट करें

एक PUT बनाएं http://localhost/3000/blogs/id के लिए अनुरोध करें नीचे दिए गए डेटा के साथ। id आपके द्वारा पहले कॉपी किए गए से बदला जाना चाहिए। यह एक 200 return लौटाना चाहिए प्रतिक्रिया दें और id वाले ऑब्जेक्ट को अपडेट करें पर्दे के पीछे। अगर आप एक और GET चलाते हैं अनुरोध है कि आपको अद्यतन वस्तु मिलनी चाहिए।

{
  "title": "why you Should Cut your Nails",
  "body": "It's important to trim your nails regularly. Nail trimming together with manicures makes your nails look well-groomed, neat, and tidy.- credit:WebMD",
  "category":"Health"
}

हटाएं

एक delete बनाएं http://localhost/3000/blogs/id के लिए अनुरोध करें .यह एक 200 . लौटाना चाहिए प्रतिक्रिया दें और id . वाले ऑब्जेक्ट को हटा दें पर्दे के पीछे। अगर आप एक और GET चलाते हैं अनुरोध है कि आपको हटाई गई वस्तु दिखाई नहीं देगी।

निष्कर्ष

तो हम अंत में इस लेख के अंत में हैं। आपने जो कवर किया है, उसका संक्षिप्त विवरण दें।

नेस्टजेएस क्या है,
NestJS में शब्दावली,
नेस्टजेएस ऐप बनाना,
MongoDB को NestJS ऐप में एकीकृत करना,
हेरफेर और NestJS ऐप,

यह काफ़ी है, यहाँ तक पहुँचने के लिए बधाई।

आप जीथब पर कोड पा सकते हैं।

NestJS की यात्रा के लिए शुभकामनाएँ!