Kurs Next.js · Moduł 4: Bazy danych i pobieranie danych
Przegląd opcji baz danych dla Next.js (SQL, NoSQL)
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ą:
PostgreSQL
- Darmowa, open-source
- Zaawansowane funkcje (np. typy JSON, full-text search)
- Świetna wydajność i skalowalność
- Doskonała integralność danych
MySQL/MariaDB
- Szeroko stosowana, darmowa baza danych
- Dobra wydajność dla operacji odczytu
- Mniejsze wymagania zasobów niż PostgreSQL
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:
Dokumentowe (MongoDB, Firebase Firestore)
- Przechowują dane jako dokumenty (obiekty JSON/BSON)
- Elastyczna struktura bez sztywnego schematu
- Świetne do szybkiego prototypowania i danych nieustrukturyzowanych
Key-Value (Redis, DynamoDB)
- Przechowują proste pary klucz-wartość
- Ekstremalnie szybkie operacje odczytu/zapisu
- Często używane jako cache
Wide-Column (Cassandra, HBase)
- Przechowują dane w kolumnach zamiast wierszach
- Wysoka skalowalność i wydajność dla ogromnych zbiorów danych
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:
- Aplikacje z jasno zdefiniowanymi relacjami: PostgreSQL + Prisma
- Szybkie prototypowanie i elastyczne struktury danych: MongoDB lub Firestore
- Aplikacje serverless: PlanetScale, Neon, lub Supabase
- 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?