Node.js Backend Development Bootcamp · Lección

ODM Mongoose para el modelado de datos

Aprenda a definir esquemas y modelos con Mongoose para estructurar sus datos eficazmente en MongoDB.

ODM Mongoose para el modelado de datos es una lección gratuita de Node.js Backend Development Bootcamp en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Node.js Backend Development Bootcamp, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Node.js Backend Development Bootcamp incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Meet Mongoose Schemas

In the last lesson, we connected to MongoDB. Now, let's learn how to structure our data with Mongoose and Schemas.

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It provides a straightforward, schema-based solution to model your application data, making it easier to work with MongoDB.

Why Schemas Matter

MongoDB is a NoSQL database, meaning it's schema-less by default. While this offers great flexibility, it can lead to inconsistent data if not managed.

Mongoose schemas bring structure and consistency:

Define Data Shape: What fields a document should have.
Data Types: Ensure fields store correct types (String, Number, etc.).
Validation: Add rules like 'required' or 'minimum length'.

Defining Your First Schema

Let's define a basic schema for a Book. We'll specify properties like title and author, and their expected data types.

First, we need to import Mongoose, then create a new Schema object.

const mongoose = require('mongoose');

// Define the Book Schema
const bookSchema = new mongoose.Schema({
  title: String,
  author: String,
  pages: Number,
  isPublished: Boolean
});

console.log('Book Schema defined!');
// In a real app, this schema would be used to create a model.

Common Schema Types

Mongoose supports many data types that map to JavaScript types and MongoDB BSON types. Here are some of the most common ones:

String: For text like names, descriptions.
Number: For numerical values like age, price.
Boolean: For true/false values.
Date: For storing dates and times.
ObjectId: A special type for unique IDs, often used for references between documents.

Schema Options: Required & Default

Beyond just types, schemas allow you to add options to each field. These options control behavior and validation. Two common ones are required and default.

required: true: Means this field must have a value.
default: 'value': Provides a fallback value if none is specified during document creation.

const mongoose = require('mongoose');

const productSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true // Name is mandatory
  },
  price: {
    type: Number,
    required: true,
    default: 0 // Default price is 0 if not set
  },
  createdAt: {
    type: Date,
    default: Date.now // Automatically set current date
  }
});

console.log('Product Schema with options defined!');

Creating a Mongoose Model

A schema is like a blueprint. To actually interact with your MongoDB collection, you need to create a Model from that schema.

A Mongoose Model is a wrapper around the schema that provides an interface for the database: creating, querying, updating, and deleting records in a specific collection.

const mongoose = require('mongoose');

// Define a simple User Schema
const userSchema = new mongoose.Schema({
  name: String,
  email: String
});

// Create a Model from the schema
// 'User' is the singular name. Mongoose will use 'users' as collection name.
const User = mongoose.model('User', userSchema);

console.log('User Model created from schema!');
// Now you can use the User model to interact with the 'users' collection.

Basic Field Validation

Mongoose schemas offer built-in validation to ensure data integrity before saving to the database. This helps keep your data clean and consistent.

You can define validators like minlength, maxlength, and enum (a list of allowed values) directly within your schema definition.

const mongoose = require('mongoose');

const taskSchema = new mongoose.Schema({
  description: {
    type: String,
    required: true,
    minlength: 5, // Must be at least 5 characters
    maxlength: 100 // Max 100 characters
  },
  status: {
    type: String,
    enum: ['pending', 'completed', 'cancelled'], // Only these values allowed
    default: 'pending'
  }
});

console.log('Task Schema with validation rules defined!');

Embedding Documents

Sometimes, one document logically 'contains' another. Mongoose allows you to embed schemas directly within other schemas, creating nested documents.

This is useful for tightly coupled data that doesn't need its own separate collection, like an address within a user profile.

const mongoose = require('mongoose');

// Define an Address Schema
const addressSchema = new mongoose.Schema({
  street: String,
  city: String,
  zip: String
});

// Embed Address Schema within a Person Schema
const personSchema = new mongoose.Schema({
  name: String,
  // The 'address' field will be a nested document using addressSchema
  address: addressSchema 
});

console.log('Person Schema with embedded Address Schema defined!');
// A 'Person' document will now contain an 'address' object.

Quick Check: Schema Fields

Imagine you're building a schema for a blog post. It needs a title (required string), content (string), and publishDate (date, defaults to now).

Which of the following Mongoose schema definitions correctly sets up these fields and their options?

Recap: Schemas & Models

Great job! You've learned the essentials of Mongoose schemas and models:

Schemas define the structure, data types, and validation rules for your MongoDB documents.
They provide consistency in a schema-less database.
You create Models from schemas to interact with specific collections in MongoDB.
We explored common types, options like required and default, and even embedding documents.

Next, we'll use these models to perform CRUD operations (Create, Read, Update, Delete)!

Preguntas frecuentes

¿La lección «ODM Mongoose para el modelado de datos» es gratis?

Sí — el texto completo de «ODM Mongoose para el modelado de datos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Node.js Backend Development Bootcamp, actualiza a CoddyKit PRO. El curso de Node.js Backend Development Bootcamp incluye 4 lecciones en total.

¿Qué aprenderé en «ODM Mongoose para el modelado de datos»?

Aprenda a definir esquemas y modelos con Mongoose para estructurar sus datos eficazmente en MongoDB. Practicas Node.js Backend Development Bootcamp con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Node.js Backend Development Bootcamp?

No se requiere experiencia previa. Node.js Backend Development Bootcamp en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «ODM Mongoose para el modelado de datos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Node.js Backend Development Bootcamp?

Sí. Cada lección de Node.js Backend Development Bootcamp incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Conexión de Node.js con MongoDB
ODM Mongoose para el modelado de datos
Operaciones CRUD con Mongoose
Consultas y filtrado de datos con Mongoose

← Volver a Node.js Backend Development Bootcamp