tech
Defaultdeesfrzh

Drizzle ORM

TypeScript ORM mit SQL-ahnlicher Syntax - typsicher, keine Abhangigkeiten, serverless-ready

TL;DR

Was: TypeScript ORM mit SQL-ähnlicher Syntax und ohne Abhängigkeiten.

Warum: Typsicher, leichtgewichtig, SQL-ähnliche API, großartige DX, serverless-ready.

Quick Start

Installation:

npm install drizzle-orm
npm install -D drizzle-kit
npm install pg  # oder better-sqlite3, mysql2

Schema definieren (src/db/schema.ts):

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

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

Verbinden und abfragen:

import { drizzle } from 'drizzle-orm/node-postgres';
import { Pool } from 'pg';
import { users } from './schema';

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const db = drizzle(pool);

const allUsers = await db.select().from(users);

Cheatsheet

BefehlBeschreibung
npx drizzle-kit generateMigrationen generieren
npx drizzle-kit migrateMigrationen ausführen
npx drizzle-kit pushSchema pushen (ohne Migration)
npx drizzle-kit studioDrizzle Studio öffnen

Gotchas

Schema definition

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

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name').notNull(),
  email: text('email').notNull().unique(),
  age: integer('age'),
  isActive: boolean('is_active').default(true),
  createdAt: timestamp('created_at').defaultNow(),
});

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

CRUD operations

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

// Erstellen
await db.insert(users).values({
  name: 'John',
  email: '[email protected]'
});

// Lesen
const allUsers = await db.select().from(users);
const user = await db.select().from(users).where(eq(users.id, 1));

// Aktualisieren
await db.update(users)
  .set({ name: 'Johnny' })
  .where(eq(users.id, 1));

// Löschen
await db.delete(users).where(eq(users.id, 1));

Filtering and joins

import { eq, and, or, like, gt } from 'drizzle-orm';

// Komplexe Where-Bedingung
const results = await db.select()
  .from(users)
  .where(
    and(
      gt(users.age, 18),
      like(users.email, '%@example.com')
    )
  );

// Join
const postsWithAuthors = await db.select()
  .from(posts)
  .leftJoin(users, eq(posts.authorId, users.id));

// Bestimmte Felder auswählen
const userNames = await db.select({
  id: users.id,
  name: users.name,
}).from(users);

Relations

import { relations } from 'drizzle-orm';

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

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

// Mit Relationen abfragen
const usersWithPosts = await db.query.users.findMany({
  with: {
    posts: true,
  },
});

Configuration (drizzle.config.ts)

import { defineConfig } from 'drizzle-kit';

export default defineConfig({
  schema: './src/db/schema.ts',
  out: './drizzle',
  dialect: 'postgresql',
  dbCredentials: {
    url: process.env.DATABASE_URL!,
  },
});

Next Steps