O ABC do NestJS:um guia para iniciantes com MongoDB (Mongoose).

O que é NestJS?

Pré-requisitos

• Competência em PostMan ou qualquer outra ferramenta de teste de API.
• Conhecimento básico de aplicativos NodeJS e Express.
• Conhecimento básico de TypeScript.
• Competência em MongoDB (Mongoose).

• NodeJS v.14 e superior.
• Código do Visual Studio (recomendado) ou qualquer outro IDE.
• PostMan ou qualquer outra ferramenta de teste de API.

Terminologias comuns usadas no NestJS;

Interfaces

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

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

Controladores

Serviços

Decoradores

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

Módulo

Instalando a CLI

npm i -g @nestjs/cli

Criando um novo projeto

nest new Blog-Api

• abra a pasta src e dentro dela,
• excluir app.controller.spec.ts ,
• excluir app.controller.ts ,
• excluir app.service.ts ,
• Abra app.module.ts ,
• Remova a referência a AppController nos controllers array e as importações,
• Remova a referência a AppService nos providers array e as importações.

//app.module.ts

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

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

Variáveis ​​Ambientais

npm i dotenv

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

//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();

Gerando Módulos

nest generate module blogs

Gerando interfaces

cd src/blogs

nest generate interface blogs

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

cd ../..

Gerando serviços e controladores

Serviço

nest generate service blogs

Controlador

nest generate controller blogs

//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(Mongoose).

npm install --save @nestjs/mongoose mongoose

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

Criando um esquema.

• Crie uma pasta dentro de seus blogs pasta, nomeie-a schemas ,
• Dentro dos schemas pasta, crie um arquivo e chame-o de blogs.schema.ts .

• Importar o prop decorador, o Schema decorador e o SchemaFactory de @nestjs/mongoose ,
• Criar uma classe Blog e exportá-lo,
• Transforme a classe em um Schema colocando o @Schema() decorador acima da classe,
• Criar uma constante BlogSchema , atribua o valor de retorno de chamar o .createForClass(Blog) com o nome de sua classe como argumento em SchemaFactory que você importou anteriormente.

//blogs.schema.ts

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

@Schema()
export class Blog {}

export const BlogSchema = SchemaFactory.createForClass(Blog);

//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);

//blogs.schema.ts

import { Document } from 'mongoose';

export type BlogDocument = Blog & Document;

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);

Esquema de registro

• Importar {MongooseModule} de '@nestjs/mongoose’ ,
• Importar {Blog, BlogSchema} de './schemas/blogs.schema’
• Crie uma imports array dentro do @module decorador
• Chame o .forFeature() método no MongooseModule . Isso recebe um array contendo um objeto que define um name e um schema propriedade que deve ser definida para seu Blog.name e seu BlogSchema respectivamente.

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

Injetando Esquema

• importar { Model } de 'mongoose' ,
• importar { InjectModel } de '@nestjs/mongoose’ ,
• Importar {Blog, BlogDocument} de './schemas/blogs.schema’ ,
• Crie um constructor dentro do BlogsService classe,
• Declarar um private variável e chame-a de blogModel e atribua um tipo de Model<BlogDocument> para isso. Todos os métodos do mangusto serão chamados nesta variável.

• Decore blogModel com @InjectModel() e passe Blog.name como argumento.

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

Como funciona o roteamento

Lógica de serviço e controlador.

//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(private readonly service: BlogsService) {}

Criar

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

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

Leia

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);
  }

Atualizar

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);
  } 

Excluir

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

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

Testando a API

Criar

{
  "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"
}

Leia

Atualizar

{
  "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"
}

Excluir

Conclusão

• O que é NestJS,
• Terminologias no NestJS,
• Criando um aplicativo NestJS,
• Integrando o MongoDB em um aplicativo NestJS,
• Aplicativo de manipulação e NestJS,