npm install prisma @prisma/client
npx prisma init

schema.prisma dosyası:

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?
  createdAt DateTime @default(now())
  posts     Post[]
}

model Post {
  id       Int    @id @default(autoincrement())
  title    String
  authorId Int
  author   User   @relation(fields: [authorId], references: [id])
}

Sonra:

npx prisma generate    # TypeScript client üret
npx prisma migrate dev # migration uygula

npm install drizzle-orm postgres
npm install -D drizzle-kit

schema.ts dosyası (doğrudan TypeScript — directly TypeScript):

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

export const users = pgTable('users', {
  id:        serial('id').primaryKey(),
  email:     text('email').notNull().unique(),
  name:      text('name'),
  createdAt: timestamp('created_at').defaultNow(),
});

export const posts = pgTable('posts', {
  id:       serial('id').primaryKey(),
  title:    text('title').notNull(),
  authorId: integer('author_id').references(() => users.id),
});

export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));

Drizzle'da kod jenerasyonu yok — type'lar şemanızdan otomatik infer edilir (types automatically inferred from schema). Migration için drizzle-kit kullanılır.

Prisma

// Tüm kullanıcılar (all users)
const users = await prisma.user.findMany();

// Email ile bul (find by email)
const user = await prisma.user.findUnique({
  where: { email: 'ahmet@example.com' }
});

// İlişkiyle birlikte (with relations)
const userWithPosts = await prisma.user.findUnique({
  where: { id: 1 },
  include: { posts: true }
});

Drizzle

import { eq } from 'drizzle-orm';

// Tüm kullanıcılar
const allUsers = await db.select().from(users);

// Email ile bul
const user = await db.select()
  .from(users)
  .where(eq(users.email, 'ahmet@example.com'));

// İlişkiyle birlikte (query API)
const userWithPosts = await db.query.users.findFirst({
  where: eq(users.id, 1),
  with: { posts: true }
});

Prisma — Limitli SQL Kontrolü

// Prisma çoğu JOIN'i optimize eder ama bazen N+1 sorunu yaşatabilir
const result = await prisma.post.findMany({
  where: { author: { name: { contains: 'Ahmet' } } },
  include: { author: true },
  orderBy: { createdAt: 'desc' },
  take: 10
});

Drizzle — Tam SQL Kontrolü (Full SQL Control)

import { eq, like, desc } from 'drizzle-orm';

const result = await db
  .select({
    postId:    posts.id,
    title:     posts.title,
    authorName: users.name,
  })
  .from(posts)
  .innerJoin(users, eq(posts.authorId, users.id))
  .where(like(users.name, '%Ahmet%'))
  .orderBy(desc(posts.createdAt))
  .limit(10);

import { User, Post } from '@prisma/client';

// Type'lar npx prisma generate ile üretilir
const user: User = await prisma.user.findUnique({ where: { id: 1 } });

Dezavantaj: Schema değişikliği sonrası prisma generate çalıştırmazsanız type'lar güncellenmez (types not updated unless you run prisma generate).

import { InferSelectModel, InferInsertModel } from 'drizzle-orm';
import { users } from './schema';

type User       = InferSelectModel<typeof users>;
type NewUser    = InferInsertModel<typeof users>;

// Type'lar otomatik infer edilir
const newUser: NewUser = { email: 'x@example.com', name: 'X' };

Avantaj: Şema TypeScript olduğu için type değişiklikleri anında reflect olur (changes reflect immediately).

# Schema değişikliği sonrası migration oluştur
npx prisma migrate dev --name add_user_role

# Production deploy
npx prisma migrate deploy

Prisma migration'ları otomatik versionlanır (auto-versioned), shadow database ile diff hesaplanır. Kolay ama bazen istenmeyen DDL üretebilir (sometimes generates unwanted DDL).

# Migration generate (schema diff'ten)
npx drizzle-kit generate

# Migration'ı çalıştır
npx drizzle-kit migrate

# Drizzle Studio (görsel arayüz — visual UI)
npx drizzle-kit studio

Drizzle Kit, schema TypeScript'ten SQL migration üretir. Üretilen SQL dosyaları manuel düzenlenebilir (can be manually edited) — Prisma'ya göre daha fazla kontrol (more control).