Поиск по сайту:

Как создать REST API с помощью Prisma и PostgreSQL

Автор выбрал программу Write for DOnations.

Введение

Prisma — это ORM с открытым исходным кодом для Node.js и TypeScript. Он состоит из трех основных инструментов:

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

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

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

Предпосылки

Этот учебник предполагает следующее:

  • Как установить Node.js и создать локальную среду разработки для вашей ОС, чтобы настроить это.
  • Как установить и использовать Docker для дистрибутивов Linux.

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

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

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

Сначала создайте новый каталог для вашего проекта:

  1. mkdir my-blog

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

  1. cd my-blog

  2. 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:

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

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

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

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

Сначала выполните следующую команду, чтобы создать файл:

  1. 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, настроите PostgreSQL с помощью Docker и подключите к нему Prisma. Схема Prisma является основным файлом конфигурации для вашей установки Prisma и содержит схему вашей базы данных.

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

  1. npm install prisma --save-dev

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

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

  1. 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 (пользователь) и ваш_пароль (пароль). Вы можете изменить эти учетные данные на предпочитаемого пользователя и пароль. Сохраните и закройте файл.

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

  1. 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

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

  1. 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:

  1. npx prisma init

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

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

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

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

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

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

  1. nano .env

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

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

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

Когда вы закончите, сохраните и выйдите из файла.

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

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

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

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

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

  1. 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?
}

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

Между двумя моделями существует отношение «один ко многим», указанное в полях отношения posts и author в User и Post. . Это означает, что один пользователь может быть связан со многими сообщениями.

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

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

  1. npx prisma migrate dev --name init

Эта команда создает новую миграцию SQL в вашей файловой системе и отправляет ее в базу данных. Опция --name init, предоставленная команде, указывает имя миграции и будет использоваться для имени папки миграции, созданной в вашей файловой системе.

Вывод этой команды будет примерно таким:

Output
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": PostgreSQL database "my-blog", schema "public" at "localhost:5432"

PostgreSQL database my-blog created at localhost:5432

The following migration(s) have been created and applied from new schema changes:

migrations/
  └─ 20201209084626_init/
    └─ migration.sql

Running generate... (Use --skip-generate to skip the generators)

✔ Generated Prisma Client (2.13.0) to ./node_modules/@prisma/client in 75ms

Файл миграции SQL в каталоге prisma/migrations/20201209084626_init/migration.sql содержит следующие операторы, которые были выполнены для базы данных (выделенная часть имени файла может отличаться в вашей настройке):

-- CreateTable
CREATE TABLE "User" (
"id" SERIAL,
    "email" TEXT NOT NULL,
    "name" TEXT,

    PRIMARY KEY ("id")
);

-- CreateTable
CREATE TABLE "Post" (
"id" SERIAL,
    "title" TEXT NOT NULL,
    "content" TEXT,
    "published" BOOLEAN NOT NULL DEFAULT false,
    "authorId" INTEGER,

    PRIMARY KEY ("id")
);

-- CreateIndex
CREATE UNIQUE INDEX "User.email_unique" ON "User"("email");

-- AddForeignKey
ALTER TABLE "Post" ADD FOREIGN KEY("authorId")REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;

Вы также можете настроить сгенерированный файл миграции SQL, если добавите параметр --create-only в команду prisma migrate dev; например, вы можете настроить триггер или использовать другие функции базовой базы данных.

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

Шаг 4 — Изучение клиентских запросов Prisma в простом скрипте

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

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

Сначала установите Prisma Client в папку вашего проекта с пакетом Prisma Client npm:

  1. npm install @prisma/client

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

  1. mkdir src

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

  1. nano src/index.ts

Все запросы Prisma Client возвращают обещания, которые вы можете ожидать в своем коде. Это требует, чтобы вы отправляли запросы внутри функции async.

В файл src/index.ts добавьте следующий шаблон с функцией async, которая выполняется в вашем скрипте:

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 из ранее установленного пакета @prisma/client npm.
  2. Вы создаете экземпляр PrismaClient, вызывая конструктор и получая экземпляр с именем prisma.
  3. Вы определяете функцию async с именем 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:

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

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

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

  1. 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
      }
    ]
  }

Примечание. Если вы используете графический интерфейс базы данных, вы можете проверить, были ли данные созданы, просмотрев таблицы User и Post. Кроме того, вы можете изучить данные в Prisma Studio, запустив npx prisma studio.

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

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

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

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

  1. npm install express

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

  1. npm install @types/express --save-dev

Имея зависимости, вы можете настроить приложение Express.

Снова откройте основной исходный файл:

  1. 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.get:

. . .
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'),
)

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

  1. 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-клиента на основе терминала.

Примечание. Если вы предпочитаете использовать HTTP-клиент с графическим интерфейсом, вы можете использовать альтернативы, такие как Postman.

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

  1. curl http://localhost:3000/users

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

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

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

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

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

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

Маршруты, которые вы будете реализовывать, включают следующие параметры:

HTTP Method Route Description
GET /feed Fetches all published posts.
GET /post/:id Fetches a specific post by its ID.
POST /user Creates a new user.
POST /post Creates a new post (as a draft).
PUT /post/publish/:id Sets the published field of a post to true.
DELETE post/:id Deletes a post by its ID.

Сначала вы реализуете два оставшихся маршрута GET.

Вы можете остановить сервер, нажав CTRL+C на клавиатуре. Затем вы можете обновить файл index.ts, сначала открыв файл для редактирования:

  1. nano src/index.ts

Затем добавьте выделенные строки после реализации пользовательского маршрута /app.get:

. . .

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

Сохраните и выйдите из файла. Затем перезапустите сервер, используя:

  1. npx ts-node src/index.ts

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

  1. curl http://localhost:3000/feed

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

Output
[]

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

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

Эта команда вернет сообщение, которое вы изначально создали:

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

Далее вы реализуете два маршрута POST. В исходном терминальном сеансе остановите сервер с помощью CTRL+C, затем откройте index.ts для редактирования:

  1. nano src/index.ts

Добавьте выделенные строки в 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 используется в обеих реализациях. В реализации маршрута /user вы передаете значения из тела HTTP-запроса в запрос create клиента Prisma.

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

Когда вы закончите, сохраните и выйдите из файла.

Перезапустите сервер, используя:

  1. npx ts-node src/index.ts

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

  1. 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:

  1. 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 с помощью следующей команды:

  1. 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. Реализация маршрута /post/:id для удаления сообщения в базе данных также извлекает идентификатор сообщения из URL-адреса и передает его в запрос delete клиента Prisma.

Сохраните и выйдите из файла.

Перезапустите сервер, используя:

  1. npx ts-node src/index.ts

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

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

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

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

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

Эта команда удалит сообщение со значением идентификатора 1. Чтобы убедиться, что сообщение с этим идентификатором было удалено, вы можете повторно отправить запрос GET на маршрут /post/1 со следующим curl команда:

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

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

Заключение

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

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