Praca z Bazą Danych w Express.js

Witaj na blogu poświęconym programowaniu z użyciem Node.js! Dziś zajmiemy się jednym z kluczowych aspektów tworzenia aplikacji backendowych — integracją Express.js z bazą danych MongoDB przy pomocy biblioteki Mongoose. Dowiesz się, jak stworzyć pełnoprawną aplikację CRUD do zarządzania prostą listą zadań.

MongoDB i Mongoose

Wprowadzenie do MongoDB

MongoDB jest nierelacyjną bazą danych NoSQL, która przechowuje dane w formacie dokumentów JSON. Jest świetnym wyborem dla aplikacji, które wymagają elastycznego zarządzania danymi, ponieważ struktura dokumentów w MongoDB pozwala na przechowywanie różnych typów danych i łatwe skalowanie.

W odróżnieniu od relacyjnych baz danych (jak MySQL), MongoDB nie używa tabel ani schematów. Zamiast tego przechowuje dane w kolekcjach, a dokumenty w tych kolekcjach mogą mieć różne pola, co pozwala na dużą elastyczność.

Instalacja MongoDB

Aby rozpocząć pracę, musisz zainstalować MongoDB na swoim lokalnym komputerze lub skorzystać z chmurowego rozwiązania MongoDB Atlas. Jeśli chcesz zainstalować MongoDB lokalnie:

  1. Przejdź na stronę MongoDB i pobierz wersję Community.
  2. Postępuj zgodnie z instrukcjami instalacyjnymi.
  3. Aby ułatwić przeglądanie danych w bazie, warto także pobrać narzędzie MongoDB Compass, które jest graficznym interfejsem do MongoDB.

Wprowadzenie do Mongoose

Mongoose jest Object Data Modeling (ODM) biblioteką dla MongoDB i Node.js. Pozwala na definiowanie schematów dla danych i jest swoistą warstwą pośrednią pomiędzy aplikacją, a bazą danych. Dzięki Mongoose, operacje takie jak tworzenie, odczyt, aktualizacja i usuwanie (CRUD) stają się bardziej intuicyjne i bezpieczne.

Aby dodać Mongoose do swojego projektu Express.js, wystarczy zainstalować tę bibliotekę komendą:

				
					npm install mongoose

Modelowanie Danych z Mongoose

Tworzenie Modeli Danych

Zacznijmy od stworzenia prostego modelu dla aplikacji zarządzającej listą zadań (ang. To-Do List). Będziemy przechowywać informacje o zadaniach, takie jak tytuł zadania oraz jego status (czy jest wykonane).

Poniżej przedstawiamy, jak utworzyć model zadania:

				
					// models/Task.js
const mongoose = require('mongoose');

const taskSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true,
  },
  completed: {
    type: Boolean,
    default: false,
  },
});

module.exports = mongoose.model('Task', taskSchema);
  • title – pole przechowujące tytuł zadania (wymagane).
  • completed – pole, które oznacza, czy zadanie zostało wykonane (domyślnie ustawione na false).

Połączenie z Bazą Danych

Przed użyciem modeli, musimy połączyć się z bazą danych. Zrobimy to w pliku głównym naszej aplikacji:

				
					// index.js
const express = require('express');
const mongoose = require('mongoose');
const app = express();

mongoose.connect('mongodb://localhost:27017/todoapp', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
}).then(() => {
  console.log('Połączono z MongoDB');
}).catch((error) => {
  console.error('Błąd połączenia z MongoDB:', error);
});

app.use(express.json());

// Dodanie ścieżek API (opisane później)

W powyższym kodzie używamy mongoose.connect() do połączenia z lokalnym serwerem MongoDB. Pamiętaj, aby uruchomić serwer MongoDB przed uruchomieniem aplikacji.

Operacje CRUD z Mongoose

Szerzej opisałem to we wpisie Podstawowe operacje CRUD przy użyciu Mongoose.

1. Create (Tworzenie)

Dodajmy możliwość tworzenia nowych zadań:

				
					// routes/tasks.js
const express = require('express');
const router = express.Router();
const Task = require('../models/Task');

// Tworzenie nowego zadania
router.post('/', async (req, res) => {
  const { title } = req.body;

  try {
    const task = new Task({ title });
    await task.save();
    res.status(201).json(task);
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
});

module.exports = router;

2. Read (Odczyt)

Pobierzmy wszystkie zadania:

				
					// Pobieranie wszystkich zadań
router.get('/', async (req, res) => {
  try {
    const tasks = await Task.find();
    res.json(tasks);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

3. Update (Aktualizacja)

Pozwólmy na aktualizację zadania — np. oznaczanie go jako ukończonego:

				
					// Aktualizacja zadania
router.put('/:id', async (req, res) => {
  try {
    const task = await Task.findById(req.params.id);
    if (!task) {
      return res.status(404).json({ message: 'Zadanie nie znalezione' });
    }

    task.completed = req.body.completed ?? task.completed;
    task.title = req.body.title ?? task.title;

    await task.save();
    res.json(task);
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
});

4. Delete (Usuwanie)

Dodajmy endpoint do usuwania zadania:

				
					// Usuwanie zadania
router.delete('/:id', async (req, res) => {
  try {
    const task = await Task.findById(req.params.id);
    if (!task) {
      return res.status(404).json({ message: 'Zadanie nie znalezione' });
    }

    await task.remove();
    res.json({ message: 'Zadanie zostało usunięte' });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

Przykładowa Aplikacja CRUD

Teraz, kiedy mamy wszystkie operacje CRUD zaimplementowane, możemy zintegrować je z główną aplikacją Express:

				
					// index.js (ciąg dalszy)
const taskRoutes = require('./routes/tasks');

app.use('/api/tasks', taskRoutes);

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Serwer działa na porcie ${PORT}`);
});

Dzięki temu nasza aplikacja będzie miała następujące endpointy:

  • POST /api/tasks – tworzy nowe zadanie,
  • GET /api/tasks – pobiera wszystkie zadania,
  • PUT /api/tasks – aktualizuje zadanie o podanym ID,
  • DELETE /api/tasks – usuwa zadanie o podanym ID.

Podsumowanie

Dziś nauczyliśmy się, jak zintegrować MongoDB z aplikacją Express.js przy użyciu Mongoose. Omówiliśmy instalację MongoDB, stworzenie modeli danych, oraz implementację pełnej aplikacji CRUD do zarządzania zadaniami.

MongoDB i Mongoose to potężne narzędzia, które upraszczają pracę z danymi, zwłaszcza w aplikacjach Node.js. Mam nadzieję, że dzięki temu wpisowi zyskałeś(aś) lepsze zrozumienie, jak tworzyć aplikacje backendowe z pełną funkcjonalnością CRUD.

Kategorie