Drizzle ORM

# Drizzle ORM

## Install
```bash
npm install drizzle-orm postgres
npm install -D drizzle-kit
```

## Schema definition
```ts
import { pgTable, serial, text, integer, boolean, timestamp } from 'drizzle-orm/pg-core'
import { relations } from 'drizzle-orm'

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

export const posts = pgTable('posts', {
  id: serial('id').primaryKey(),
  title: text('title').notNull(),
  published: boolean('published').default(false),
  authorId: integer('author_id').references(() => users.id, { onDelete: 'cascade' }),
})

export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}))
export const postsRelations = relations(posts, ({ one }) => ({
  author: one(users, { fields: [posts.authorId], references: [users.id] }),
}))
```

## drizzle.config.ts
```ts
import { defineConfig } from 'drizzle-kit'
export default defineConfig({
  schema: './src/db/schema.ts',
  out: './drizzle',
  dialect: 'postgresql',
  dbCredentials: { url: process.env.DATABASE_URL! },
})
```
```bash
npx drizzle-kit generate  # generate migration
npx drizzle-kit migrate   # apply
npx drizzle-kit studio    # GUI
```

## Queries
```ts
import { db } from './db'
import { users, posts } from './schema'
import { eq, and, like, desc, count } from 'drizzle-orm'

// Select
const all = await db.select().from(users)
const user = await db.select().from(users).where(eq(users.id, 1))

// With relations
const withPosts = await db.query.users.findMany({
  with: { posts: { where: eq(posts.published, true) } },
  orderBy: desc(users.createdAt),
  limit: 10,
})

// Insert
const [newUser] = await db.insert(users).values({ name: 'A', email: 'a@b.c' }).returning()

// Update
await db.update(users).set({ name: 'B' }).where(eq(users.id, 1))

// Delete
await db.delete(users).where(eq(users.id, 1))
```

## Transactions
```ts
await db.transaction(async (tx) => {
  const [user] = await tx.insert(users).values({ ... }).returning()
  await tx.insert(posts).values({ authorId: user.id, ... })
})
```

## Serverless / Edge (Neon, Turso)
```ts
import { neon } from '@neondatabase/serverless'
import { drizzle } from 'drizzle-orm/neon-http'
const sql = neon(process.env.DATABASE_URL!)
export const db = drizzle(sql, { schema })
```