Creación de una API REST para MongoDB con NestJS

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

export type BookDocument = Book & Document; (2)

@Schema() (3)
export class Book {
  @Prop() (4)
  genre: string;

  @Prop()
  description: string;

  @Prop()
  author: string;

  @Prop()
  pages: number;

  @Prop()
  image_url: string;

  @Prop([String]) (5)
  keywords: string[];
}

export const BookSchema = SchemaFactory.createForClass(Book); (6)

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 }]), (1)
  ],
  controllers: [BooksController],
  providers: [BooksService],
})
export class BooksModule {}

import { ApiProperty } from '@nestjs/swagger';
export class CreateBookDto {
  @ApiProperty({ (1)
    example: 'Nest.js: A Progressive Node.js Framework (English Edition)',
  })
  readonly title: string; (2)

  @ApiProperty({ example: 'Web Development' })
  readonly genre: string;

  @ApiProperty({
    example:
      'JavaScript frameworks go in and out of style very quickly as web technologies change and grow. Nest.js is a good starting point for many developers that are looking to use a modern web framework because it uses a language that is very similar to that of the most used language on the web to this day, JavaScript...',
  })
  readonly description: string;

  @ApiProperty({ example: 'Jay Bell' })
  readonly author: string;

  @ApiProperty({ example: 350 })
  readonly pages: number;

  @ApiProperty({
    example: 'https://m.media-amazon.com/images/I/41fveBeDWmL._SY346_.jpg',
  })
  readonly image_url: string;

  @ApiProperty({ example: ['NestJS', 'REST API'] }) (3)
  readonly keywords: string[];
}

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

@Injectable()
export class BooksService {
  constructor( (1)
    @InjectModel(Book.name) private readonly bookModel: Model<BookDocument>, (2)
  ) {}

  async create(createBookDto: CreateBookDto): Promise<Book> { (3)
    return this.bookModel.create(createBookDto); (4)
  }

  async findAll(): Promise<Book[]> { (5)
    return this.bookModel.find().exec();
  }

  async findOne(id: string): Promise<Book> { (6)
    return this.bookModel.findOne({ _id: id }).exec(); (7)
  }

  async update(id: string, updateBookDto: UpdateBookDto): Promise<Book> { (8)
    return this.bookModel.findOneAndUpdate({ _id: id }, updateBookDto, { (9)
      new: true, (10)
    });
  }

  async remove(id: string) { (11)
    return this.bookModel.findByIdAndRemove({ _id: id }).exec(); (12)
  }
}

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

@Controller('books')
@ApiTags('book') (2)

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

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

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

import { Req } from '@nestjs/common';
import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
} from '@nestjs/common';
import { ApiTags } from '@nestjs/swagger';
import { Request } from 'express'; (1)
import { BooksService } from './books.service';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';

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

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

  @Get()
  findAll(@Req() request: Request) { (2)
    return this.booksService.findAll(request); (3)
  }

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

import { Injectable } from '@nestjs/common';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';
import { InjectModel } from '@nestjs/mongoose';
import { Book, BookDocument } from './schemas/book.schema';
import { Model } from 'mongoose';
import { Request } from 'express'; (1)

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

  async create(createBookDto: CreateBookDto): Promise<Book> {
    return this.bookModel.create(createBookDto);
  }

  async findAll(request: Request): Promise<Book[]> { (2)
    return this.bookModel
      .find(request.query) (3)
      .setOptions({ sanitizeFilter: true }) (4)
      .exec();
  }

  async findOne(id: string): Promise<Book> {
    return this.bookModel.findOne({ _id: id }).exec();
  }

  async update(id: string, updateBookDto: UpdateBookDto) {
    return this.bookModel.findOneAndUpdate({ _id: id }, updateBookDto, {
      new: true,
    });
  }

  async remove(id: string) {
    return this.bookModel.findByIdAndRemove({ _id: id }).exec();
  }
}

{
  "genre": "Web Development",
  "description": "JavaScript frameworks go in and out of style very quickly as web technologies change and grow. Nest.js is a good starting point for many developers that are looking to use a modern web framework because it uses a language that is very similar to that of the most used language on the web to this day, JavaScript...",
  "author": "Jay Bell",
  "pages": 350,
  "image_url": "https://m.media-amazon.com/images/I/41fveBeDWmL._SY346_.jpg",
  "keywords": [
    "NestJS",
    "REST API"
  ],
  "_id": "62594f8ddae1eebf6c6c209c",
  "__v": 0
}

$ http://localhost:3000/books?pages=350

http://localhost:3000/books?pages=350&genre=Web%20Development

http://localhost:3000/books?keywords=NestJS

{
  "pages": 400
}

{
  "_id": "62594f8ddae1eebf6c6c209c",
  "genre": "Web Development",
  "description": "JavaScript frameworks go in and out of style very quickly as web technologies change and grow. Nest.js is a good starting point for many developers that are looking to use a modern web framework because it uses a language that is very similar to that of the most used language on the web to this day, JavaScript...",
  "author": "Jay Bell",
  "pages": 400,
  "image_url": "https://m.media-amazon.com/images/I/41fveBeDWmL._SY346_.jpg",
  "keywords": [
    "NestJS",
    "REST API"
  ],
  "__v": 0
}

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

export type UserDocument = User & Document; (2)

@Schema() (3)
export class User {
  @Prop() (4)
  _id: string; (5)

  @Prop()
  name: string;

  @Prop()
  email: string;

  @Prop()
  country: string;
}

export const UserSchema = SchemaFactory.createForClass(User); (6)
}

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import { MongooseModule } from '@nestjs/mongoose';
import { User, UserSchema } from './schemas/user.schema';

@Module({
  imports: [
    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]), (1)
  ],
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

import { ApiProperty } from '@nestjs/swagger';

export class CreateUserDto {
  @ApiProperty({ example: 'johndoe' }) (1)
  readonly _id: string; (2)

  @ApiProperty({ example: 'John Doe' })
  readonly name: string;

  @ApiProperty({ example: 'johndoe@gmail.com' })
  readonly email: string;

  @ApiProperty({ example: 'Spain' })
  readonly country: string;
}

import { Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User, UserDocument } from './schemas/user.schema';

@Injectable()
export class UsersService {
  constructor( (1)
    @InjectModel(User.name) private readonly userModel: Model<UserDocument>, (2)
  ) {}

  async create(createUserDto: CreateUserDto): Promise<User> { (3)
    return this.userModel.create(createUserDto); (4)
  }

  async findAll(): Promise<User[]> { (5)
    return this.userModel.find().exec();
  }

  async findOne(id: string): Promise<User> { (6)
    return this.userModel.findOne({ _id: id }).exec(); (7)
  }

  async update(id: string, updateUserDto: UpdateUserDto) { (8)
    return this.userModel.findOneAndUpdate({ _id: id }, updateUserDto, { (9)
      new: true, (10)
    });
  }

  async remove(id: string) { (11)
    return this.userModel.findByIdAndRemove({ _id: id }).exec(); (12)
  }
}

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
} from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { ApiTags } from '@nestjs/swagger'; (1)

@Controller('users')
@ApiTags('user') (2)

export class UsersController {
  constructor(private readonly userService: UsersService) {}

  @Post()
  async create(@Body() createUserDto: CreateUserDto) {
    return this.userService.create(createUserDto);
  }

  @Get()
  async findAll() {
    return this.userService.findAll();
  }

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

  @Patch(':id')
  async update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    return this.userService.update(id, updateUserDto); (4)
  }

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

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  Req
} from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { ApiTags } from '@nestjs/swagger';
import { Request } from 'express'; (1)

@Controller('users')
@ApiTags('user')

export class UsersController {
  constructor(private readonly userService: UsersService) {}

  @Post()
  async create(@Body() createUserDto: CreateUserDto) {
    return this.userService.create(createUserDto);
  }

  @Get()
  async findAll(@Req() request: Request) { (2)
    return this.userService.findAll(request); (3)
  }

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

  @Patch(':id')
  async update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
    return this.userService.update(id, updateUserDto);
  }

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

import { Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User, UserDocument } from './schemas/user.schema';
import { Request } from 'express'; (1)

@Injectable()
export class UsersService {
  constructor(
    @InjectModel(User.name) private readonly userModel: Model<UserDocument>,
  ) {}

  async create(createUserDto: CreateUserDto): Promise<User> {
    return this.userModel.create(createUserDto);
  }

  async findAll(request: Request): Promise<User[]> { (2)
    return this.userModel
      .find(request.query) (3)
      .setOptions({ sanitizeFilter: true }) (4)
      .exec();
  }

  async findOne(id: string): Promise<User> {
    return this.userModel.findOne({ _id: id }).exec();
  }

  async update(id: string, updateUserDto: UpdateUserDto): Promise<User> {
    return this.userModel.findOneAndUpdate({ _id: id }, updateUserDto, {
      new: true,
    });
  }

  async remove(id: string) {
    return this.userModel.findByIdAndRemove({ _id: id }).exec();
  }
}

{
  "_id": "johndoe",
  "name": "John Doe",
  "email": "johndoe@gmail.com",
  "country": "Spain",
  "__v": 0
}

{
  "_id": "marysmith",
  "name": "Mary Smith",
  "email": "marysmith@gmail.com",
  "country": "France"
}

$ http://localhost:3000/users?country=spain

{
  "country": "Italy"
}

{
  "_id": "johndoe",
  "name": "John Doe",
  "email": "johndoe@gmail.com",
  "country": "Italy",
  "__v": 0
}

import { Schema, Prop, SchemaFactory } from '@nestjs/mongoose';
import { ApiProperty } from '@nestjs/swagger';
import { Document } from 'mongoose';
import { User } from '../../users/schemas/user.schema';
import mongoose from 'mongoose';

export type CommentDocument = Comment & Document;

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

  @Prop()
  stars: number;

  @Prop()
  comment: string;

  @Prop({ type: mongoose.Schema.Types.String, ref: 'User' }) (1)
  username: User; (2)
}

export const CommentSchema = SchemaFactory.createForClass(Comment);

import { Schema, Prop, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';
import { CommentSchema } from './comment.schema';

export type BookDocument = Book & Document;

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

  @Prop()
  description: string;

  @Prop()
  author: string;

  @Prop()
  pages: number;

  @Prop()
  image_url: string;

  @Prop([String])
  keywords: string[];

  @Prop([CommentSchema]) (1)
  comments: Comment[]; (2)
}

export const BookSchema = SchemaFactory.createForClass(Book);

[
  {
    "_id": "62594f8ddae1eebf6c6c209c",
    "genre": "Web Development",
    "description": "JavaScript frameworks go in and out of style very quickly as web technologies change and grow. Nest.js is a good starting point for many developers that are looking to use a modern web framework because it uses a language that is very similar to that of the most used language on the web to this day, JavaScript...",
    "author": "Jay Bell",
    "pages": 350,
    "image_url": "https://m.media-amazon.com/images/I/41fveBeDWmL._SY346_.jpg",
    "keywords": [
      "NestJS",
      "REST API"
    ],
    "__v": 0,
    "comments": [] (1)
  }
]

import { ApiProperty } from '@nestjs/swagger';
import { User } from '../../users/schemas/user.schema';

export class CreateCommentDto {
  @ApiProperty({ example: 'Esperaba más' })
  readonly title: string;

  @ApiProperty({
    example: 3,
  })
  readonly stars: number;

  @ApiProperty({
    example:
      'Nisi officia fugiat id nulla laboris ex. Sit laboris culpa occaecat occaecat aliquip dolor non excepteur reprehenderit.',
  })
  readonly comment: string;

  @ApiProperty({ example: 'johndoe' })
  readonly username: User;
}

import { Injectable } from '@nestjs/common';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';
import { InjectModel } from '@nestjs/mongoose';
import { Book, BookDocument } from './schemas/book.schema';
import { Model } from 'mongoose';
import { Request } from 'express';

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

  async create(createBookDto: CreateBookDto): Promise<Book> {
    return this.bookModel.create(createBookDto);
  }

  async findAll(request: Request): Promise<Book[]> {
    return this.bookModel
      .find(request.query)
      .setOptions({ sanitizeFilter: true })
      .exec();
  }

  async findOne(id: string): Promise<Book> {
    return this.bookModel.findOne({ _id: id }).exec();
  }

  async update(id: string, updateBookDto: UpdateBookDto): Promise<Book> {
    return this.bookModel.findOneAndUpdate({ _id: id }, updateBookDto, {
      new: true,
    });
  }

  async remove(id: string) {
    return this.bookModel.findByIdAndRemove({ _id: id }).exec();
  }

  async addComment(id: string, comment: any) { (1)
    let book: BookDocument = await this.bookModel.findById(id); (2)
    book.comments.push(comment); (3)
    book.save(); (4)
    return book;
  }
}

import { Req } from '@nestjs/common';
import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
} from '@nestjs/common';
import { ApiTags } from '@nestjs/swagger';
import { Request } from 'express';
import { BooksService } from './books.service';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';
import { ParseObjectIdPipe } from '../utilities/parse-object-id-pipe.pipe';
import { CreateCommentDto } from './dto/create-comment.dto';

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

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

  @Get()
  findAll(@Req() request: Request) {
    return this.booksService.findAll(request);
  }

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

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

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

  @Post(':id/comment') (1)
  async addComment(
    @Param('id', ParseObjectIdPipe) id: string, (2)
    @Body() comment: CreateCommentDto, (3)
  ) {
    return this.booksService.addComment(id, comment); (4)
  }
}

{
  "_id": "62594f8ddae1eebf6c6c209c",
  "genre": "Web Development",
  "description": "JavaScript frameworks go in and out of style very quickly as web technologies change and grow. Nest.js is a good starting point for many developers that are looking to use a modern web framework because it uses a language that is very similar to that of the most used language on the web to this day, JavaScript...",
  "author": "Jay Bell",
  "pages": 350,
  "image_url": "https://m.media-amazon.com/images/I/41fveBeDWmL._SY346_.jpg",
  "keywords": [
    "NestJS",
    "REST API"
  ],
  "__v": 1,
  "comments": [
    { (1)
      "title": "Esperaba más",
      "stars": 3,
      "comment": "Nisi officia fugiat id nulla laboris ex. Sit laboris culpa occaecat occaecat aliquip dolor non excepteur reprehenderit.",
      "username": "johndoe", (2)
      "_id": "625bade7c73a12ec6c5c9c16"
    }
  ]
}

{
  "title": "Me encantó",
  "stars": 5,
  "comment": "Non consequat laborum pariatur et tempor fugiat excepteur. Incididunt minim voluptate nostrud Lorem ullamco consectetur sint veniam amet non aliqua proident. Cillum reprehenderit veniam nulla ex eiusmod id sit tempor. Consectetur nostrud Lorem duis culpa sit incididunt aliqua.",
  "username": "marysmith",
}

{
  "_id": "62594f8ddae1eebf6c6c209c",
  "genre": "Web Development",
  "description": "JavaScript frameworks go in and out of style very quickly as web technologies change and grow. Nest.js is a good starting point for many developers that are looking to use a modern web framework because it uses a language that is very similar to that of the most used language on the web to this day, JavaScript...",
  "author": "Jay Bell",
  "pages": 350,
  "image_url": "https://m.media-amazon.com/images/I/41fveBeDWmL._SY346_.jpg",
  "keywords": [
    "NestJS",
    "REST API"
  ],
  "__v": 1,
  "comments": [
    { (1)
      "title": "Esperaba más",
      "stars": 3,
      "comment": "Nisi officia fugiat id nulla laboris ex. Sit laboris culpa occaecat occaecat aliquip dolor non excepteur reprehenderit.",
      "username": "johndoe",
      "_id": "625bade7c73a12ec6c5c9c16"
    },
    { (2)
      "title": "Me encantó",
      "stars": 5,
      "comment": "Non consequat laborum pariatur et tempor fugiat excepteur. Incididunt minim voluptate nostrud Lorem ullamco consectetur sint veniam amet non aliqua proident. Cillum reprehenderit veniam nulla ex eiusmod id sit tempor. Consectetur nostrud Lorem duis culpa sit incididunt aliqua.",
      "username": "marysmith",
      "_id": "625baedcc73a12ec6c5c9c19"
    }
  ]
}

import { Injectable } from '@nestjs/common';
import { CreateBookDto } from './dto/create-book.dto';
import { UpdateBookDto } from './dto/update-book.dto';
import { InjectModel } from '@nestjs/mongoose';
import { Book, BookDocument } from './schemas/book.schema';
import { Model } from 'mongoose';
import { Request } from 'express';

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

  async create(createBookDto: CreateBookDto): Promise<Book> {
    return this.bookModel.create(createBookDto);
  }

  async findAll(request: Request): Promise<Book[]> {
    return this.bookModel
      .find(request.query)
      .populate({ path: 'comments.username' }) (1)
      .setOptions({ sanitizeFilter: true })
      .exec();
  }

  async findOne(id: string): Promise<Book> {
    return this.bookModel
      .findOne({ _id: id })
      .populate({ path: 'comments.username' }) (2)
      .exec();
  }

  async update(id: string, updateBookDto: UpdateBookDto): Promise<Book> {
    return this.bookModel.findOneAndUpdate({ _id: id }, updateBookDto, {
      new: true,
    });
  }

  async remove(id: string) {
    return this.bookModel.findByIdAndRemove({ _id: id }).exec();
  }

  async addComment(id: string, comment: any) {
    let book: BookDocument = await this.bookModel.findById(id);
    book.comments.push(comment);
    book.save();
    return book;
  }
}

[
  {
    "_id": "62594f8ddae1eebf6c6c209c",
    "genre": "Web Development",
    "description": "JavaScript frameworks go in and out of style very quickly as web technologies change and grow. Nest.js is a good starting point for many developers that are looking to use a modern web framework because it uses a language that is very similar to that of the most used language on the web to this day, JavaScript...",
    "author": "Jay Bell",
    "pages": 350,
    "image_url": "https://m.media-amazon.com/images/I/41fveBeDWmL._SY346_.jpg",
    "keywords": [
      "NestJS",
      "REST API"
    ],
    "__v": 2,
    "comments": [
      {
        "title": "Esperaba más",
        "stars": 3,
        "comment": "Nisi officia fugiat id nulla laboris ex. Sit laboris culpa occaecat occaecat aliquip dolor non excepteur reprehenderit.",
        "username": { (1)
          "_id": "johndoe",
          "name": "John Doe",
          "email": "johndoe@gmail.com",
          "country": "Italy",
          "__v": 0
        },
        "_id": "625bade7c73a12ec6c5c9c16"
      },
      {
        "title": "Me encantó",
        "stars": 5,
        "comment": "Non consequat laborum pariatur et tempor fugiat excepteur. Incididunt minim voluptate nostrud Lorem ullamco consectetur sint veniam amet non aliqua proident. Cillum reprehenderit veniam nulla ex eiusmod id sit tempor. Consectetur nostrud Lorem duis culpa sit incididunt aliqua.",
        "username": { (2)
          "_id": "marysmith",
          "name": "Mary Smith",
          "email": "marysmith@gmail.com",
          "country": "France",
          "__v": 0
        },
        "_id": "625baedcc73a12ec6c5c9c19"
      }
    ]
  }
]