Prisma, Express, TypeScript 및 PostgreSQL을 사용하여 RESTful API 구축

목차

1. 소개

   • Prisma, Express, TypeScript, PostgreSQL 개요
   • Prisma를 ORM으로 사용해야 하는 이유
   • 환경설정

2. 초기 프로젝트 설정

   • 새 Node.js 프로젝트 설정
   • TypeScript 구성
   • 필수 패키지 설치

3. PostgreSQL 설정

   • PostgreSQL 설치
   • 새 데이터베이스 생성
   • 환경 변수 구성

4. Prisma 설정

   • 프리즈마 설치
   • 프로젝트에서 Prisma 초기화
   • Prisma 스키마 구성

5. 데이터 모델 정의

   • PSL(Prisma 스키마 언어) 이해
   • API용 모델 생성
   • Prisma를 사용한 마이그레이션

6. Prisma와 Express 통합

   • 익스프레스 서버 설정
   • Prisma를 사용하여 CRUD 작업 생성
   • 오류 처리 및 유효성 검사

7. 유형 안전을 위해 TypeScript 사용

   • Prisma로 유형 정의
   • 유형이 안전한 쿼리 및 변형
   • API 개발에 TypeScript 활용

8. API 테스트

   • Prisma 모델을 위한 단위 테스트 작성
   • Supertest와 Jest를 이용한 통합 테스트
   • Prisma를 이용한 데이터베이스 모의

9. 배포 고려 사항

   • 프로덕션용 API 준비
   • PostgreSQL 배포
   • Node.js 애플리케이션 배포

10. 결론

    • Express 및 TypeScript와 함께 Prisma를 사용할 때의 이점
    • 최종 생각 및 다음 단계

---

1. 소개

Prisma, Express, TypeScript 및 PostgreSQL 개요

현대 웹 개발에서는 강력하고 확장 가능하며 유형이 안전한 API를 구축하는 것이 중요합니다. ORM으로서의 Prisma, 서버측 로직을 위한 Express, 정적 타이핑을 위한 TypeScript, 안정적인 데이터베이스 솔루션인 PostgreSQL을 결합하여 강력한 RESTful API를 만들 수 있습니다.

Prisma는 유형이 안전한 쿼리, 마이그레이션 및 원활한 데이터베이스 스키마 관리를 지원하는 최신 ORM을 제공하여 데이터베이스 관리를 단순화합니다. Express는 웹 및 모바일 애플리케이션을 위한 강력한 기능 세트를 제공하는 최소한의 유연한 Node.js 웹 애플리케이션 프레임워크입니다. TypeScript는 JavaScript에 정적 유형 정의를 추가하여 개발 프로세스 초기에 오류를 포착하는 데 도움을 줍니다. PostgreSQL은 안정성과 기능 세트로 유명한 강력한 오픈 소스 관계형 데이터베이스 시스템입니다.

왜 Prisma를 ORM으로 사용하나요?

Prisma는 Sequelize 및 TypeORM과 같은 기존 ORM에 비해 몇 가지 장점을 제공합니다.

• 유형이 안전한 데이터베이스 쿼리: 자동으로 생성된 유형은 데이터베이스 쿼리가 유형이 안전하고 오류가 없는지 보장합니다.
• 자동 마이그레이션: Prisma는 데이터베이스 스키마를 Prisma 스키마와 동기화된 상태로 유지하는 강력한 마이그레이션 시스템을 제공합니다.
• 직관적인 데이터 모델링: Prisma 스키마 파일(PSL로 작성)은 이해하고 유지 관리하기 쉽습니다.
• 광범위한 생태계: Prisma는 GraphQL, REST API 및 PostgreSQL과 같은 인기 데이터베이스를 포함한 다른 도구 및 서비스와 원활하게 통합됩니다.

환경 설정

코드를 살펴보기 전에 컴퓨터에 다음 도구가 설치되어 있는지 확인하세요.

• Node.js(LTS 버전 권장)
• npm 또는 Yarn(패키지 관리용)
• TypeScript(정적 타이핑용)
• PostgreSQL(데이터베이스로)

이러한 도구가 설치되면 API 구축을 시작할 수 있습니다.

---

2. 초기 프로젝트 설정

새 Node.js 프로젝트 설정

1. 새 프로젝트 디렉토리 만들기:

   mkdir prisma-express-api
   cd prisma-express-api

1. 새 Node.js 프로젝트 초기화:

   npm init -y

이렇게 하면 프로젝트 디렉터리에 package.json 파일이 생성됩니다.

TypeScript 구성

1. TypeScript 및 Node.js 유형 설치:

   npm install typescript @types/node --save-dev

1. 프로젝트에서 TypeScript 초기화:

   npx tsc --init

이 명령은 TypeScript의 구성 파일인 tsconfig.json 파일을 생성합니다. 프로젝트에 필요에 따라 수정하세요. 기본 설정은 다음과 같습니다.

   {
     "compilerOptions": {
       "target": "ES2020",
       "module": "commonjs",
       "strict": true,
       "esModuleInterop": true,
       "skipLibCheck": true,
       "forceConsistentCasingInFileNames": true,
       "outDir": "./dist"
     },
     "include": ["src/**/*"]
   }

1. 프로젝트 구조 만들기:

   mkdir src
   touch src/index.ts

필수 패키지 설치

Express 및 Prisma를 시작하려면 몇 가지 필수 패키지를 설치해야 합니다.

npm install express prisma @prisma/client
npm install --save-dev ts-node nodemon @types/express

• express: The web framework for Node.js.
• prisma: The Prisma CLI for database management.
• @prisma/client: The Prisma client for querying the database.
• ts-node: Runs TypeScript directly without the need for precompilation.
• nodemon: Automatically restarts the server on file changes.
• @types/express: TypeScript definitions for Express.

---

3. Setting Up PostgreSQL

Installing PostgreSQL

PostgreSQL can be installed via your operating system’s package manager or directly from the official website. For example, on macOS, you can use Homebrew:

brew install postgresql
brew services start postgresql

Creating a New Database

Once PostgreSQL is installed and running, you can create a new database for your project:

psql postgres
CREATE DATABASE prisma_express;

Replace prisma_express with your preferred database name.

Configuring Environment Variables

To connect to the PostgreSQL database, create a .env file in your project’s root directory and add the following environment variables:

DATABASE_URL="postgresql://<user>:<password>@localhost:5432/prisma_express"
</password></user>

Replace and with your PostgreSQL username and password. This connection string will be used by Prisma to connect to your PostgreSQL database.

---

4. Setting Up Prisma

Installing Prisma

Prisma is already installed in the previous step, so the next step is to initialize it within the project:

npx prisma init

This command will create a prisma directory containing a schema.prisma file and a .env file. The .env file should already contain the DATABASE_URL you specified earlier.

Configuring the Prisma Schema

The schema.prisma file is where you'll define your data models, which will be used to generate database tables.

Here’s a basic example schema:

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id        Int      @id @default(autoincrement())
  name      String
  email     String   @unique
  createdAt DateTime @default(now())
  posts     Post[]
}

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

In this schema, we have two models: User and Post. Each model corresponds to a database table. Prisma uses these models to generate type-safe queries for our database.

---

5. Defining the Data Model

Understanding Prisma Schema Language (PSL)

Prisma Schema Language (PSL) is used to define your database schema. It's intuitive and easy to read, with a focus on simplicity. Each model in the schema represents a table in your database, and each field corresponds to a column.

Creating Models for the API

In the schema defined earlier, we created two models:

• User: Represents users in our application.
• Post: Represents posts created by users.

Migrations with Prisma

To apply your schema changes to the database, you’ll need to run a migration:

npx prisma migrate dev --name init

This command will create a new migration file and apply it to your database, creating the necessary tables.

---

6. Integrating Prisma with Express

Setting Up the Express Server

In your src/index.ts, set up the basic Express server:

import express, { Request, Response } from 'express';
import { PrismaClient } from '@prisma/client';

const app = express();
const prisma = new PrismaClient();

app.use(express.json());

app.get('/', (req: Request, res: Response) => {
  res.send('Hello, Prisma with Express!');
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});

This code sets up a simple Express server and initializes the Prisma client.

Creating CRUD Operations with Prisma

Next, let’s create some CRUD (Create, Read, Update, Delete) routes for our User model.

Create a new user:

app.post('/user', async (req: Request, res: Response) => {
  const { name, email } = req.body;
  const user = await prisma.user.create({
    data: { name, email },
  });
  res.json(user);
});

Read all users:

app.get('/users', async (req: Request, res: Response) => {
  const users = await prisma.user.findMany();
  res.json(users);
});

Update a user:

app.put('/user/:id', async (req: Request, res: Response) => {
  const { id } = req.params;
  const { name, email } = req.body;
  const user = await prisma.user.update({
    where: { id: Number(id) },
    data: { name, email },
  });
  res.json(user);
});

Delete a user:

app.delete('/user/:id', async (req: Request, res: Response) => {
  const { id } = req.params;
  const user = await prisma.user.delete({
    where: { id: Number(id) },
  });
  res.json(user);
});

Error Handling and Validation

To enhance the robustness of your API, consider adding error handling and validation:

app.post('/user', async (req: Request, res: Response) => {
  try {
    const { name, email } = req.body;
    if (!name || !email) {
      return res.status(400).json({ error: 'Name and email are required' });
    }
    const user = await prisma.user.create({
      data: { name, email },
    });
    res.json(user);
  } catch (error) {
    res.status(500).json({ error: 'Internal Server Error' });
  }
});

---

7. Using TypeScript for Type Safety

Defining Types with Prisma

Prisma automatically generates TypeScript types for your models based on your schema. This ensures that your database queries are type-safe.

For example, when creating a new user, TypeScript will enforce the shape of the data being passed:

const user = await prisma.user.create({
  data: { name, email }, // TypeScript ensures 'name' and 'email' are strings.
});

Type-Safe Queries and Mutations

With TypeScript, you get autocomplete and type-checking for all Prisma queries, reducing the chance of runtime errors:

const users: User[] = await prisma.user.findMany();

Leveraging TypeScript in API Development

Using TypeScript throughout your API development helps catch potential bugs early, improves code readability, and enhances overall development experience.

---

8. Testing the API

Writing Unit Tests for Prisma Models

Testing is an essential part of any application development. You can write unit tests for your Prisma models using a testing framework like Jest:

npm install jest ts-jest @types/jest --save-dev

Create a jest.config.js file:

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
};

Example test for creating a user:

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

test('should create a new user', async () => {
  const user = await prisma.user.create({
    data: {
      name: 'John Doe',
      email: 'john.doe@example.com',
    },
  });
  expect(user).toHaveProperty('id');
  expect(user.name).toBe('John Doe');
});

Integration Testing with Supertest and Jest

You can also write integration tests using Supertest:

npm install supertest --save-dev

Example integration test:

import request from 'supertest';
import app from './app'; // Your Express app

test('GET /users should return a list of users', async () => {
  const response = await request(app).get('/users');
  expect(response.status).toBe(200);
  expect(response.body).toBeInstanceOf(Array);
});

Mocking the Database with Prisma

For testing purposes, you might want to mock the Prisma client. You can do this using tools like jest.mock() or by creating a mock instance of the Prisma client.

---

9. Deployment Considerations

Preparing the API for Production

Before deploying your API, ensure you:

• Remove all development dependencies.
• Set up environment variables correctly.
• Optimize the build process using tools like tsc and webpack.

Deploying PostgreSQL

You can deploy PostgreSQL using cloud services like AWS RDS, Heroku, or DigitalOcean. Make sure to secure your database with proper authentication and network settings.

Deploying the Node.js Application

For deploying the Node.js application, consider using services like:

• Heroku: For simple, straightforward deployments.
• AWS Elastic Beanstalk: For more control over the infrastructure.
• Docker: To containerize the application and deploy it on any cloud platform.

---

10. Conclusion

Benefits of Using Prisma with Express and TypeScript

Using Prisma as an ORM with Express and TypeScript provides a powerful combination for building scalable, type-safe, and efficient RESTful APIs. With Prisma, you get automated migrations, type-safe queries, and an intuitive schema language, making database management straightforward and reliable.

Congratulations!! You've now built a robust RESTful API using Prisma, Express, TypeScript, and PostgreSQL. From setting up the environment to deploying the application, this guide covered the essential steps to get you started. As next steps, consider exploring advanced Prisma features like nested queries, transactions, and more complex data models.

Happy coding!

위 내용은 Prisma, Express, TypeScript 및 PostgreSQL을 사용하여 RESTful API 구축의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!