Wprowadzenie do Mongoose – Modelowanie Danych w MongoDB

By /

JavaScript Node.js

W tej lekcji dowiesz się, czym jest Mongoose i jak ułatwia pracę z MongoDB w aplikacjach Node.js. Mongoose jest biblioteką ODM (Object Data Modeling), która umożliwia tworzenie schematów danych oraz modelowanie struktur dokumentów w MongoDB. Pozwala także na walidację danych i zapewnia bogaty zestaw narzędzi do interakcji z bazą danych.

Dlaczego Mongoose?

MongoDB jest bazą danych NoSQL, która pozwala przechowywać dane w formie dokumentów JSON/BSON. Chociaż ten sposób przechowywania jest bardzo elastyczny, to w większych aplikacjach warto zorganizować dane według pewnych reguł i zasad. Właśnie tu wkracza Mongoose, umożliwiając:

  • Definiowanie schematów danych (struktur) dla dokumentów.
  • Dodawanie walidacji danych.
  • Korzystanie z wbudowanych metod CRUD w bardziej zorganizowany sposób.

 Pierwsze Kroki z Mongoose

Stwórz nowy plik o nazwie mongoose_example.js i skopiuj do niego poniższy kod. Kod ten pokazuje, jak podłączyć się do MongoDB za pomocą Mongoose, zdefiniować schemat danych, utworzyć model oraz wykonać kilka podstawowych operacji na danych.

Instalacja Mongoose

Zanim rozpoczniemy pracę, upewnij się, że zainstalowałeś Mongoose w swoim projekcie:

npm install mongoose

Implementacja

Poniżej znajduje się przykład, jak rozpocząć pracę z Mongoose:

// Importujemy Mongoose do naszego projektu
const mongoose = require('mongoose');

// Ustawiamy URL połączenia z lokalną bazą danych MongoDB
const url = 'mongodb://localhost:27017/myMongooseDatabase';

// Funkcja główna, w której będziemy wykonywać wszystkie operacje
async function main() {
  try {
    // Nawiązujemy połączenie z MongoDB za pomocą Mongoose
    await mongoose.connect(url, {
      useNewUrlParser: true, // Używamy nowego parsera URL
      useUnifiedTopology: true, // Używamy nowego silnika zarządzania połączeniami
    });
    console.log('Połączono z MongoDB za pomocą Mongoose!');

    // --- Definiowanie schematu i modelu ---

    // Definiujemy schemat dla kolekcji "users"
    const userSchema = new mongoose.Schema({
      name: {
        type: String, // Pole typu String
        required: true, // Pole jest wymagane
        trim: true, // Usuwa białe znaki na początku i końcu
      },
      age: {
        type: Number, // Pole typu Number
        min: 0, // Minimalna wartość pola to 0
      },
      email: {
        type: String, // Pole typu String
        required: true, // Pole jest wymagane
        unique: true, // Pole musi być unikalne w całej kolekcji
        match: /.+\@.+\..+/ // Walidacja - pole musi być poprawnym adresem e-mail
      },
      createdAt: {
        type: Date, // Pole typu Date
        default: Date.now, // Ustawia aktualną datę jako domyślną wartość
      },
    });

    // Tworzymy model "User" na podstawie zdefiniowanego schematu
    const User = mongoose.model('User', userSchema);

    // --- CREATE: Dodawanie nowego dokumentu ---

    // Tworzymy instancję nowego użytkownika
    const newUser = new User({
      name: 'Jan Kowalski',
      age: 28,
      email: 'jan.kowalski@example.com',
    });

    // Zapisujemy nowy dokument do bazy danych
    await newUser.save();
    console.log('Nowy użytkownik zapisany:', newUser);

    // --- READ: Pobieranie dokumentów ---

    // Znajdujemy wszystkich użytkowników w bazie danych
    const users = await User.find();
    console.log('Wszyscy użytkownicy:', users);

    // Znajdujemy jednego użytkownika na podstawie e-maila
    const user = await User.findOne({ email: 'jan.kowalski@example.com' });
    console.log('Znaleziony użytkownik:', user);

    // --- UPDATE: Aktualizowanie dokumentów ---

    // Aktualizujemy wiek użytkownika o podanym adresie e-mail
    const updatedUser = await User.findOneAndUpdate(
      { email: 'jan.kowalski@example.com' }, // Warunek wyszukiwania
      { age: 29 }, // Nowa wartość pola
      { new: true, runValidators: true } // Opcje: "new" zwraca zaktualizowany dokument, "runValidators" uruchamia walidację
    );
    console.log('Zaktualizowany użytkownik:', updatedUser);

    // --- DELETE: Usuwanie dokumentów ---

    // Usuwamy użytkownika na podstawie adresu e-mail
    const deleteResult = await User.deleteOne({ email: 'jan.kowalski@example.com' });
    console.log('Liczba usuniętych dokumentów:', deleteResult.deletedCount);

  } catch (error) {
    console.error('Błąd podczas operacji na bazie danych:', error); // Obsługa błędów, wyświetla komunikat błędu
  } finally {
    // Zawsze zamykamy połączenie z bazą danych, nawet w przypadku błędu
    await mongoose.connection.close();
    console.log('Połączenie z MongoDB zamknięte.');
  }
}

// Wywołujemy główną funkcję
main().catch(console.error); // Obsługa błędów podczas uruchamiania funkcji głównej

Wyjaśnienie Kodu:

  1. Połączenie z MongoDB:
    • mongoose.connect(url, {...}): Używamy Mongoose do połączenia z bazą danych MongoDB, podając adres URL bazy i dodatkowe opcje konfiguracyjne (useNewUrlParser i useUnifiedTopology).
  2. Definiowanie Schematów:
    • mongoose.Schema: Tworzymy nowy schemat dla kolekcji “users”, określając strukturę dokumentów, typy danych, walidacje (np. required, unique) oraz domyślne wartości (default).
  3. Tworzenie Modelu:
    • mongoose.model('User', userSchema): Tworzymy model “User” na podstawie zdefiniowanego schematu userSchema. Model pozwala na wykonywanie operacji na kolekcji “users”.
  4. Operacje CRUD:
    • CREATE:
      • const newUser = new User({...}): Tworzymy instancję nowego użytkownika na podstawie modelu User.
      • newUser.save(): Zapisujemy nowy dokument w kolekcji.
    • READ:
      • User.find(): Pobiera wszystkie dokumenty z kolekcji.
      • User.findOne({ email: '...' }): Znajduje jeden dokument na podstawie podanego kryterium.
    • UPDATE:
      • User.findOneAndUpdate({ ... }, { ... }, { ... }): Aktualizuje wybrany dokument. Opcje { new: true, runValidators: true } oznaczają, że zwracany będzie zaktualizowany dokument, a walidacje schematu zostaną przeprowadzone.
    • DELETE:
      • User.deleteOne({ ... }): Usuwa dokument spełniający podane kryterium.
  5. Zamykanie Połączenia:
    • mongoose.connection.close(): Zawsze zamykamy połączenie z bazą danych po zakończeniu operacji.

Podsumowanie

W tej lekcji nauczyłeś się, jak korzystać z Mongoose do modelowania danych w MongoDB:

  1. Jak połączyć się z MongoDB przy użyciu Mongoose.
  2. Jak zdefiniować schemat (Schema) oraz model (Model) dla kolekcji.
  3. Jak dodawać, pobierać, aktualizować i usuwać dokumenty za pomocą Mongoose.
  4. Jak używać walidacji, aby zapewnić przechowywanie poprawnych danych.

Mongoose upraszcza pracę z MongoDB, dodając warstwę abstrakcji do zarządzania danymi, dzięki czemu tworzenie bardziej zaawansowanych aplikacji staje się prostsze i bezpieczniejsze. W kolejnej lekcji zagłębimy się w zaawansowane opcje schematów i metody w modelach, aby jeszcze bardziej zoptymalizować interakcje z bazą danych.

Jeżeli chcesz przyśpieszyć swoją naukę tworzenia stron chciałbym polecić mój kurs video JavaScript w którym nauczysz się tego języka od podstaw do zaawansowanych jego aspektów.

Powiązane artykuły

Scroll to Top