Node.js, Express и Prisma: API и работа с базой

Как это работает: createServer принимает callback, который выполняется на каждый входящий запрос; вы сами проверяете req.url/req.method, чтобы решить, что делать, и всегда должны вызвать res.end() для завершения ответа.

import { createServer } from 'node:http'

const server = createServer((req, res) => {
  if (req.url === '/health') {
    res.writeHead(200, { 'Content-Type': 'application/json' })
    res.end(JSON.stringify({ status: 'ok' }))
    return
  }

  res.writeHead(404)
  res.end('Not found')
})

server.listen(3000, () => console.log('Listening on http://localhost:3000'))

Как это работает: bcrypt генерирует уникальную случайную соль при каждом вызове (она встроена в саму возвращённую хеш-строку), поэтому хеширование одного и того же пароля два раза даёт два разных хеша — compare() заново извлекает эту соль из сохранённого хеша для проверки пароля-кандидата, поэтому хранить соль отдельно не нужно.

import bcrypt from 'bcrypt'

async function hashPassword(plainPassword) {
  const saltRounds = 12
  return bcrypt.hash(plainPassword, saltRounds)
}

async function verifyPassword(plainPassword, storedHash) {
  return bcrypt.compare(plainPassword, storedHash)
}

// Example usage
const hash = await hashPassword('correct horse battery staple')
const isValid = await verifyPassword('correct horse battery staple', hash)

Как это работает: функция проверяет process.env по ключу и возвращает fallback-значение, если переменная не задана или равна пустой строке.

function env(key, fallback) {
  const value = process.env[key]
  return value === undefined || value === '' ? fallback : value
}

// Example usage
const port = Number(env('PORT', 3000))
const dbUrl = env('DATABASE_URL', 'sqlite://local.db')

Как это работает: fs/promises (встроен в Node с v14) позволяет делать await файловых операций напрямую вместо вложенных коллбэков или ручного оборачивания fs.readFile в Promise — и в отличие от readFileSync, не блокирует обработку других запросов на время чтения с диска.

import { readFile } from 'node:fs/promises'

async function loadConfig(path) {
  const contents = await readFile(path, 'utf-8')
  return JSON.parse(contents)
}

// Example usage
const config = await loadConfig('./config.json')

Как это работает: обычное сравнение === завершается сразу при первом несовпавшем символе, поэтому время ответа тонко коррелирует с тем, сколько первых символов совпало — за много запросов атакующий может этим воспользоваться, чтобы подобрать секрет посимвольно. timingSafeEqual всегда занимает одинаковое время независимо от того, где строки расходятся.

import { timingSafeEqual } from 'node:crypto'

function timingSafeStringEquals(a, b) {
  const bufferA = Buffer.from(a, 'utf8')
  const bufferB = Buffer.from(b, 'utf8')

  // Length check short-circuits before the constant-time compare — safe,
  // since the expected length is fixed per endpoint and doesn't leak secret content
  if (bufferA.length !== bufferB.length) return false

  return timingSafeEqual(bufferA, bufferB)
}

// Example usage — verifying a webhook signature
if (!timingSafeStringEquals(receivedSignature, expectedSignature)) {
  throw new Error('Invalid signature')
}

Как это работает: Stripe отправляет каждое событие с подписью в заголовке. Обработчик проверяет подпись через секрет эндпоинта, затем проверяет набор дедупликации — один и тот же event.id никогда не обрабатывается дважды, даже если Stripe делает повторную отправку.

import Stripe from 'stripe'
import express from 'express'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)
const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET!

app.post('/webhooks/stripe', express.raw({ type: 'application/json' }), async (req, res) => {
  const sig = req.headers['stripe-signature']
  let event: Stripe.Event

  try {
    event = stripe.webhooks.constructEvent(req.body, sig!, endpointSecret)
  } catch {
    return res.status(400).send('Invalid signature')
  }

  // Дедупликация — event.id уникален
  if (await hasBeenProcessed(event.id)) {
    return res.json({ received: true }) // уже обработано
  }

  switch (event.type) {
    case 'checkout.session.completed':
      const session = event.data.object
      await activateSubscription(session.client_reference_id, session.subscription)
      break

    case 'invoice.payment_succeeded':
      await extendSubscription(event.data.object.subscription)
      break

    case 'customer.subscription.updated':
    case 'customer.subscription.deleted':
      await syncSubscriptionStatus(event.data.object)
      break
  }

  await markProcessed(event.id)
  res.json({ received: true })
})

async function hasBeenProcessed(id: string): Promise<boolean> {
  // Использовать Redis SET или таблицу в БД
  return false
}

async function markProcessed(id: string): Promise<void> {
  // Сохранить ID события с TTL
}

Как это работает: access token живёт 15 минут и передаётся в теле ответа. Refresh token хранится в httpOnly cookie и ротируется при каждом использовании — старый сразу инвалидируется, предотвращая перехват.

import jwt from 'jsonwebtoken'

const ACCESS_SECRET = process.env.JWT_ACCESS_SECRET!
const REFRESH_SECRET = process.env.JWT_REFRESH_SECRET!

function signTokens(userId: string) {
  const accessToken = jwt.sign({ sub: userId }, ACCESS_SECRET, { expiresIn: '15m' })
  const refreshToken = jwt.sign({ sub: userId, jti: crypto.randomUUID() }, REFRESH_SECRET, { expiresIn: '7d' })
  return { accessToken, refreshToken }
}

function authMiddleware(req, res, next) {
  const header = req.headers.authorization
  if (!header?.startsWith('Bearer ')) return res.sendStatus(401)

  try {
    req.user = jwt.verify(header.slice(7), ACCESS_SECRET)
    next()
  } catch {
    res.sendStatus(401)
  }
}

// Refresh endpoint с ротацией
app.post('/auth/refresh', (req, res) => {
  const token = req.cookies.refreshToken
  if (!token) return res.sendStatus(401)

  try {
    const payload = jwt.verify(token, REFRESH_SECRET)
    // Инвалидируем старый refresh token в БД
    invalidateToken(payload.jti)
    // Выдаём новую пару
    const tokens = signTokens(payload.sub)
    setRefreshCookie(res, tokens.refreshToken)
    res.json({ accessToken: tokens.accessToken })
  } catch {
    res.clearCookie('refreshToken')
    res.sendStatus(401)
  }
})

function setRefreshCookie(res, token) {
  res.cookie('refreshToken', token, {
    httpOnly: true, secure: true, sameSite: 'strict',
    path: '/auth/refresh', maxAge: 7 * 24 * 60 * 60 * 1000,
  })
}

Как это работает: без CORS-заголовков браузер блокирует любой fetch/XHR-запрос с другого origin, чем у API (классическая ошибка "No 'Access-Control-Allow-Origin' header") — middleware cors добавляет эти заголовки автоматически согласно конфигу, включая обработку preflight-запроса OPTIONS.

import cors from 'cors'

// Quick and open — any origin can call this API
app.use(cors())

// Locked down to specific origins, with credentials (cookies) allowed
app.use(cors({
  origin: ['https://example.com', 'https://app.example.com'],
  credentials: true,
}))

Как это работает: Express не отлавливает автоматически отклонённые промисы внутри async-обработчиков роутов — необработанное отклонение просто "подвешивает" запрос. Оборачивание обработчиков в asyncHandler передаёт любую брошенную/отклонённую ошибку в next(), что направляет её в middleware обработки ошибок с 4 аргументами (Express определяет обработчики ошибок именно по этой сигнатуре).

// Wrap async route handlers so thrown errors reach Express's error handling
function asyncHandler(fn) {
  return (req, res, next) => fn(req, res, next).catch(next)
}

app.get('/users/:id', asyncHandler(async (req, res) => {
  const user = await db.findUser(req.params.id)
  if (!user) {
    const error = new Error('User not found')
    error.status = 404
    throw error
  }
  res.json(user)
}))

// Must be registered LAST, after all other app.use()/routes
app.use((err, req, res, next) => {
  console.error(err)
  res.status(err.status || 500).json({ error: err.message || 'Internal server error' })
})

Сниппет для авторизации роутов в Node.js / Express приложении с использованием библиотеки jsonwebtoken. Включает расширение глобального типа Request в TypeScript, чтобы безопасно обращаться к свойству req.user.

import { Request, Response, NextFunction } from 'express'
import jwt from 'jsonwebtoken'

// 1. Расширение глобального типа Request для TypeScript
declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string
        email: string
        role?: string
      }
    }
  }
}

const JWT_SECRET = process.env.JWT_SECRET || 'your-default-secret-key'

// 2. Middleware функция верификации токена
export function requireAuth(req: Request, res: Response, next: NextFunction) {
  const authHeader = req.headers.authorization

  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({
      error: 'Unauthorized',
      message: 'Access token is missing or malformed'
    })
  }

  const token = authHeader.split(' ')[1]

  try {
    const decoded = jwt.verify(token, JWT_SECRET) as {
      id: string
      email: string
      role?: string
    }
    
    // Записываем payload токена в объект запроса
    req.user = {
      id: decoded.id,
      email: decoded.email,
      role: decoded.role
    }
    
    next()
  } catch (err) {
    return res.status(403).json({
      error: 'Forbidden',
      message: 'Invalid or expired access token'
    })
  }
}

Как это работает: этот лимитер в памяти достаточен для одного инстанса сервера; за балансировщиком нагрузки с несколькими инстансами нужно заменить стандартное хранилище на общее (например, rate-limit-redis), чтобы все инстансы считали в один общий лимит.

import rateLimit from 'express-rate-limit'

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100,                 // 100 requests per IP per window
  standardHeaders: true,    // adds RateLimit-* response headers
  message: { error: 'Too many requests, please try again later.' },
})

app.use('/api/', limiter)

// Stricter limit for a sensitive endpoint
app.post('/api/login', rateLimit({ windowMs: 15 * 60 * 1000, max: 5 }), loginHandler)

Как это работает:

1. replace(/\.[^/.]+$/, '') убирает расширение.
2. replace(/[^a-zA-Z0-9]+/g, '-') заменяет каждую последовательность не-алфанумерических символов на один дефис.
3. replace(/^-+|-+$/g, '') убирает лишние дефисы в начале/конце.

function sanitizeFilename(filename) {
  const nameWithoutExt = filename.replace(/\.[^/.]+$/, '')
  const sanitized = nameWithoutExt
    .replace(/[^a-zA-Z0-9]+/g, '-')
    .replace(/^-+|-+$/g, '')

  return sanitized
}

// Example usage in an Express upload handler
app.post('/upload', upload.single('file'), (req, res) => {
  const safeName = sanitizeFilename(req.file.originalname)
  res.json({ savedAs: `${safeName}${path.extname(req.file.originalname)}` })
})

Как это работает: Prisma Client предоставляет отдельные методы для каждой операции. Каждый запрос типобезопасен — тип возврата выводится из схемы, поэтому обращение к несуществующему полю — ошибка компиляции.

import { PrismaClient } from '@prisma/client'
const prisma = new PrismaClient()

// Создание
const user = await prisma.user.create({
  data: {
    email: '[email protected]',
    name: 'Alice',
    role: 'USER',
  },
})

// Чтение по уникальному полю
const found = await prisma.user.findUnique({
  where: { email: '[email protected]' },
})

// Чтение с фильтром и связями
const admins = await prisma.user.findMany({
  where: { role: 'ADMIN' },
  include: { posts: true },
  orderBy: { createdAt: 'desc' },
})

// Обновление
const updated = await prisma.user.update({
  where: { id: user.id },
  data: { name: 'Alice Smith' },
})

// Upsert — обновить или создать
const upserted = await prisma.user.upsert({
  where: { email: '[email protected]' },
  update: { name: 'Bob' },
  create: { email: '[email protected]', name: 'Bob' },
})

// Удаление
await prisma.user.delete({
  where: { id: user.id },
})

// Количество
const total = await prisma.user.count()
const active = await prisma.user.count({
  where: { role: 'USER' },
})

Как это работает: после изменений в schema.prisma запустите prisma migrate dev, чтобы создать новый файл миграции. CLI генерирует SQL, применяет к локальной БД и создаёт файл с временной меткой — его нужно закоммитить. Команда и продакшен применяют миграции через prisma migrate deploy.

# Создать и применить миграцию после изменений схемы
npx prisma migrate dev --name add-user-role

# Применить ожидающие миграции (CI/CD, продакшен)
npx prisma migrate deploy

# Сброс БД — удалить данные и переприменить все миграции
npx prisma migrate reset

# Статус миграций
npx prisma migrate status

# Создать миграцию без применения (проверить SQL)
npx prisma migrate dev --create-only

# Применить на продакшене
npx prisma migrate deploy

# Если миграции разсинхронизировались:
npx prisma migrate diff --from-empty --to-schema-datamodel prisma/schema.prisma

# Скрипт деплоя на продакшен
npx prisma migrate deploy
npx prisma generate
npx next start

// Пример: добавление нового поля
model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String?
  phone     String?  // ← новое поле
  role      Role     @default(USER) // ← новое поле
}

Как это работает: offset-пагинация использует skip и take — просто, но медленно на глубоких страницах (база сканирует пропущенные строки). Cursor-пагинация использует уникальное значение (id) для старта после конкретной записи — O(1) на страницу и стабильна при вставке новых элементов.

// Offset пагинация — простая, но тормозит на глубоких страницах
const page1 = await prisma.post.findMany({
  skip: 0,
  take: 20,
  orderBy: { createdAt: 'desc' },
})

const page2 = await prisma.post.findMany({
  skip: 20,
  take: 20,
  orderBy: { createdAt: 'desc' },
})

// Cursor пагинация — быстрая и стабильная
const firstPage = await prisma.post.findMany({
  take: 20,
  orderBy: { id: 'asc' },
})

const lastId = firstPage[firstPage.length - 1].id

const secondPage = await prisma.post.findMany({
  take: 20,
  cursor: { id: lastId },
  skip: 1, // пропустить сам курсор
  orderBy: { id: 'asc' },
})

// Cursor с where
const filtered = await prisma.post.findMany({
  take: 20,
  where: { published: true },
  cursor: { id: lastId },
  skip: 1,
  orderBy: { id: 'asc' },
})

// Хелпер для cursor пагинации
async function paginatePosts(cursor?: string, limit = 20) {
  return prisma.post.findMany({
    take: limit + 1,
    ...(cursor ? { cursor: { id: cursor }, skip: 1 } : {}),
    orderBy: { createdAt: 'desc' },
  })
}

Как это работает: схема определяет четыре связанных модели. User имеет много Post и Session; Subscription привязывает пользователя к Stripe-подписке. Enums ограничивают значения статусов, а @@index ускоряет частые запросы.

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

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

enum Role {
  USER
  ADMIN
}

enum SubscriptionStatus {
  ACTIVE
  CANCELED
  PAST_DUE
  EXPIRED
}

model User {
  id             String         @id @default(cuid())
  email          String         @unique
  name           String?
  role           Role           @default(USER)
  posts          Post[]
  sessions       Session[]
  subscription   Subscription?
  createdAt      DateTime       @default(now())
  updatedAt      DateTime       @updatedAt
}

model Post {
  id        String   @id @default(cuid())
  title     String
  content   String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  String
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  @@index([authorId])
  @@index([published, createdAt])
}

model Session {
  id        String   @id @default(cuid())
  userId    String
  user      User     @relation(fields: [userId], references: [id])
  expiresAt DateTime
  createdAt DateTime @default(now())

  @@index([userId])
}

model Subscription {
  id             String             @id @default(cuid())
  userId         String             @unique
  user           User               @relation(fields: [userId], references: [id])
  stripeId       String             @unique
  status         SubscriptionStatus
  currentPeriodEnd DateTime?
  createdAt      DateTime           @default(now())

  @@index([stripeId])
  @@index([status])
}

// Найти пользователя с постами и подпиской
const user = await prisma.user.findUnique({
  where: { email: '[email protected]' },
  include: { posts: true, subscription: true }
})