Búsqueda de sitios web

mongodb - Pregunta sobre NestJS con enfoque de esquema, interfaz y dto de mongoose

Soy nuevo en NestJS y MongoDB y no me queda claro por qué necesitamos declarar DTO, esquema e interfaz para cada colección que queremos guardar en nuestro MongoDB. Es decir, tengo una colección (desafortunadamente la he llamado collection pero no importa) y este es mi DTO:

export class CollectionDto {
  readonly description: string;
  readonly name: string;
  readonly expiration: Date;
}

interfaz :

import { Document } from 'mongoose';

export interface Collection extends Document {
  readonly description: string;
  readonly name: string;
  readonly expiration: Date;
}

y esquema:

import * as mongoose from 'mongoose';

export const CollectionSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
  },
  description: {
    type: String,
    required: false,
  },
  expiration: {
    type: String,
    required: true,
  }
});

Mi duda es si realmente necesitamos hasta tres objetos con casi el mismo contenido. Parece extraño a primera vista.

Respuesta #1

Estuve trabajando mucho con mongoose en Node.js puro y también estoy empezando a trabajar con NestJS. Mongoose define dos cosas para que puedas usar MongoDB para crear, consultar, actualizar y eliminar documentos: Schema y Model. Ya tienes tu schema, y para el modelo en mongoose puro debería ser así:

import * as mongoose from 'mongoose';

export const CollectionSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
  },
  description: {
    type: String,
    required: false,
  },
  expiration: {
    type: String,
    required: true,
  }
});
const Collection = mongoose.model('collections', CollectionSchema);

La colección aquí será el modelo de mongoose. Hasta ahora todo bien.

En NestJs, y si vas a seguir las mejores prácticas de API, usarás un DTO (Objeto de Transferencia de Datos). NestJs en la documentación menciona que es preferible usar clases en lugar de interfaces, así que no necesitas interfaces aquí. Cuando defines un esquema de Mongoose, también puedes definir Modelo/Esquema:

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

export type CollectionDocument = Collection & Document;

@Schema()
export class Collection {
  @Prop()
  name: string;

  @Prop()
  description: number;

  @Prop()
  expiration: string;
}

export const CollectionSchema = SchemaFactory.createForClass(Collection);

Y para sus servicios y controladores utiliza ambos (modelo y DTO):

import { Model } from 'mongoose';
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Collection, CollectionDocument } from './schemas/collection.schema';
import { CollectionDto } from './dto/collection.dto';

@Injectable()
export class CollectionService {
  constructor(@InjectModel(Collection.name) private collectionModel: Model<CollectionDocument>) {}

  async create(createColDto: CollectionDto): Promise<Collection> {
    const createdCollection = new this.collectionModel(createColDto);
    return createdCollection.save();
  }

  async findAll(): Promise<Collection[]> {
    return this.collectionModel.find().exec();
  }
}

Después de esto, puedes usar Swagger para la documentación automática de tus APIs. Técnicas de NestJS con Mongo

Artículos relacionados