¡Convierte JSON a esquema de Mongoose (TypeScript)!

¡Introduce JSON y conviértelo a esquema de Mongoose (TypeScript)! Compatible con NestJS @nestjs/mongoose @Schema, @Prop, SchemaFactory, MongoDB.
JSON
Resultado
 

¡Convierte JSON a esquema de Mongoose (TypeScript)!

Convierte JSON en una clase de schema de NestJS con @nestjs/mongoose: una clase @Schema() con @Prop() en cada campo, el schema construido con SchemaFactory.createForClass() y un tipo ProductDocument, todo en un solo archivo. Cada campo lleva además @IsNotEmpty() o @IsOptional() de class-validator.

Úsalo cuando un módulo de NestJS necesita un schema para registrar con MongooseModule.forFeature(), ya tienes un ejemplo del documento que se va a guardar y escribir cada decorador a mano es la parte lenta.

Cómo usar

  1. Pega un documento de ejemplo en la entrada. Si algunos campos solo aparecen a veces, pega varios documentos como array para que se detecten los campos opcionales.
  2. Escribe el nombre de la clase en Nombre del modelo (por defecto MyModel). Si escribes product, se generan Product, ProductDocument y ProductSchema.
  3. Guarda el resultado como product.schema.ts y regístralo con MongooseModule.forFeature([{ name: Product.name, schema: ProductSchema }]).

Ejemplo

Entrada (JSON)
{
  "sku": "KB-87-RED",
  "title": "Mechanical keyboard",
  "price": 89.5,
  "stock": 42,
  "discontinued": false,
  "restocked_at": "2024-03-18"
}
Salida (NestJS @nestjs/mongoose)
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document, Schema as MongooseSchema } from 'mongoose';
import { IsNotEmpty, IsOptional } from 'class-validator';

export type ProductDocument = Product & Document;

@Schema()
export class Product {
  _id: MongooseSchema.Types.ObjectId;

  @Prop({ type: MongooseSchema.Types.String, required: true })
  @IsNotEmpty()
  sku: string;

  @Prop({ type: MongooseSchema.Types.String, required: true })
  @IsNotEmpty()
  title: string;

  @Prop({ type: MongooseSchema.Types.Number, required: true })
  @IsNotEmpty()
  price: number;

  @Prop({ type: MongooseSchema.Types.Number, required: true })
  @IsNotEmpty()
  stock: number;

  @Prop({ type: MongooseSchema.Types.Boolean, required: true })
  @IsNotEmpty()
  discontinued: boolean;

  @Prop({ type: MongooseSchema.Types.Date, required: true })
  @IsNotEmpty()
  restocked_at: Date;
}

export const ProductSchema = SchemaFactory.createForClass(Product);

El ejemplo es un único documento con todos los campos rellenos, así que cada campo recibe required: true y @IsNotEmpty(). restocked_at es una cadena con formato de fecha, así que se tipa como Date, y la propiedad conserva el nombre de clave almacenado restocked_at.

Funciones compatibles

  • Los tipos de Mongoose son explícitos, p. ej. @Prop({ type: MongooseSchema.Types.String, required: true }). El Schema de Mongoose se importa como MongooseSchema para que no choque con el decorador Schema.
  • Tipos de TypeScript: number, boolean, Date para cadenas de fecha ISO 8601, string para todo lo demás, incluidas las cadenas solo de dígitos como "0042".
  • Los objetos anidados se declaran con MongooseSchema.Types.Mixed y se tipan como Record<string, unknown>; los arrays de un tipo simple pasan p. ej. a [MongooseSchema.Types.String] con string[].
  • Los nombres de propiedad son las claves JSON sin cambios, entre comillas cuando hace falta ('home-url': string), así que la clase coincide con los documentos que ya están en la colección.
  • Los campos con valor no vacío en todos los documentos reciben required: true más @IsNotEmpty(); el resto solo @IsOptional(). Una clave _id en la entrada se omite porque _id: MongooseSchema.Types.ObjectId ya está declarado.
  • Se genera export type ProductDocument = Product & Document para inyectarlo como @InjectModel(Product.name) model: Model<ProductDocument>.

Casos de uso

Añadir una colección a un servicio NestJS

Pasa el payload de un evento que te envió otro equipo, o el JSON de un scraper, para obtener la clase de schema, inyéctala con @InjectModel y llama a create o find de inmediato.

Pasar un modelo Mongoose de Express a NestJS

Exporta unos cuantos documentos guardados por el antiguo modelo new Schema({...}) y pégalos aquí para reescribirlo como clase basada en decoradores sin perder campos al copiarlos a mano.

Notas y limitaciones

  • @IsNotEmpty() y @IsOptional() están en la clase de schema, pero ValidationPipe valida los DTOs de los controllers. Para validar peticiones, mueve estos decoradores a una clase DTO o crea una.
  • @Schema() no tiene opciones, así que el nombre de la colección sigue la regla de Mongoose de pasar el nombre del modelo a minúsculas y a plural: products. Configura @Schema({ collection: 'product' }) si necesitas un nombre concreto.
  • Los campos opcionales siguen saliendo sin ? (p. ej. memo: string). Con strictNullChecks, es más seguro cambiarlos a memo?: string.
  • Los subdocumentos se guardan como Mixed en lugar de schemas tipados. Para validar dentro de ellos, define una clase @Schema() aparte y usa @Prop({ type: SubSchema }).

Preguntas frecuentes

¿Por qué & Document en lugar de extender Document?

Sigue el patrón por defecto de la documentación de NestJS: la clase de schema se queda como una definición simple de campos y ProductDocument se usa solo donde hacen falta métodos de documento de Mongoose como save(). En Mongoose 7+, HydratedDocument<Product> es una alternativa directa.

¿Y si mi proyecto no usa class-validator?

Borra la línea import { IsNotEmpty, IsOptional } from 'class-validator' y los dos decoradores de cada campo. El comportamiento del schema lo controla solo el required de @Prop().

¿Tengo que especificar type en @Prop()?

Con emitDecoratorMetadata se pueden inferir los tipos simples, pero la inferencia falla con arrays y uniones como Date | null. El código generado indica type de antemano para que el comportamiento no cambie si más adelante modificas el tipo TypeScript de una propiedad.