Prisma에서 Drizzle ORM으로 — 번들 사이즈·엣지 호환성·Raw SQL 타입 안전성 차이와 프로덕션 마이그레이션 전략

// Drizzle 스키마 정의 — 순수한 TypeScript 파일
import { pgTable, serial, text, timestamp, decimal } from 'drizzle-orm/pg-core'
 
export const orders = pgTable('orders', {
  id: serial('id').primaryKey(),
  userId: text('user_id').notNull(),
  amount: decimal('amount', { precision: 10, scale: 2 }).notNull(),
  createdAt: timestamp('created_at').defaultNow(),
})

// Prisma 스키마 정의 — 전용 DSL 파일
model Order {
  id        Int      @id @default(autoincrement())
  userId    String
  amount    Decimal
  createdAt DateTime @default(now())
}

// Cloudflare Workers + Neon Postgres
import { drizzle } from 'drizzle-orm/neon-http'
import { neon } from '@neondatabase/serverless'
 
// HTTP 기반 연결 — Node.js net/tls 모듈 불필요
const sql = neon(env.DATABASE_URL)
const db = drizzle(sql)

// Cloudflare D1 (Workers 내장 SQLite)
import { drizzle } from 'drizzle-orm/d1'
const db = drizzle(env.DB)

// 반환 타입을 제네릭으로 수동 지정
const result = await db.execute(
  sql<{ count: number; revenue: string }>`
    SELECT COUNT(*) as count, SUM(amount) as revenue
    FROM ${orders}
    WHERE created_at > ${startDate}
  `
)
// result는 { count: number; revenue: string }[] 타입
 
// 쿼리 빌더와 Raw SQL 혼합도 가능
const complexQuery = await db
  .select({
    id: users.id,
    postCount: sql<number>`COUNT(${posts.id})`,
  })
  .from(users)
  .leftJoin(posts, eq(posts.userId, users.id))
  .groupBy(users.id)

-- prisma/sql/getOrderStats.sql
SELECT COUNT(*) as count, SUM(amount) as revenue
FROM "Order"
WHERE created_at > $1

// prisma generate 후 자동 생성된 타입으로 호출
import { getOrderStats } from '@prisma/client/sql'
 
const result = await prisma.$queryRawTyped(getOrderStats(startDate))
// 완전 자동 타입 추론 — 수동 지정 불필요

// Hono + Drizzle + Neon (Cloudflare Workers)
import { Hono } from 'hono'
import { drizzle } from 'drizzle-orm/neon-http'
import { neon } from '@neondatabase/serverless'
import { orders } from './schema'
import { eq, desc } from 'drizzle-orm'
 
type Bindings = {
  DATABASE_URL: string
}
 
const app = new Hono<{ Bindings: Bindings }>()
 
app.get('/orders/:userId', async (c) => {
  const sql = neon(c.env.DATABASE_URL)
  const db = drizzle(sql)
 
  const userOrders = await db
    .select()
    .from(orders)
    .where(eq(orders.userId, c.req.param('userId')))
    .orderBy(desc(orders.createdAt))
    .limit(20)
 
  return c.json(userOrders)
})
 
export default app

// Prisma — include로 관계 조회, 중첩 객체 반환
const postsWithAuthor = await prisma.post.findMany({
  include: {
    author: { select: { id: true, name: true } }
  },
  where: { published: true }
})
// 반환 구조: { id, title, author: { id, name } }
 
// Drizzle select join — 평탄한 객체 반환 (구조가 다름!)
const postsWithAuthor = await db
  .select({
    id: posts.id,
    title: posts.title,
    authorId: users.id,
    authorName: users.name,
  })
  .from(posts)
  .innerJoin(users, eq(posts.authorId, users.id))
  .where(eq(posts.published, true))
// 반환 구조: { id, title, authorId, authorName } — 중첩 없음
 
// Prisma include와 동일한 중첩 구조를 원하면 relational query API 사용
const postsWithAuthor = await db.query.posts.findMany({
  where: eq(posts.published, true),
  with: {
    author: { columns: { id: true, name: true } }
  }
})
// 반환 구조: { id, title, author: { id, name } }

# drizzle.config.ts 설정 후 실행
npx drizzle-kit introspect

import { PrismaClient } from '@prisma/client'
import { drizzle } from 'drizzle-orm/postgres-js'
import postgres from 'postgres'
import { eq, desc } from 'drizzle-orm'
import * as schema from './drizzle/schema'
 
const prisma = new PrismaClient()
const queryClient = postgres(process.env.DATABASE_URL!)
const db = drizzle(queryClient, { schema })
 
// 새로 작성하는 쿼리는 Drizzle로
export async function getRecentOrders(userId: string) {
  return db
    .select()
    .from(schema.orders)
    .where(eq(schema.orders.userId, userId))
    .orderBy(desc(schema.orders.createdAt))
}
 
// 기존 Prisma 쿼리는 건드리지 않고 유지
export async function getUserProfile(id: string) {
  return prisma.user.findUnique({ where: { id } })
}

// Prisma 기본 테이블명은 PascalCase
// Drizzle 전환 시 반드시 동일한 이름 사용
export const users = pgTable('User', {  // 'user' 아님
  id: text('id').primaryKey(),
  name: text('name').notNull(),
})

import { createId } from '@paralleldrive/cuid2'
 
export const posts = pgTable('Post', {
  // Prisma의 @default(cuid()) 대체
  id: text('id').primaryKey().$defaultFn(() => createId()),
  title: text('title').notNull(),
})

export const posts = pgTable('Post', {
  id: text('id').primaryKey(),
  title: text('title').notNull(),
  updatedAt: timestamp('updated_at')
    .defaultNow()
    .$onUpdate(() => new Date()),
})
 
// $onUpdate를 설정하지 않은 컬럼은 UPDATE마다 명시적으로 지정
await db
  .update(posts)
  .set({ title: newTitle, updatedAt: new Date() })
  .where(eq(posts.id, postId))

import Decimal from 'decimal.js'
 
const order = await db.select().from(orders).where(eq(orders.id, 1))
 
// string → Decimal 객체로 변환 후 연산 (정밀도 유지)
const amount = new Decimal(order[0].amount)
const withTax = amount.mul(1.1).toFixed(2)
 
// 단순 표시 목적이라면 parseFloat도 가능하지만 금융 계산에는 적합하지 않음