Files

T

Antigravity Agent 93ec7e9056 [G1-Sync] Manual knowledge update

2026-05-09 21:08:02 +09:00

5.6 KiB

Raw Blame History

id, title, category, status, source_trust_level, verification_status, created_at, updated_at, tags, tech_stack, applied_in, aliases

title

ORM 비교

Prisma = 강 type 안전 + DX, Drizzle = 가볍고 SQL 그대로, Kysely = pure query builder, TypeORM = 옛 ActiveRecord. 추천 = Drizzle (modern) 또는 Prisma (DX).

📖 핵심 개념

ORM: object 매핑.
Query builder: SQL 같은 chained API.
Type-safe: schema → type infer.
Migration: schema 변경 자동 SQL.

💻 코드 패턴

Prisma

// schema.prisma
model User {
  id    String  @id @default(uuid())
  email String  @unique
  posts Post[]
}

model Post {
  id     String @id @default(uuid())
  title  String
  userId String
  user   User   @relation(fields: [userId], references: [id])
}

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

const u = await prisma.user.findUnique({
  where: { id },
  include: { posts: true },
});

await prisma.user.create({
  data: { email, posts: { create: [{ title: 'first' }] } },
});

await prisma.user.update({
  where: { id }, data: { email: newEmail },
});

→ Pros: 강 type, migration 자동. Cons: query engine binary, 일부 제약.

Drizzle (modern, SQL-style)

import { pgTable, uuid, text, integer } from 'drizzle-orm/pg-core';

export const users = pgTable('users', {
  id: uuid('id').primaryKey().defaultRandom(),
  email: text('email').unique().notNull(),
});

export const posts = pgTable('posts', {
  id: uuid('id').primaryKey().defaultRandom(),
  title: text('title').notNull(),
  userId: uuid('user_id').references(() => users.id),
});

import { drizzle } from 'drizzle-orm/node-postgres';
import { eq } from 'drizzle-orm';

const db = drizzle(pool);

const result = await db.select().from(users).where(eq(users.id, id));

await db.insert(users).values({ email });

await db.update(users).set({ email: newEmail }).where(eq(users.id, id));

// Joined
const result = await db
  .select()
  .from(users)
  .leftJoin(posts, eq(users.id, posts.userId))
  .where(eq(users.id, id));

→ Pros: 가볍고 빠름, SQL 그대로. Cons: 약간 verbose.

Kysely (pure query builder)

import { Kysely, PostgresDialect } from 'kysely';

interface DB {
  users: { id: string; email: string };
  posts: { id: string; title: string; user_id: string };
}

const db = new Kysely<DB>({ dialect: new PostgresDialect({ pool }) });

const u = await db.selectFrom('users').where('id', '=', id).selectAll().executeTakeFirst();

await db.insertInto('users').values({ id: uuid(), email }).execute();

const joined = await db
  .selectFrom('users')
  .leftJoin('posts', 'posts.user_id', 'users.id')
  .where('users.id', '=', id)
  .selectAll()
  .execute();

→ Pros: SQL 정확 매핑, 매우 typed. Cons: schema 직접 정의.

TypeORM (옛, ActiveRecord)

@Entity()
class User {
  @PrimaryGeneratedColumn('uuid') id!: string;
  @Column({ unique: true }) email!: string;
  @OneToMany(() => Post, p => p.user) posts!: Post[];
}

const u = await User.findOne({ where: { id }, relations: ['posts'] });

→ 옛 design, 새 프로젝트 권장 X.

Migration 비교

# Prisma
prisma migrate dev --name add_user_email
prisma migrate deploy

# Drizzle
drizzle-kit generate
drizzle-kit migrate

# Kysely
# 직접 SQL 파일 + kysely-codegen 으로 type

Transaction

// Prisma
await prisma.$transaction(async (tx) => {
  await tx.user.create({...});
  await tx.post.create({...});
});

// Drizzle
await db.transaction(async (tx) => {
  await tx.insert(users).values(...);
});

// Kysely
await db.transaction().execute(async (tx) => {
  await tx.insertInto('users').values(...).execute();
});

Raw SQL (escape hatch)

// Prisma
const result = await prisma.$queryRaw<User[]>`SELECT * FROM users WHERE name LIKE ${pattern}`;

// Drizzle
import { sql } from 'drizzle-orm';
const r = await db.execute(sql`SELECT * FROM users WHERE name LIKE ${pattern}`);

// Kysely
const r = await sql<User[]>`SELECT * FROM users WHERE name LIKE ${pattern}`.execute(db);

Connection pool

// 모두 공통: pg / mysql 의 Pool wrap
import { Pool } from 'pg';
const pool = new Pool({ connectionString, max: 20 });

Edge runtime

Drizzle: HTTP driver (Neon / PlanetScale) 가벼움. Edge OK.
Prisma: Accelerate / Data Proxy 필요. 기본은 binary (Edge X).
Kysely: HTTP driver 호환.

🤔 의사결정 기준

상황	추천
빠른 시작 + DX	Prisma
Edge runtime	Drizzle / Kysely
가벼운 + SQL 명확	Drizzle
Pure query builder	Kysely
매우 작은 bundle	Drizzle
큰 schema + relation 복잡	Prisma 또는 Drizzle
옛 시스템 유지	TypeORM

❌ 안티패턴

N+1 ORM: include 안 쓰고 loop 안 쿼리. Prisma include / Drizzle leftJoin.
모든 column SELECT: select 명시.
Connection pool 매번 새로: lazy singleton.
Migration 수동 prod: drift. CI 에서 auto.
Transaction 안 외부 API: 롤백 시 부수효과만 남음.
Raw SQL string concat: SQL injection. parameterized.
Schema 두 곳 (.prisma + ts type): drift. infer.

🤖 LLM 활용 힌트

새 프로젝트 = Drizzle 또는 Prisma.
Edge / serverless = Drizzle (Neon HTTP).
Prisma = DX 우월하지만 binary.

5.6 KiB Raw Blame History