Node.js Backend Development Bootcamp · Ders

Veri Modellemede Mongoose ODM

Mongoose ile şemalar ve modeller tanımlamayı, verilerinizi MongoDB'de etkili biçimde yapılandırmayı öğrenin.

Veri Modellemede Mongoose ODM, CoddyKit'te ücretsiz bir Node.js Backend Development Bootcamp dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Node.js Backend Development Bootcamp öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Node.js Backend Development Bootcamp kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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)!

Sıkça Sorulan Sorular

“Veri Modellemede Mongoose ODM” dersi ücretsiz mi?

Evet — “Veri Modellemede Mongoose ODM” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Node.js Backend Development Bootcamp kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Node.js Backend Development Bootcamp kursu toplamda 4 dersten oluşur.

“Veri Modellemede Mongoose ODM” dersinde ne öğreneceğim?

Mongoose ile şemalar ve modeller tanımlamayı, verilerinizi MongoDB'de etkili biçimde yapılandırmayı öğrenin. Node.js Backend Development Bootcamp ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Node.js Backend Development Bootcamp öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Node.js Backend Development Bootcamp, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Veri Modellemede Mongoose ODM” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Node.js Backend Development Bootcamp dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Node.js Backend Development Bootcamp dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

Node.js'i MongoDB'ye Bağlama
Veri Modellemede Mongoose ODM
Mongoose ile CRUD İşlemleri
Mongoose ile Veri Sorgulama ve Filtreleme

← Node.js Backend Development Bootcamp Sayfasına Dön