Создание REST API с помощью Prisma и PostgreSQL

Автор выбрал Diversity in Tech Fund для получения пожертвования в рамках программы Write for DOnations.

Введение

Prisma — это набор инструментов для работы с базой данных с открытым исходным кодом. Он включает три основных инструмента:

• Prisma Client: конструктор автоматически генерируемых типобезопасных запросов для Node.js и TypeScript.
• Prisma Migrate: система моделирования данных и миграции, поддерживающая декларативный подход.
• Prisma Studio: графический пользовательский интерфейс для просмотра и редактирования данных в вашей базе данных.

Эти инструменты направлены на повышение производительности разработчика приложения при работе с базой данных. Одним из главных преимуществ Prisma является уровень абстракции, который она предоставляет: вместо формирования сложных SQL запросов или миграций схемы БД, разработчики приложения могут рассуждать о своих данных более интуитивно понятным образом, используя Prisma для работы с базой данных.

В этом обучающем руководстве мы напишем REST API для небольшого приложения для ведения блога на TypeScript с помощью Prisma и базы данных PostgreSQL. Вы настроите локальную базу данных PostgreSQL с помощью Docker и реализуете маршруты REST API с помощью Express. После выполнения руководства у вас будет работающий на вашем локальном компьютере веб-сервер, который будет отвечать на различные HTTP запросы, а также выполнять чтение и запись в базу данных.

Предварительные требования

Для выполнения инструкций данного руководства требуется следующее:

• Node.js версии 10 или выше, установленный на вашем компьютере. Вы можете воспользоваться одним из наших руководств по установке Node.js и созданию локальной среды разработки для вашей ОС для выполнения необходимых настроек.
• Docker, установленный на вашем компьютере (для запуска базы данных PostgreSQL). Вы можете установить необходимое ПО на macOS и Windows с помощью веб-сайта Docker, или воспользоваться инструкцией Установка и использование Docker, если вы используете какой-либо из дистрибутивов Linux.

Базовое знакомство с TypeScript и REST API будет полезно, но не обязательно для выполнения данного руководства.

Шаг 1 — Создание проекта TypeScript

В этом шаге мы настроим простой проект TypeScript с помощью npm. Этот проект послужит основой для REST API, который вы будете создавать при выполнении данного руководства.

Во-первых, создайте новый каталог для вашего проекта:

mkdir my-blog

Затем перейдите в этот каталог и инициализируйте создание пустого проекта npm. Обратите внимание, что опция -y здесь означает, что вы хотите пропустить интерактивные запросы команды. Чтобы просмотреть запросы, удалите -y из команды:

cd my-blog
npm init -y

Дополнительную информацию об этих запросах вы можете найти в шаге 1 руководства Использование модулей Node.js с npm и package.json.

Вы получите примерно следующий вывод с ответами по умолчанию:

Output
Wrote to /.../my-blog/package.json:

{
  "name": "my-blog",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Эта команда создает файл package.json с минимальным содержанием, который вы будете использовать в качестве файла конфигурации для вашего проекта npm. Теперь вы готовы к настройке TypeScript в вашем проекте.

Выполните следующую команду для простой настройки TypeScript:

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

Эта команда устанавливает три пакета в качестве зависимостей разработки в вашем проекте:

• typescript: набор инструментов TypeScript.
• ts-node: пакет для запуска приложений TypeScript без предварительной компиляции в JavaScript.
• @types/node: определения типов TypeScript для Node.js.

В качестве последнего шага необходимо добавить файл tsconfig.json, чтобы гарантировать корректность настройки TypeScript для приложения, которое вы будете создавать.

Сначала запустите следующую команду для создания файла:

nano tsconfig.json

Добавьте в файл следующий код JSON:

{
  "compilerOptions": {
    "sourceMap": true,
    "outDir": "dist",
    "strict": true,
    "lib": ["esnext"],
    "esModuleInterop": true
  }
}

Сохраните и закройте файл.

Это стандартная и минимальная конфигурация для проекта TypeScript. Если вы хотите узнать об отдельных свойствах файла конфигурации, всю необходимую информацию вы можете найти в документации TypeScript.

Вы настроили простой проект TypeScript с помощью npm. После этого вы должны будете настроить свою базу данных PostgreSQL с помощью Docker и подключить Prisma к этой базе данных.

Шаг 2 — Настройка Prisma с PostgreSQL

В этом шаге мы установим Prisma CLI, создадим первоначальный файл схемы Prisma и настроим PostgreSQL с помощью Docker, после чего нужно будет подключить ее к Prisma. Схема Prisma — это основной файл конфигурации для настройки Prisma, который содержит схему вашей базы данных.

Начните с установки Prisma CLI, воспользовавшись следующей командой:

npm install @prisma/cli --save-dev

Рекомендуется использовать локальную установку Prisma CLI для вашего проекта (а не глобальную установку). Это помогает избежать конфликтов версий при наличии нескольких проектов Prisma на вашем компьютере.

Далее вам нужно настроить вашу базу данных PostgreSQL с помощью Docker. Создайте новый файл Docker Compose с помощью следующей команды:

nano docker-compose.yml

Добавьте следующий код во вновь созданный файл:

version: '3.8'
services:
  postgres:
    image: postgres:10.3
    restart: always
    environment:
      - POSTGRES_USER=sammy
      - POSTGRES_PASSWORD=your_password
    volumes:
      - postgres:/var/lib/postgresql/data
    ports:
      - '5432:5432'
volumes:
  postgres:

Данный файл Docker Compose настраивает базу данных PostgreSQL, доступ к которой можно получить через порт 5432 контейнера Docker. Обратите внимание, что в настоящее время для базы данных установлены следующие учетные данные: sammy (пользователь) и your_password (пароль). Вы можете изменить эти учетные данные и указать предпочитаемые имя пользователя и пароль. Сохраните и закройте файл.

После выполнения этих действий вы можете перейти к запуску сервера базы данных PostgreSQL с помощью следующей команды:

docker-compose up -d

Вывод этой команды будет выглядеть примерно следующим образом:

Output
Pulling postgres (postgres:10.3)...
10.3: Pulling from library/postgres
f2aa67a397c4: Pull complete
6de83ca23e55: Pull complete
. . .
Status: Downloaded newer image for postgres:10.3
Creating my-blog_postgres_1 ... done

Вы можете проверить, работает ли сервер базы данных, воспользовавшись следующей командой:

docker ps

Вы получите примерно следующий вывод:

Output
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
8547f8e007ba        postgres:10.3       "docker-entrypoint.s…"   3 seconds ago       Up 2 seconds        0.0.0.0:5432->5432/tcp   my-blog_postgres_1

После запуска сервера базы данных вы сможете создать вашу настройку Prisma. Запустите следующую команду в Prisma CLI:

npx prisma init

Результат будет выглядеть следующим образом:

Output
✔ Your Prisma schema was created at prisma/schema.prisma.
  You can now open it in your favorite editor.

Обратите внимание, что рекомендуется использовать префикс npx в каждом вызове Prisma CLI. Это гарантирует, что будет использоваться именно локальная установка клиента.

После запуска команды Prisma CLI создает новую папку с именем prisma в вашем проекте. Она содержит два следующих файла:

• schema.prisma: главный файл конфигурации для вашего проекта Prisma (он будет включать вашу модель данных).
• .env: файл dotenv для определения URL-адреса для подключения к базе данных.

Чтобы гарантировать, что Prisma будет знать расположение вашей базы данных, откройте файл .env и измените значение переменной среды DATABASE_URL.

Сначала откройте файл .env:

nano prisma/.env

Теперь вы можете задать значение переменной среды следующим образом:

DATABASE_URL="postgresql://sammy:your_password@localhost:5432/my-blog?schema=public"

Убедитесь, что вы можете изменить учетные данные для БД на данные, указанные в файле Docker Compose. Дополнительную информацию о формате URL-адреса подключения см. в документации Prisma.

После выполнения этих действий сохраните и закройте файл.

В этом шаге вы настроили свою базу данных PostgreSQL с помощью Docker, установили Prisma CLI и подключили Prisma к базе данных с помощью переменной среды. В следующем разделе вы определите модель данных и создадите таблицы вашей базы данных.

Шаг 3 — Определение модели данных и создание таблиц базы данных

В этом шаге вы определите вашу модель данных в файле схемы Prisma. Эта модель данных затем будет перенесена на базу данных с помощью Prisma Migrate, которая будет генерировать и отправлять SQL инструкции для создания таблиц, соответствующих вашей модели данных. Поскольку вы создаете приложение для ведения блога, основными сущностями приложения будут пользователи и посты.

Prisma использует свой собственный язык моделирования данных для определения формы данных вашего приложения.

Сначала откройте файл schema.prisma с помощью следующей команды:

nano prisma/schema.prisma

Теперь добавьте в файл следующие определения модели. Вы можете поместить модели в нижней части файла сразу после блока generator client:

. . .
model User {
  id    Int     @default(autoincrement()) @id
  email String  @unique
  name  String?
  posts Post[]
}

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

Сохраните и закройте файл.

Вы определяете две модели: User и Post. Каждая из этих моделей имеет ряд полей, которые представляют свойства модели. Модели будут отображаться в таблицах базы данных, а поля представляют отдельные столбцы.

Обратите внимание на связь один-ко-многим между двумя моделями, определяемую связанными полями posts и author в таблицах User и Post. Это означает, что один пользователь может быть связан с несколькими постами.

После получения этих моделей вы можете создать соответствующие таблицы в базе данных с помощью Prisma Migrate. В терминале запустите следующую команду:

npx prisma migrate save --experimental --create-db --name "init"

Эта команда создает новую миграцию в вашей файловой системе. Ниже приводится краткое описание трех опций, предоставляемых командой:

• --experimental: обязательная опция, поскольку Prisma Migrate находится в настоящее время в экспериментальном состоянии.
• --create-db: дает Prisma Migrate возможность создать базу данных с именем my-blog, которое указано в URL-адресе подключения.
• --name "init": указывает имя миграции (будет использоваться при присвоении имени папке миграции, создаваемой в вашей файловой системе).

Вывод этой команды будет выглядеть примерно следующим образом:

Output
New datamodel:

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

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

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

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

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


Prisma Migrate just created your migration 20200811140708-init in

migrations/
  └─ 20200811140708-init/
    └─ steps.json
    └─ schema.prisma
    └─ README.md

Вы можете ознакомиться с созданными миграционными файлами в каталоге prisma/migrations.

Чтобы запустить миграцию для вашей базы данных и создать таблицы для ваших моделей Prisma, запустите следующую команду в терминале:

npx prisma migrate up --experimental

Вывод должен выглядеть следующим образом:

Output
. . .
Checking the datasource for potential data loss...

Database Changes:

Migration            Database actions             Status

20200811140708-init  2 CreateTable statements.    Done 🚀

You can get the detailed db changes with prisma migrate up --experimental --verbose
Or read about them here:
      ./migrations/20200811140708-init/README.md


🚀    Done with 1 migration in 206ms.

Prisma Migrate генерирует инструкции SQL, необходимые для выполнения миграции, и отправляет их базе данных. Ниже приводятся SQL инструкции, которые создают таблицы:

CREATE TABLE "public"."User" (
  "id" SERIAL,
  "email" text  NOT NULL ,
  "name" text   ,
  PRIMARY KEY ("id")
)

CREATE TABLE "public"."Post" (
  "id" SERIAL,
  "title" text  NOT NULL ,
  "content" text   ,
  "published" boolean  NOT NULL DEFAULT false,
  "authorId" integer   ,
  PRIMARY KEY ("id")
)

CREATE UNIQUE INDEX "User.email" ON "public"."User"("email")

ALTER TABLE "public"."Post" ADD FOREIGN KEY ("authorId")REFERENCES "public"."User"("id") ON DELETE SET NULL ON UPDATE CASCADE

В этом шаге вы определили вашу модель данных в схеме Prisma и создали соответствующие таблицы базы данных с помощью Prisma Migrate. В следующем шаге вы установите Prisma Client для вашего проекта, чтобы вы могли отправлять запросы базе данных.

Шаг 4 — Знакомство с запросами Prisma Client в форме простого скрипта

Prisma Client — это инструмент для автоматической генерации типобезопасных запросов, который вы можете использовать для программного чтения и записи данных в базу данных в приложении на базе Node.js или TypeScript. Вы будете использовать его для доступа к базе данных в рамках ваших маршрутов REST API в качестве замены для традиционных ORM, простых запросов SQL, собственных слоев доступа к данным или любого другого метода работы с базой данных.

В этом шаге вы установите Prisma Client и познакомитесь с запросами, которые он позволяет отправлять. Прежде чем реализовать маршруты для вашего REST API в следующих шагах, вы должны будете познакомиться с запросами Prisma Client в форме простого исполняемого скрипта.

Перейдите к установке Prisma Client для вашего проекта, открыв терминал и установив пакет npm Prisma Client:

npm install @prisma/client

Затем создайте новый каталог с именем src, который будет содержать исходные файлы:

mkdir src

Теперь создайте файл TypeScript внутри нового каталога:

nano src/index.ts

Все запросы Prisma Client возвращают промисы, которые вы можете ожидать в своем коде. Поэтому вы должны отправлять запросы внутри асинхронной функции.

Добавьте следующий шаблонный код с асинхронной функцией, выполняемой в вашем скрипте:

import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient()

async function main() {
  // ... your Prisma Client queries will go here
}

main()
  .catch((e) => console.error(e))
  .finally(async () => await prisma.disconnect())

Ниже приводится короткое пояснения шаблонного кода:

1. Импорт конструктора PrismaClient из ранее установленного пакета npm @prisma/client.
2. Создание объекта PrismaClient с помощью вызова конструктора и получения экземпляра с именем prisma.
3. Определение асинхронной функции с именем main, куда вы позже будете добавлять запросы Prisma Client.
4. Вызов функции main вместе с перехватом любых возможных исключений, а также гарантия того, что Prisma Client будет закрывать все открытые подключения к базе данных с помощью вызова prisma.disconnect().

Получив в распоряжение функцию main, вы можете начинать добавлять запросы Prisma Client в скрипт. Измените содержание файла index.ts, которое должно выглядеть следующим образом:

import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient()

async function main() {
  const newUser = await prisma.user.create({
    data: {
      name: 'Alice',
      email: 'alice@prisma.io',
      posts: {
        create: {
          title: 'Hello World',
        },
      },
    },
  })
  console.log('Created new user: ', newUser)

  const allUsers = await prisma.user.findMany({
    include: { posts: true },
  })
  console.log('All users: ')
  console.dir(allUsers, { depth: null })
}

main()
  .catch((e) => console.error(e))
  .finally(async () => await prisma.disconnect())

В этом коде вы используете два запроса Prisma Client:

• create: создает новую запись User. Обратите внимание, что вы используете вложенную запись, что означает, что вы создаете записи User и Post в одном запросе.
• findMany: считывает все существующие записи User из базы данных. Вы указываете опцию include, которая дополнительно загружает связанные записи Post для каждой записи User.

Теперь запустите скрипт с помощью следующей команды:

npx ts-node src/index.ts

В терминале вы получили следующий вывод:

Output
Created new user:  { id: 1, email: 'alice@prisma.io', name: 'Alice' }
[
  {
    id: 1,
    email: 'alice@prisma.io',
    name: 'Alice',
    posts: [
      {
        id: 1,
        title: 'Hello World',
        content: null,
        published: false,
        authorId: 1
      }
    ]
  }

Вы успешно воспользовались Prisma Client для чтения и записи данных в вашей базе данных. В оставшихся шагах вы будете применять эти новые знания для реализации маршрутов на образце REST API.

Шаг 5 — Реализация вашего первого маршрута REST API

В этом шаге вы установите Express для вашего приложения. Express — это популярный веб-фреймворк для Node.js, который вы будете использовать для имплементации ваших маршрутов REST API в рамках данного проекта. Первый маршрут, который вы будете реализовать, позволит вам получить всех пользователей из API с помощью запроса GET. Данные пользователя будут получены из базы данных с помощью Prisma Client.

Начните с установки Express с помощью следующей команды:

npm install express

Поскольку вы используете TypeScript, вам также нужно будет установить соответствующие типы в качестве зависимостей разработки. Для этого запустите следующую команду:

npm install @types/express --save-dev

После получения зависимостей вы можете перейти к настройке вашего приложения Express.

Начните с открытия вашего главного исходного файла еще раз:

nano src/index.ts

Теперь удалите весь код в файле index.ts и замените его на следующий код для запуска вашего REST API:

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

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

app.use(express.json())

// ... your REST API routes will go here

app.listen(3000, () =>
  console.log('REST API server ready at: http://localhost:3000'),
)

Ниже приводится краткое описание элементов кода:

1. Импорт PrismaClient и express из соответствующих пакетов npm.
2. Создание объекта PrismaClient с помощью вызова конструктора и получения экземпляра с именем prisma.
3. Создание вашего приложения Express с помощью вызова express().
4. Добавление промежуточного слоя ПО с помощью вызова express.json() для обеспечения возможности корректной обработки данных в формате JSON с помощью Express.
5. Запуск сервера на порту 3000.

Теперь вы можете реализовать свой первый маршрут. Между вызовами app.use и app.listen добавьте следующий код:

. . .
app.use(express.json())

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

app.listen(3000, () =>
console.log('REST API server ready at: http://localhost:3000'),
)

После добавления кода сохраните и закройте файл. Затем запустите локальный веб-сервер с помощью следующей команды:

npx ts-node src/index.ts

Результат будет выглядеть следующим образом:

Output
REST API server ready at: http://localhost:3000

Чтобы получить доступ к маршруту /users, вы можете указать в адресной строке браузера http://localhost:3000/users или воспользоваться любым другим клиентом HTTP.

В этом руководстве мы будем тестировать все маршруты REST API с помощью curl, HTTP клиента для командной строки.

Чтобы протестировать маршрут, откройте новое окно терминала или вкладку (чтобы ваш локальный веб-сервер мог продолжать работу) и выполните следующую команду:

curl http://localhost:3000/users

Вы получите данные сущности User, которую вы создали в предыдущем шаге:

Output
[{"id":1,"email":"alice@prisma.io","name":"Alice"}]

Обратите внимание, что в этот раз массив posts не включен в результат. Это происходит потому, что вы не передаете опцию include в вызов findMany при реализации маршрута /users.

Вы успешно реализовали свой первый маршрут REST API в /users. В следующем шаге вы будете реализовывать оставшиеся маршруты REST API, чтобы добавить дополнительный функционал для вашего API.

Шаг 6 — Реализация остальных маршрутов REST API

В этом шаге вы будете реализовывать оставшиеся маршруты REST API для вашего приложения для ведения блога. В результате ваш веб-сервер будет обслуживать различные запросы типа GET, POST, PUT и DELETE.

Ниже приводится описание различных маршрутов, которые вы будете реализовывать:

Теперь вы можете перейти к реализации остальных маршрутов GET.

Откройте файл index.ts с помощью следующей команды:

nano src/index.ts

Затем добавьте следующий код под реализацией маршрута /users:

. . .

app.get('/feed', async (req, res) => {
  const posts = await prisma.post.findMany({
    where: { published: true },
    include: { author: true }
  })
  res.json(posts)
})

app.get(`/post/:id`, async (req, res) => {
  const { id } = req.params
  const post = await prisma.post.findOne({
    where: { id: Number(id) },
  })
  res.json(post)
})

app.listen(3000, () =>
  console.log('REST API server ready at: http://localhost:3000'),
)

Сохраните и закройте файл.

Этот код реализует маршруты API для двух запросов GET:

• /feed: возвращает список опубликованных постов.
• /post/:id: возвращает конкретный пост по его идентификатору.

Prisma Client используется в обеих реализациях. В реализации маршрута /feed запрос, который вы отправляете с помощью Prisma Client, отфильтровывает все записи Post, где в колонке published указано значение true. Кроме того, запрос Prisma Client использует опцию include для получения связанной информации об авторе для каждого возвращаемого поста. В реализации маршрута /post/:id вы передаете идентификатор, который будет получен из URL-адреса, для чтения конкретной записи Post из базы данных.

Вы можете остановить работу сервера, нажав CTRL+C на клавиатуре. Затем перезапустите его с помощью следующей команды:

npx ts-node src/index.ts

Чтобы протестировать маршрут /feed, вы можете воспользоваться следующей командой curl:

curl http://localhost:3000/feed

Поскольку ни один пост еще не был опубликован, ответ будет содержать пустой массив:

Output
[]

Чтобы протестировать маршрут /post/:id, вы можете воспользоваться следующей командой curl:

curl http://localhost:3000/post/1

Она вернет пост, созданный вами ранее:

Output
{"id":1,"title":"Hello World","content":null,"published":false,"authorId":1}

Далее реализуйте два маршрута POST. Добавьте следующий код в файл index.ts под реализацией трех маршрутов GET:

. . .

app.post(`/user`, async (req, res) => {
  const result = await prisma.user.create({
    data: { ...req.body },
  })
  res.json(result)
})

app.post(`/post`, async (req, res) => {
  const { title, content, authorEmail } = req.body
  const result = await prisma.post.create({
    data: {
      title,
      content,
      published: false,
      author: { connect: { email: authorEmail } },
    },
  })
  res.json(result)
})

app.listen(3000, () =>
  console.log('REST API server ready at: http://localhost:3000'),
)

После этого сохраните и закройте файл.

Этот код реализует маршруты API для двух запросов POST:

• /user: создает нового пользователя в базе данных.
• /post: создает новый пост в базе данных.

Как и ранее, Prisma Client используется в обеих реализациях. В реализации маршрута /user вы передаете значения из тела запроса HTTP в запрос create Prisma Client.

Маршрут /post имеет немного более сложную структуру: здесь вы не можете прямо передавать значения из тела HTTP запроса, вместо этого вам сначала нужно вручную извлечь их, а уже после этого передать эти полученные значения в запрос Prisma Client. Это вызвано тем, что структура JSON в теле запроса не соответствует структуре, которую ожидает Prisma Client, поэтому вам нужно вручную создать ожидаемую структуру.

Вы можете протестировать новые маршруты, остановив сервер с помощью CTRL+C. Затем перезапустите его с помощью следующей команды:

npx ts-node src/index.ts

Чтобы создать нового пользователя с помощью маршрута /user, вы можете отправить следующий POST запрос с помощью curl:

curl -X POST -H "Content-Type: application/json" -d '{"name":"Bob", "email":"bob@prisma.io"}' http://localhost:3000/user

В результате в базе данных будет создан новый пользователь, а в консоли будет отображен следующий вывод:

Output
{"id":2,"email":"bob@prisma.io","name":"Bob"}

Чтобы создать новый пост с помощью маршрута /post, вы можете отправить следующий POST запрос с помощью curl:

curl -X POST -H "Content-Type: application/json" -d '{"title":"I am Bob", "authorEmail":"bob@prisma.io"}' http://localhost:3000/post

В результате в базе данных будет создан новый пост, который будет привязан к пользователю с электронной почтой bob@prisma.io. В консоль будет выведен следующий текст:

Output
{"id":2,"title":"I am Bob","content":null,"published":false,"authorId":2}

В заключение вы можете реализовать маршруты PUT и DELETE.

Откройте файл index.ts с помощью следующей команды:

nano src/index.ts

Затем под реализацией двух маршрутов POST добавьте выделенный код:

. . .

app.put('/post/publish/:id', async (req, res) => {
  const { id } = req.params
  const post = await prisma.post.update({
    where: { id: Number(id) },
    data: { published: true },
  })
  res.json(post)
})

app.delete(`/post/:id`, async (req, res) => {
  const { id } = req.params
  const post = await prisma.post.delete({
    where: { id: Number(id) },
  })
  res.json(post)
})

app.listen(3000, () =>
  console.log('REST API server ready at: http://localhost:3000'),
)

Сохраните и закройте файл.

Этот код реализует маршруты API для одного запроса PUT и одного запроса DELETE:

• /post/publish/:id (PUT): публикует пост по его идентификатору.
• /post/:id(DELETE): удаляет пост по его идентификатору.

Prisma Client снова используется в обеих реализациях. В реализации маршрута /post/publish/:id идентификатор поста, который будет опубликован, извлекается из URL-адреса и передается в запрос update Prisma Client. Реализация маршрута /post/:id, который будет удалять пост в базе данных, также извлекает идентификатор поста из URL-адреса и передает его в запрос delete Prisma Client.

Еще раз остановите сервер, нажав CTRL+C на клавиатуре. Затем перезапустите его с помощью следующей команды:

npx ts-node src/index.ts

Вы можете протестировать маршрут PUT с помощью следующей команды curl:

curl -X PUT http://localhost:3000/post/publish/2

В этом случае пост будет опубликован с идентификатором, равным 2. Если вы повторно отправите запрос для маршрута /feed, этот пост будет добавлен в ответ.

Далее вы можете протестировать маршрут DELETE с помощью следующей команды curl:

curl -X DELETE http://localhost:3000/post/1

В результате выполнения этой команды будет удален пост с идентификатором 1. Чтобы убедиться, что пост с этим идентификатором был удален, повторно отправьте запрос GET для маршрута /post/1.

В этом шаге вы реализовали оставшиеся маршруты REST API для вашего приложения для ведения блога. API теперь отвечает на различные запросы GET, POST, PUT и DELETE и реализует функционал для чтения и записи данных в базе данных.

Заключение

С помощью этой статьи вы создали сервер REST API с рядом различных маршрутов для создания, чтения, обновления и удаления данных пользователя и поста для примера приложения для ведения блога. Внутри маршрутов API вы используете Prisma Client для отправки соответствующих запросов для вашей базы данных.

В качестве следующих шагов вы можете реализовать дополнительные маршруты API или расширить схему вашей базы данных с помощью Prisma Migrate. Обязательно ознакомьтесь с документацией Prisma для получения информации о различных аспектах Prisma и изучите ряд готовых проектов в репозитории prisma-examples, воспользовавшись такими инструментами, как GraphQL или grPC API.