NestJs Create CRUD And Mongo AND softDelete

Step1 : nest g res Books

For SoftDelete
https://www.npmjs.com/package/soft-delete-plugin-mongoose

books.controller.ts

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { BooksService } from './books.service';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';

@Controller('books')
export class BooksController {
  constructor(private readonly booksService: BooksService) {}

  @Post()
  create(@Body() createBookDto: CreateBookDto) {
    return this.booksService.create(createBookDto);
  }

  @Get()
  findAll() {
    return this.booksService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.booksService.findOne(id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateBookDto: UpdateBookDto) {
    return this.booksService.update(id, updateBookDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.booksService.remove(id);
  }
}

books.module.ts

import { Module } from '@nestjs/common';
import { BooksService } from './books.service';
import { BooksController } from './books.controller';
import {MongooseModule} from "@nestjs/mongoose";
import {Book,BookSchema} from "./schemas/book.schema";

@Module({
  imports:      [
                    MongooseModule.forFeature([
                                                        {
                                                            name: Book.name,
                                                            schema: BookSchema
                                                        }
                                                      ]
                                            )
                ],
  controllers:  [BooksController],
  providers:    [BooksService]
})
export class BooksModule {}

books.service.ts

import { Injectable } from '@nestjs/common';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';
import { Book, BookDocument } from './schemas/book.schema';
import {InjectModel} from "@nestjs/mongoose";
import {Model} from "mongoose";
import {SoftDeleteModel} from "soft-delete-plugin-mongoose";

@Injectable()
export class BooksService {
  constructor(@InjectModel(Book.name) private bookModel: SoftDeleteModel<BookDocument>) {}


  async create(createBookDto: CreateBookDto): Promise<Book> {
    const createdBook = new this.bookModel(createBookDto);
    return createdBook.save();
  }

  findAll() {
    return this.bookModel.find().exec();
  }

  findOne(id: string) {
    return this.bookModel.findById(id);
  }

  update(id: string, updateBookDto: UpdateBookDto) {
    const filter = { _id: id };
    return this.bookModel.updateOne(filter,updateBookDto);
  }

  async remove(id: string) {
    const filter  = { _id: id };

    const deleted = await this.bookModel.softDelete(filter);
    return deleted;

    //return this.bookModel.deleteOne(filter);
    //return this.bookModel.;
  }
}

create-book.dto.ts

import { IsOptional, IsString } from "class-validator";

export class CreateBookDto{

    @IsOptional()
    @IsString()
    title: string ;

    @IsOptional()
    count: number;
}

update-book.dto.ts

import { PartialType } from '@nestjs/mapped-types';
import { CreateBookDto } from './create-book.dto';

export class UpdateBookDto extends PartialType(CreateBookDto) {}

book.entity.ts

import { PartialType } from '@nestjs/mapped-types';
import { CreateBookDto } from './create-book.dto';

export class UpdateBookDto extends PartialType(CreateBookDto) {}

book.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';
import { softDeletePlugin, SoftDeleteModel } from 'soft-delete-plugin-mongoose';


export type BookDocument = Book & Document;

@Schema()
export class Book {
  @Prop()
  title: string;

  @Prop()
  count: number;




}


export const BookSchema = SchemaFactory.createForClass(Book).plugin(softDeletePlugin);