Wprowadzenie
Architektura REST (Representational State Transfer) jest powszechnie stosowanym podejściem do projektowania aplikacji internetowych. Pozwala na tworzenie skalowalnych, elastycznych i przyjaznych programistom systemów. Dzięki REST, aplikacje internetowe mogą efektywnie komunikować się z różnorodnymi urządzeniami i platformami.
Prisma to narzędzie ORM (Object-Relational Mapping), które upraszcza interakcję z bazami danych PostgreSQL. Oferuje ono intuicyjny interfejs do wykonywania zapytań, modyfikacji danych i zarządzania strukturą bazy. Używając Prismy, można szybko konstruować aplikacje internetowe z dostępem do danych.
W niniejszym artykule przedstawiamy szczegółową instrukcję, jak stworzyć REST API, korzystając z Prismy i PostgreSQL. Przejdziemy przez wszystkie etapy, od konfiguracji środowiska po wdrożenie gotowego API.
Konfiguracja środowiska
Aby rozpocząć pracę, upewnij się, że masz zainstalowane następujące komponenty:
- Node.js (wersja 16 lub nowsza)
- Prisma (wersja 4 lub nowsza)
- PostgreSQL (wersja 13 lub nowsza)
Po zainstalowaniu tych narzędzi, możesz przystąpić do konfiguracji środowiska, tworząc nowy projekt Node.js.
Projektowanie modelu danych
Model danych definiuje strukturę informacji przechowywanych w bazie. W naszym przykładzie stworzymy prosty model dla tabeli użytkowników:
model User {
id Int @id @default(autoincrement())
username String @unique
email String @unique
password String
}
Powyższy model definiuje tabelę User z kolumnami: id (identyfikator), username, email i password. id jest kluczem podstawowym, a username i email są kluczami unikalnymi.
Migracja bazy danych
Po zdefiniowaniu struktury danych, należy uruchomić migrację, aby utworzyć tabelę użytkowników w bazie danych PostgreSQL:
npx prisma migrate dev
Tworzenie kontrolerów
Kontrolery odpowiadają za obsługę przychodzących żądań HTTP i generowanie odpowiedzi. W tym przykładzie utworzymy kontroler dla użytkowników:
// user.controller.js
const { PrismaClient } = require('@prisma/client');
const prisma = new PrismaClient();
const createUser = async (req, res) => {
const user = await prisma.user.create({
data: req.body,
});
res.status(201).json(user);
};
const getAllUsers = async (req, res) => {
const users = await prisma.user.findMany();
res.status(200).json(users);
};
const getUserById = async (req, res) => {
const user = await prisma.user.findUnique({
where: {
id: parseInt(req.params.id),
},
});
if (!user) {
return res.status(404).json({ error: 'User not found' });
}
res.status(200).json(user);
};
const updateUser = async (req, res) => {
const user = await prisma.user.update({
where: {
id: parseInt(req.params.id),
},
data: req.body,
});
if (!user) {
return res.status(404).json({ error: 'User not found' });
}
res.status(200).json(user);
};
const deleteUser = async (req, res) => {
const user = await prisma.user.delete({
where: {
id: parseInt(req.params.id),
},
});
if (!user) {
return res.status(404).json({ error: 'User not found' });
}
res.status(204).end();
};
module.exports = {
createUser,
getAllUsers,
getUserById,
updateUser,
deleteUser,
};
Powyższy kontroler definiuje pięć funkcji:
- createUser: Służy do tworzenia nowego użytkownika.
- getAllUsers: Pobiera listę wszystkich użytkowników.
- getUserById: Pobiera dane użytkownika na podstawie identyfikatora.
- updateUser: Aktualizuje dane użytkownika o podanym identyfikatorze.
- deleteUser: Usuwa użytkownika na podstawie identyfikatora.
Tworzenie tras
Trasy definiują, jak adresy URL są powiązane z odpowiednimi kontrolerami. W naszym przykładzie przypiszemy trasę do każdej z metod kontrolera:
// routes.js
const express = require('express');
const router = express.Router();
const userController = require('./user.controller');
/* GET routes */
router.get('/users', userController.getAllUsers);
router.get('/users/:id', userController.getUserById);
/* POST routes */
router.post('/users', userController.createUser);
/* PUT routes */
router.put('/users/:id', userController.updateUser);
/* DELETE routes */
router.delete('/users/:id', userController.deleteUser);
module.exports = router;
Powyższe trasy odpowiadają następującym adresom URL:
- GET /users: Zwraca listę wszystkich użytkowników.
- GET /users/:id: Zwraca dane użytkownika o podanym identyfikatorze.
- POST /users: Tworzy nowego użytkownika.
- PUT /users/:id: Aktualizuje dane użytkownika o podanym identyfikatorze.
- DELETE /users/:id: Usuwa użytkownika o podanym identyfikatorze.
Uruchomienie serwera
Po skonfigurowaniu kontrolerów i tras, uruchom serwer Node.js za pomocą polecenia:
node index.js
Serwer zostanie uruchomiony na domyślnym porcie 3000.
Wdrożenie API
Po uruchomieniu serwera, można wdrożyć API na serwerze produkcyjnym. Istnieje wiele sposobów na wdrożenie aplikacji Node.js, np. Heroku, AWS Elastic Beanstalk czy Docker.
Podsumowanie
Prisma i PostgreSQL umożliwiają szybkie i łatwe tworzenie REST API. Prisma dostarcza prosty interfejs do pracy z bazą danych, co pozwala programistom skupić się na logice aplikacji. W tym artykule opisaliśmy, jak skonfigurować środowisko, stworzyć model danych, przeprowadzić migrację bazy, tworzyć kontrolery i trasy, a także uruchomić serwer. Mamy nadzieję, że te informacje pomogą Ci w tworzeniu własnych REST API.
Najczęściej zadawane pytania
1. Czym jest RESTful API?
RESTful API to styl architektury aplikacji internetowych, który definiuje zestaw reguł dla tworzenia aplikacji, które są łatwe w użyciu, skalowalne i elastyczne.
2. Czym jest Prisma?
Prisma jest frameworkiem ORM, który upraszcza interakcję z bazami danych. Oferuje interfejs do tworzenia zapytań, modyfikowania danych i zarządzania schematem bazy.
3. Jak skonfigurować środowisko dla Prismy i PostgreSQL?
Aby skonfigurować środowisko, należy zainstalować Node.js, Prismę i PostgreSQL. Można to zrobić, używając następujących poleceń:
npm install -g nodejs
npm install -g prisma
brew install postgresql@13
4. Jak stworzyć model danych w Prismie?
W celu utworzenia modelu danych w Prismie, stwórz plik schema.prisma w głównym katalogu projektu i zdefiniuj w nim model. Przykładowo:
model User {
id Int @id @default(autoincrement())
username String @unique
email String @unique
password String
}
5. Jak migrować bazę danych za pomocą Prismy?
Aby dokonać migracji bazy danych, należy uruchomić następujące polecenie:
npx prisma migrate dev
6. Jak tworzyć kontrolery w REST API?
Kontrolery w REST API odpowiadają za przetwarzanie żądań HTTP i generowanie odpowiedzi. Kontrolery zazwyczaj zawierają funkcje do tworzenia (Create), odczytywania (Read), aktualizowania (Update) i usuwania (Delete) danych (CRUD).
7. Jak definiować trasy w REST API?
Trasy określają, jak adresy URL są powiązane z