目录
简介
初始项目设置
设置 PostgreSQL
设置 Prisma
定义数据模型
将 Prisma 与 Express 集成
使用 TypeScript 实现类型安全
测试 API
部署注意事项
结论
在现代 Web 开发中，构建健壮、可扩展且类型安全的 API 至关重要。结合 Prisma 作为 ORM、Express 用于服务器端逻辑、TypeScript 用于静态类型以及 PostgreSQL 作为可靠的数据库解决方案的强大功能，我们可以创建强大的 RESTful API。
Prisma 通过提供支持类型安全查询、迁移和无缝数据库模式管理的现代 ORM 来简化数据库管理。 Express 是一个最小且灵活的 Node.js Web 应用程序框架，为 Web 和移动应用程序提供了一组强大的功能。 TypeScript 向 JavaScript 添加了静态类型定义，有助于在开发过程的早期捕获错误。 PostgreSQL 是一个功能强大的开源关系数据库系统，以其可靠性和功能集而闻名。
Prisma 与 Sequelize 和 TypeORM 等传统 ORM 相比具有多种优势：
在我们深入研究代码之前，请确保您的计算机上安装了以下工具：
安装这些工具后，我们就可以开始构建我们的 API。
mkdir prisma-express-api cd prisma-express-api
npm init -y
这将在您的项目目录中创建一个 package.json 文件。
npm install typescript @types/node --save-dev
npx tsc --init
此命令创建一个 tsconfig.json 文件，它是 TypeScript 的配置文件。根据您的项目需要对其进行修改。这是基本设置：
{
"compilerOptions": {
"target": "ES2020",
"module": "commonjs",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"outDir": "./dist"
},
"include": ["src/**/*"]
}
mkdir src touch src/index.ts
要开始使用 Express 和 Prisma，您需要安装一些必要的软件包：
npm install express prisma @prisma/client npm install --save-dev ts-node nodemon @types/express
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
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.
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"
Replace
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.
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.
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.
In the schema defined earlier, we created two models:
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.
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.
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);
});
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' });
}
});
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.
});
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();
Using TypeScript throughout your API development helps catch potential bugs early, improves code readability, and enhances overall development experience.
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');
});
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);
});
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.
Before deploying your API, ensure you:
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.
For deploying the Node.js application, consider using services like:
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中文网其他相关文章！
