Bygg ditt REST API med Prisma & PostgreSQL: Steg-for-steg guide!

0 Shares

Konstruksjon av et REST API med Prisma og PostgreSQL

Et REST API fungerer som et grensesnitt som tillater klienter, for eksempel applikasjoner på mobil eller nettlesere, å aksessere data fra en server på en strukturert måte. Prosessen med å bygge et REST API involverer definering av et sett med veier som klienter kan nå, samt utvikling av logikken for å håndtere både forespørsler og svar.

Prisma er et ORM (Object-Relational Mapping) verktøy som forenkler modelleringen av datarelasjoner og utførelsen av databaseforespørsler. PostgreSQL, derimot, er en velkjent open source-database kjent for sin stabilitet, ytelse og brede funksjonalitet.

I denne veiledningen vil vi gå gjennom de nødvendige trinnene for å skape et REST API ved hjelp av Prisma og PostgreSQL.

Nødvendige forberedelser

Node.js må være installert
PostgreSQL må være installert
Prisma CLI må være installert
En grunnleggende forståelse av REST APIer, Node.js, Prisma og PostgreSQL kreves

Steg 1: Etablering av en database

Vi starter med å opprette en PostgreSQL-database. Dette kan gjøres med følgende kommando:

createdb -U postgres -h localhost min_database

Bytt ut «min_database» med det ønskede navnet på databasen.

Steg 2: Initiere et Prisma-prosjekt

Lag et nytt Prisma-prosjekt ved å utføre denne kommandoen:

prisma init min-rest-api

Erstatt «min-rest-api» med navnet du ønsker å gi Prisma-prosjektet ditt.

Steg 3: Definere datamodellen

I filen «schema.prisma» definerer vi datamodellen for vårt REST API. I dette eksemplet vil vi benytte oss av en enkel modell med to enheter: «Bruker» og «Innlegg».

model User {
  id        Int    @id @default(autoincrement())
  name      String
  email     String  @unique
  password  String
}

model Post {
  id         Int    @id @default(autoincrement())
  title      String
  content    String
  publishedAt DateTime
  authorId   Int
  author     User   @relation(fields: [authorId], references: [id])
}

Steg 4: Generere Prisma-klienten

Utfør følgende kommando for å generere Prisma-klienten:

prisma generate

Dette skaper en mappe kalt «node_modules/@prisma/client» som inneholder både TypeScript- og JavaScript-klienter for å samhandle med databasen vår.

Steg 5: Opprettelse av Node.js-serveren

Lag en ny Node.js-fil (for eksempel «server.js») og importer Prisma-klienten:

    const { PrismaClient } = require("@prisma/client");
    const prisma = new PrismaClient();

Steg 6: Implementere CRUD-operasjoner

Vi skal nå implementere de grunnleggende CRUD-operasjonene (Create, Read, Update, Delete) som kreves i et REST API.

Opprett (Create)

app.post("/api/users", async (req, res) => {
    const newUser = await prisma.user.create({
      data: {
        name: req.body.name,
        email: req.body.email,
        password: req.body.password
      }
    });
    res.json(newUser);
  });

Les (Read)

app.get("/api/users", async (req, res) => {
    const users = await prisma.user.findMany();
    res.json(users);
  });

app.get("/api/users/:id", async (req, res) => {
    const user = await prisma.user.findUnique({
      where: {
        id: parseInt(req.params.id)
      }
    });
    res.json(user);
  });

Oppdater (Update)

app.put("/api/users/:id", async (req, res) => {
    const updatedUser = await prisma.user.update({
      where: {
        id: parseInt(req.params.id)
      },
      data: {
        name: req.body.name,
        email: req.body.email,
        password: req.body.password
      }
    });
    res.json(updatedUser);
  });

Slett (Delete)

app.delete("/api/users/:id", async (req, res) => {
    const deletedUser = await prisma.user.delete({
      where: {
        id: parseInt(req.params.id)
      }
    });
    res.json(deletedUser);
  });

Konklusjon

Ved å følge instruksjonene i denne artikkelen har vi bygget et fungerende REST API ved hjelp av Prisma og PostgreSQL. Denne kombinasjonen tilbyr en effektiv og robust metode for å håndtere data i en Node.js-applikasjon.

Prisma forenkler både datamodellering og utføring av spørringer, noe som gir en smidigere utviklingsprosess. PostgreSQL tilfører datasikkerhet, ytelse og muligheten for skalering. Samlet gir disse teknologiene et sterkt fundament for å utvikle pålitelige REST APIer.

Ofte Stilte Spørsmål

1. Hva er fordelene ved å bruke Prisma?	Enhetlig håndtering av data Automatisk generering av modeller og spørringer Tydelig typekontroll
2. Hva er forskjellen mellom Prisma og Sequelize?	Prisma er et ORM-verktøy som er basert på Prisma Language, mens Sequelize er et ORM for Node.js som benytter JavaScript. Prisma har en mer deklarativ tilnærming til datamodellering, mens Sequelize er mer imperativ.
3. Hvorfor burde jeg velge PostgreSQL fremfor andre databaser?	PostgreSQL er en stabil og allsidig database med en bred funksjonalitet. Den er open source og har et stort fellesskap av brukere. Den tilbyr avanserte funksjoner som transaksjoner, indekser og utløsere.
4. Hvilke andre alternativer til Prisma finnes for å lage REST APIer?	TypeORM Mikro-ORM NestJS ORM
5. Hvordan kan jeg sikre mitt REST API?	Bruk autentisering og autorisasjon Implementer CSRF-beskyttelse Valider all inndata fra brukere Overvåk og loggfør API-forespørsler
6. Hvordan kan jeg forbedre ytelsen til mitt REST API?	Optimaliser databaseforespørsler Bruk hurtigbufring og andre cashing-mekanismer Implementer horisontal skalering
7. Hva er de beste fremgangsmåtene ved design av REST APIer?	Følg RESTful-prinsipper Bruk HTTP-statuskoder korrekt Sørg for god dokumentasjon
8. Hvordan kan jeg teste mitt REST API?	Bruk automatiserte verktøy som Postman eller Insomnia Lag unit- og integrasjonstester