Kurs Next.js · Moduł 4: Bazy danych i pobieranie danych

Przegląd opcji baz danych dla Next.js (SQL, NoSQL)

7 min czytania ·
W tej lekcji5

Wybór odpowiedniej bazy danych jest jedną z kluczowych decyzji przy tworzeniu aplikacji w Next.js. W tym module poznamy najpopularniejsze opcje baz danych oraz ich zalety i wady w kontekście aplikacji Next.js.

Rodzaje baz danych

Bazy danych możemy podzielić na dwie główne kategorie: SQL (relacyjne) i NoSQL (nierelacyjne). Każda z nich ma swoje charakterystyczne cechy, które wpływają na to, do jakich projektów najlepiej się nadają.

Bazy danych SQL (relacyjne)

Bazy relacyjne organizują dane w tabelach z predefiniowaną strukturą i relacjami między nimi. Przykładami popularnych baz SQL są:

  1. PostgreSQL

    • Darmowa, open-source
    • Zaawansowane funkcje (np. typy JSON, full-text search)
    • Świetna wydajność i skalowalność
    • Doskonała integralność danych
  2. MySQL/MariaDB

    • Szeroko stosowana, darmowa baza danych
    • Dobra wydajność dla operacji odczytu
    • Mniejsze wymagania zasobów niż PostgreSQL
  3. SQLite

    • Lekka baza danych (plik) bez osobnego serwera
    • Idealna do prototypowania i testów
    • Nie nadaje się do produkcyjnych aplikacji z dużym ruchem

Bazy danych NoSQL (nierelacyjne)

Bazy NoSQL oferują większą elastyczność struktury danych i zazwyczaj lepszą skalowalność poziomą. Główne typy to:

  1. Dokumentowe (MongoDB, Firebase Firestore)

    • Przechowują dane jako dokumenty (obiekty JSON/BSON)
    • Elastyczna struktura bez sztywnego schematu
    • Świetne do szybkiego prototypowania i danych nieustrukturyzowanych
  2. Key-Value (Redis, DynamoDB)

    • Przechowują proste pary klucz-wartość
    • Ekstremalnie szybkie operacje odczytu/zapisu
    • Często używane jako cache
  3. Wide-Column (Cassandra, HBase)

    • Przechowują dane w kolumnach zamiast wierszach
    • Wysoka skalowalność i wydajność dla ogromnych zbiorów danych
  4. Grafowe (Neo4j, Amazon Neptune)

    • Specjalizują się w relacjach między danymi
    • Idealne do złożonych relacji i analizy połączeń

Popularne opcje baz danych dla Next.js

1. PostgreSQL + Prisma

PostgreSQL w połączeniu z ORM Prisma to jedna z najpopularniejszych opcji dla aplikacji Next.js:

// Przykład modelu Prisma dla PostgreSQL
model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  posts     Post[]
  profile   Profile?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  content   String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  Int
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Profile {
  id     Int    @id @default(autoincrement())
  bio    String
  user   User   @relation(fields: [userId], references: [id])
  userId Int    @unique
}

Zalety:

  • Silna integralność danych dzięki relacjom
  • Wysoka wydajność i niezawodność
  • Dobra skalowalność
  • Świetne wsparcie TypeScript dzięki Prisma

Wady:

  • Wymaga serwera bazy danych
  • Sztywna struktura danych (schema)

2. MongoDB + Mongoose

MongoDB to popularna nierelacyjna baza dokumentowa, często używana z Next.js:

// Przykładowy model Mongoose dla MongoDB
import mongoose from 'mongoose';

const UserSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, 'Proszę podać imię'],
    maxlength: [50, 'Imię nie może być dłuższe niż 50 znaków']
  },
  email: {
    type: String,
    required: [true, 'Proszę podać email'],
    unique: true,
    match: [
      /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/,
      'Proszę podać poprawny adres email'
    ]
  },
  posts: [
    {
      type: mongoose.Schema.Types.ObjectId,
      ref: 'Post'
    }
  ],
  createdAt: {
    type: Date,
    default: Date.now
  }
});

export default mongoose.models.User || mongoose.model('User', UserSchema);

Zalety:

  • Elastyczna struktura danych
  • Łatwa skalowalność pozioma
  • Format danych podobny do JSON
  • Dobre wsparcie dla TypeScript

Wady:

  • Słabsza integralność danych niż w bazach SQL
  • Trudniejsze złożone zapytania

3. Serverless Databases (PlanetScale, Neon, Supabase)

Serverless databases to nowy trend idealnie pasujący do architektury Next.js:

// Przykład użycia PlanetScale z Next.js
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

// W API route lub Server Component
export async function getUsers() {
  try {
    const users = await prisma.user.findMany({
      include: { posts: true }
    });
    return users;
  } catch (error) {
    console.error('Database error:', error);
    throw new Error('Nie udało się pobrać użytkowników');
  }
}

Popularne opcje:

  • PlanetScale - MySQL-kompatybilna baza danych serverless
  • Neon - PostgreSQL w modelu serverless
  • Supabase - platforma backend-as-a-service z PostgreSQL
  • Firebase - kompleksowe rozwiązanie z Firestore jako bazą dokumentową

Zalety:

  • Brak konieczności zarządzania infrastrukturą
  • Pay-per-use (płacisz tylko za to, co wykorzystasz)
  • Automatyczne skalowanie
  • Często darmowy plan dla małych projektów

Wady:

  • Potencjalnie wyższe koszty przy dużej skali
  • Mniejsza kontrola nad infrastrukturą
  • Zależność od zewnętrznego dostawcy

4. Edge Databases (Cloudflare D1, Fauna)

Nowością w ekosystemie Next.js są bazy danych działające na edge:

// Przykład użycia Cloudflare D1 z Next.js
// W API Route (Pages Router) lub Route Handler (App Router)
import { D1Database } from '@cloudflare/workers-types';

export const runtime = 'edge';

export async function GET() {
  const db = process.env.DB as unknown as D1Database;

  const { results } = await db
    .prepare('SELECT * FROM users WHERE status = ?')
    .bind('active')
    .all();

  return Response.json({ users: results });
}

Zalety:

  • Minimalne opóźnienia dla użytkowników globalnych
  • Integracja z funkcjami edge
  • Często niższe koszty

Wady:

  • Ograniczone możliwości w porównaniu z tradycyjnymi bazami danych
  • Relatywnie nowa technologia

Wybór bazy danych dla Next.js - czynniki do rozważenia

1. Struktura danych

  • Jeśli masz jasno zdefiniowaną strukturę danych z relacjami → PostgreSQL lub MySQL
  • Jeśli struktura danych jest płynna i może się zmieniać → MongoDB lub Firestore

2. Skalowalność

  • Dla aplikacji, które muszą obsłużyć miliony użytkowników → Serverless options (PlanetScale, Neon)
  • Dla aplikacji o przewidywalnym ruchu → Tradycyjne rozwiązania jak PostgreSQL

3. Zespół i doświadczenie

  • Jeśli zespół ma doświadczenie z SQL → PostgreSQL/MySQL
  • Jeśli zespół preferuje podejście JavaScript-first → MongoDB

4. Hosting i deployment

  • Jeśli używasz Vercel do hostingu Next.js → Dobrze integruje się z PlanetScale, Neon, Supabase
  • Jeśli używasz Cloudflare Pages → Cloudflare D1 lub Cloudflare KV

Przykłady integracji w Next.js

Przykład 1: PostgreSQL + Prisma w Next.js

// lib/prisma.ts
import { PrismaClient } from '@prisma/client';

let prisma: PrismaClient;

if (process.env.NODE_ENV === 'production') {
  prisma = new PrismaClient();
} else {
  // Zapobieganie wielu instancjom w trybie dev
  if (!global.prisma) {
    global.prisma = new PrismaClient();
  }
  prisma = global.prisma;
}

export default prisma;

// W Server Component (App Router)
// app/users/page.tsx
import prisma from '@/lib/prisma';

export default async function UsersPage() {
  const users = await prisma.user.findMany({
    include: {
      posts: true,
    },
  });

  return (
    <div>
      <h1>Użytkownicy</h1>
      <ul>
        {users.map((user) => (
          <li key={user.id}>
            {user.name} - {user.posts.length} postów
          </li>
        ))}
      </ul>
    </div>
  );
}

Przykład 2: MongoDB w Next.js (Pages Router)

// lib/mongodb.js
import { MongoClient } from 'mongodb';

const MONGODB_URI = process.env.MONGODB_URI;
const MONGODB_DB = process.env.MONGODB_DB;

if (!MONGODB_URI) {
  throw new Error('Zdefiniuj MONGODB_URI w pliku .env.local');
}

if (!MONGODB_DB) {
  throw new Error('Zdefiniuj MONGODB_DB w pliku .env.local');
}

let cachedClient = null;
let cachedDb = null;

export async function connectToDatabase() {
  if (cachedClient && cachedDb) {
    return { client: cachedClient, db: cachedDb };
  }

  const client = await MongoClient.connect(MONGODB_URI, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  });

  const db = await client.db(MONGODB_DB);

  cachedClient = client;
  cachedDb = db;

  return { client, db };
}

// W API Route
// pages/api/users.js
import { connectToDatabase } from '@/lib/mongodb';

export default async function handler(req, res) {
  const { db } = await connectToDatabase();

  const users = await db
    .collection('users')
    .find({})
    .limit(20)
    .toArray();

  res.status(200).json(users);
}

Podsumowanie

Przy wyborze bazy danych dla Next.js warto kierować się następującymi zasadami:

  1. Aplikacje z jasno zdefiniowanymi relacjami: PostgreSQL + Prisma
  2. Szybkie prototypowanie i elastyczne struktury danych: MongoDB lub Firestore
  3. Aplikacje serverless: PlanetScale, Neon, lub Supabase
  4. Aplikacje globalne z niskim opóźnieniem: Edge Databases jak Cloudflare D1 lub FaunaDB

Niezależnie od wyboru, Next.js oferuje świetne mechanizmy integracji z wszystkimi popularnymi bazami danych. W kolejnym module dowiemy się, jak skonfigurować ORM dla wybranego rozwiązania, aby jeszcze bardziej usprawnić pracę z bazą danych.

Kod do tej lekcji: app/page.tsx
// Database Integration Demo - app/page.tsx
'use client';

import { useState, useEffect } from 'react';
import { CitizenManager } from './components/CitizenManager';
import { EnergyMonitor } from './components/EnergyMonitor';
import { DatabaseStatsPanel } from './components/DatabaseStatsPanel';
import { QueryBuilder } from './components/QueryBuilder';

interface DatabaseStats {
  totalCitizens: number;
  activeConnections: number;
  energyRecords: number;
  avgResponseTime: number;
  lastBackup: string;
}

export default function DatabaseHomePage() {
  const [activeTab, setActiveTab] = useState('overview');
  const [isConnected, setIsConnected] = useState(false);
  const [connectionStatus, setConnectionStatus] = useState('connecting');
  const [stats, setStats] = useState<DatabaseStats>({
    totalCitizens: 2847392,
    activeConnections: 47,
    energyRecords: 9542816,
    avgResponseTime: 23.7,
    lastBackup: '2024-01-15 03:00:00'
  });

  useEffect(() => {
    console.log("Initializing database connection...");

    // Symuluj połączenie z bazą danych
    const connectToDatabase = async () => {
      setConnectionStatus('connecting');

      // Symuluj opóźnienie połączenia
      await new Promise(resolve => setTimeout(resolve, 2000));

      setIsConnected(true);
      setConnectionStatus('connected');
      console.log("Database connection established");

      // Symuluj aktualizacje statystyk
      const interval = setInterval(() => {
        setStats(prev => ({
          ...prev,
          activeConnections: prev.activeConnections + Math.floor(Math.random() * 3) - 1,
          avgResponseTime: Math.max(10, prev.avgResponseTime + (Math.random() - 0.5) * 5)
        }));
      }, 3000);

      return () => clearInterval(interval);
    };

    connectToDatabase();
  }, []);

  const getConnectionColor = () => {
    switch (connectionStatus) {
      case 'connected': return '#4caf50';
      case 'connecting': return '#ff9800';
      case 'error': return '#f44336';
      default: return '#757575';
    }
  };

  const getConnectionIcon = () => {
    switch (connectionStatus) {
      case 'connected': return 'OK';
      case 'connecting': return '↻';
      case 'error': return '×';
      default: return '⏳';
    }
  };

  return (
    <div className="database-home">
      <section className="hero-section">
        <h1>Quantum Database Control Center</h1>
        <p>
         Zarządzaj danymi Metropolis Quantum z wykorzystaniem nowoczesnych 
          technologii bazodanowych i ORM w Next.js 16
        </p>

        <div className="connection-status">
          <div
            className="status-indicator"
            style={{ backgroundColor: getConnectionColor() }}
          >
            <span className="status-icon">{getConnectionIcon()}</span>
            <span className="status-text">
              Database: {connectionStatus.toUpperCase()}
            </span>
          </div>

          {isConnected && (
            <div className="connection-details">
              <span>Quantum-DB v3.2.1</span>
              <span>Cluster: metropolis-primary</span>
              <span>Response: {stats.avgResponseTime.toFixed(1)}ms</span>
            </div>
          )}
        </div>
      </section>

      <section className="database-overview">
        <h2>Database Overview</h2>

        <div className="overview-grid">
          <div className="overview-card">
            <div className="card-icon">◆</div>
            <div className="card-content">
              <div className="card-value">{stats.totalCitizens.toLocaleString()}</div>
              <div className="card-label">Total Citizens</div>
              <div className="card-change positive">+127 today</div>
            </div>
          </div>

          <div className="overview-card">
            <div className="card-icon">↯</div>
            <div className="card-content">
              <div className="card-value">{stats.energyRecords.toLocaleString()}</div>
              <div className="card-label">Energy Records</div>
              <div className="card-change positive">+2.4k today</div>
            </div>
          </div>

          <div className="overview-card">
            <div className="card-icon">◆</div>
            <div className="card-content">
              <div className="card-value">{stats.activeConnections}</div>
              <div className="card-label">Active Connections</div>
              <div className="card-change neutral">Real-time</div>
            </div>
          </div>

          <div className="overview-card">
            <div className="card-icon">⏱</div>
            <div className="card-content">
              <div className="card-value">{stats.avgResponseTime.toFixed(1)}ms</div>
              <div className="card-label">Avg Response Time</div>
              <div className="card-change positive">-5.2ms</div>
            </div>
          </div>
        </div>
      </section>

      <section className="database-operations">
        <h2>Database Operations</h2>

        <div className="operations-tabs">
          {[
            { id: 'overview', label: 'Overview', icon: '' },
            { id: 'citizens', label: 'Citizens', icon: '' },
            { id: 'energy', label: 'Energy', icon: '' },
            { id: 'queries', label: 'Query Builder', icon: '' }
          ].map(tab => (
            <button
              key={tab.id}
              className={`tab-button ${activeTab === tab.id ? 'active' : ''}`}
              onClick={() => setActiveTab(tab.id)}
            >
              <span className="tab-icon">{tab.icon}</span>
              {tab.label}
            </button>
          ))}
        </div>

        <div className="tab-content">
          {activeTab === 'overview' && (
            <DatabaseStatsPanel stats={stats} isConnected={isConnected} />
          )}

          {activeTab === 'citizens' && (
            <CitizenManager isConnected={isConnected} />
          )}

          {activeTab === 'energy' && (
            <EnergyMonitor isConnected={isConnected} />
          )}

          {activeTab === 'queries' && (
            <QueryBuilder isConnected={isConnected} />
          )}
        </div>
      </section>

      <section className="database-info">
        <h2>Database Architecture</h2>

        <div className="architecture-grid">
          <div className="arch-card">
            <h3>Database Models</h3>
            <div className="code-block">
              <pre><code>{`// Prisma Schema Example
model Citizen {
  id        String   @id @default(cuid())
  name      String
  email     String   @unique
  district  District @relation(fields: [districtId], references: [id])
  districtId String
  energyUsage EnergyUsage[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model District {
  id       String    @id @default(cuid())
  name     String    @unique
  type     String
  citizens Citizen[]
  energyGrid EnergyGrid?
}`}</code></pre>
            </div>
          </div>

          <div className="arch-card">
            <h3>API Integration</h3>
            <div className="code-block">
              <pre><code>{`// Next.js API Route
export async function GET() {
  try {
    const citizens = await prisma.citizen.findMany({
      include: {
        district: true,
        energyUsage: {
          orderBy: { createdAt: 'desc' },
          take: 5
        }
      }
    });

    return Response.json(citizens);
  } catch (error) {
    return Response.json(
      { error: 'Database connection failed' },
      { status: 500 }
    );
  }
}`}</code></pre>
            </div>
          </div>

          <div className="arch-card">
            <h3>Real-time Updates</h3>
            <div className="code-block">
              <pre><code>{`// Server-Sent Events for real-time data
useEffect(() => {
  const eventSource = new EventSource('/api/events');

  eventSource.onmessage = (event) => {
    const data = JSON.parse(event.data);
    updateEnergyData(data);
  };

  return () => eventSource.close();
}, []);`}</code></pre>
            </div>
          </div>

          <div className="arch-card">
            <h3>Performance Optimization</h3>
            <div className="features-list">
              <div className="feature-item">
                <span className="feature-icon">▲</span>
                <span>Connection Pooling</span>
              </div>
              <div className="feature-item">
                <span className="feature-icon">◆</span>
                <span>Query Optimization</span>
              </div>
              <div className="feature-item">
                <span className="feature-icon">■</span>
                <span>Redis Caching</span>
              </div>
              <div className="feature-item">
                <span className="feature-icon">↻</span>
                <span>Background Jobs</span>
              </div>
            </div>
          </div>
        </div>
      </section>
    </div>
  );
}

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Przydatne artykuły