Prisma ORM 실전 튜토리얼 — PostgreSQL 연결, 스키마 마이그레이션, Next.js 라우트 구현까지

로컬 PostgreSQL 컨테이너 실행 (도커)
docker run -d \
  --name prisma-demo \
  -e POSTGRES_USER=myuser \
  -e POSTGRES_PASSWORD=mypassword \
  -e POSTGRES_DB=mydb \
  -p 5432:5432 \
  postgres:15-alpine

Node.js 프로젝트 초기화 및 Prisma 설치
mkdir prisma-tutorial && cd prisma-tutorial
npm init -y
npm install prisma @prisma/client
npm install -D typescript ts-node @types/node
npx tsc --init

# Prisma 초기화 (PostgreSQL 선택)
npx prisma init --datasource-provider postgresql

.env — DATABASE_URL 설정
DATABASE_URL="postgresql://myuser:mypassword@localhost:5432/mydb?schema=public"

prisma/schema.prisma — User, Post 모델 정의
generator client {
  provider = "prisma-client-js"
}

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

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

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

개발 환경 마이그레이션 실행
# 마이그레이션 파일 생성 및 데이터베이스 적용
npx prisma migrate dev --name init

# 예상 출력:
# Applying migration 20260708000000_init
# Your database is now in sync with your schema.
# Generated Prisma Client

# 마이그레이션 상태 확인
npx prisma migrate status

# Prisma Studio 실행 (브라우저 GUI — localhost:5555)
npx prisma studio

src/index.ts — 기본 CRUD 실습
import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient()

async function main() {
  // 1. 사용자 생성
  const user = await prisma.user.create({
    data: {
      email: 'dev@example.com',
      name: '김개발',
    },
  })
  console.log('생성된 사용자:', user)

  // 2. 포스트 생성 (관계 연결)
  const post = await prisma.post.create({
    data: {
      title: 'Prisma 입문',
      content: 'Prisma로 데이터베이스를 다루는 방법',
      published: true,
      author: { connect: { id: user.id } },
    },
  })
  console.log('생성된 포스트:', post)

  // 3. 사용자 + 관련 포스트 조회
  const userWithPosts = await prisma.user.findUnique({
    where: { email: 'dev@example.com' },
    include: { posts: true },
  })
  console.log('사용자+포스트:', JSON.stringify(userWithPosts, null, 2))

  // 4. 포스트 수정
  const updated = await prisma.post.update({
    where: { id: post.id },
    data: { title: 'Prisma 입문 (개정판)' },
  })
  console.log('수정:', updated.title)

  // 5. 포스트 삭제
  await prisma.post.delete({ where: { id: post.id } })
  console.log('삭제 완료')
}

main()
  .catch(console.error)
  .finally(() => prisma.$disconnect())

npx ts-node src/index.ts

관계형 쿼리 패턴 — include, select, 중첩 생성, 페이지네이션
// 발행된 포스트가 있는 사용자 목록
const activeUsers = await prisma.user.findMany({
  where: {
    posts: { some: { published: true } },
  },
  include: {
    posts: {
      where: { published: true },
      orderBy: { createdAt: 'desc' },
      take: 5,
    },
  },
})

// 필요한 필드만 select (포스트 수 집계 포함)
const emailList = await prisma.user.findMany({
  select: {
    id: true,
    email: true,
    name: true,
    _count: { select: { posts: true } },
  },
})

// 중첩 생성 — 사용자 + 포스트 한 번에
const newUser = await prisma.user.create({
  data: {
    email: 'newuser@example.com',
    name: '이신규',
    posts: {
      create: [
        { title: '첫 번째 글', published: true },
        { title: '두 번째 글 (초안)', published: false },
      ],
    },
  },
  include: { posts: true },
})

// 오프셋 기반 페이지네이션 (페이지 3, 페이지당 10개)
const page3 = await prisma.post.findMany({
  where: { published: true },
  skip: 20,
  take: 10,
  orderBy: { createdAt: 'desc' },
})

// 커서 기반 (마지막으로 본 항목 ID 기준)
const nextPage = await prisma.post.findMany({
  take: 10,
  skip: 1, // 커서 자체는 결과에서 제외
  cursor: { id: lastSeenId },
  orderBy: { id: "asc" },
})

lib/prisma.ts — 싱글톤 Prisma Client (Next.js 필수 패턴)
import { PrismaClient } from '@prisma/client'

const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined
}

export const prisma =
  globalForPrisma.prisma ??
  new PrismaClient({
    log:
      process.env.NODE_ENV === 'development'
        ? ['query', 'error', 'warn']
        : ['error'],
  })

if (process.env.NODE_ENV !== 'production') {
  globalForPrisma.prisma = prisma
}

app/api/posts/route.ts — GET, POST API 구현
import { NextRequest, NextResponse } from 'next/server'
import { prisma } from '@/lib/prisma'

// GET /api/posts?page=1
export async function GET(request: NextRequest) {
  const { searchParams } = new URL(request.url)
  const page = Number(searchParams.get('page') ?? '1')
  const limit = 10

  const [posts, total] = await Promise.all([
    prisma.post.findMany({
      where: { published: true },
      include: { author: { select: { name: true } } },
      orderBy: { createdAt: 'desc' },
      skip: (page - 1) * limit,
      take: limit,
    }),
    prisma.post.count({ where: { published: true } }),
  ])

  return NextResponse.json({
    posts,
    pagination: {
      page,
      limit,
      total,
      totalPages: Math.ceil(total / limit),
    },
  })
}

// POST /api/posts
export async function POST(request: NextRequest) {
  const body = await request.json()
  const { title, content, authorId } = body

  if (!title || !authorId) {
    return NextResponse.json(
      { error: 'title과 authorId는 필수입니다' },
      { status: 400 }
    )
  }

  const post = await prisma.post.create({
    data: { title, content, authorId },
    include: { author: { select: { name: true, email: true } } },
  })

  return NextResponse.json(post, { status: 201 })
}

// package.json
{
  "scripts": {
    "postinstall": "prisma generate",
    "db:migrate": "prisma migrate deploy"
  }
}