Drizzle ORM用于 SQL 数据库的 TypeScript ORM

Drizzle ORM 是用于 SQL 数据库的 TypeScript ORM，在设计时考虑到了最大的类型安全性。它带有用于自动生成 SQL 迁移的 drizzle-kit CLI 。

Drizzle ORM 是一个库，而不是一个框架，它的主要哲学是“如果你知道 SQL，你就知道 Drizzle ORM”，因此设计的时候尽可能遵循类似 SQL 的语法，强类型化并在编译时就会失败，而不是在运行时。

功能列表

• 全类型安全


• 智能自动迁移生成


• 没有 ORM 学习曲线


• 用于表定义和查询的类似于 SQL 的语法


• 一流的全类型连接


• 任何复杂性的全类型部分和非部分选择


• 自动推断 DB 模型的 TS 类型以分别选择和插入


• Zod 架构生成


• 零依赖

支持的数据库

安装

npm install drizzle-orm

npm install -D drizzle-kit

功能展示 (PostgreSQL)

注意：不要忘记安装 pg 和 @types/pg 包。

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

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

import { InferModel, eq, sql } from 'drizzle-orm';

import { Pool } from 'pg';



export const users = pgTable('users', {

  id: serial('id').primaryKey(),

  fullName: text('full_name').notNull(),

  phone: varchar('phone', { length: 20 }).notNull(),

  role: text('role', { enum: ['user', 'admin'] }).default('user').notNull(),

  cityId: integer('city_id').references(() => cities.id),

  createdAt: timestamp('created_at').defaultNow().notNull(),

  updatedAt: timestamp('updated_at').defaultNow().notNull(),

});



export type User = InferModel<typeof users>;

export type NewUser = InferModel<typeof users, 'insert'>;



export const cities = pgTable('cities', {

  id: serial('id').primaryKey(),

  name: text('name').notNull(),

});



export type City = InferModel<typeof cities>;

export type NewCity = InferModel<typeof cities, 'insert'>;



const pool = new Pool({

  connectionString: 'postgres://user:password@host:port/db',

});



const db = drizzle(pool);



// Insert

const newUser: NewUser = {

  fullName: 'John Doe',

  phone: '+123456789',

};

const insertedUsers /* : User[] */ = await db.insert(users).values(newUser).returning();

const insertedUser = insertedUsers[0]!;



const newCity: NewCity = {

  name: 'New York',

};

const insertedCities /* : City[] */ = await db.insert(cities).values(newCity).returning();

const insertedCity = insertedCities[0]!;



// Update

const updateResult /* : { updated: Date }[] */ = await db.update(users)

  .set({ cityId: insertedCity.id, updatedAt: new Date() })

  .where(eq(users.id, insertedUser.id))

  .returning({ updated: users.updatedAt });



// Select

const allUsers /* : User[] */ = await db.select().from(users);



// Select custom fields

const upperCaseNames /* : { id: number; name: string }[] */ = await db

  .select({

    id: users.id,

    name: sql<string>`upper(${users.fullName})`,

  })

  .from(users);



// Joins

// You wouldn't BELIEVE how SMART the result type is! 😱

const allUsersWithCities = await db

  .select({

    id: users.id,

    name: users.fullName,

    city: {

      id: cities.id,

      name: cities.name,

    },

  })

  .from(users)

  .leftJoin(cities, eq(users.cityId, cities.id));



// Delete

const deletedNames /* : { name: string }[] */ = await db.delete(users)

  .where(eq(users.id, insertedUser.id))

  .returning({ name: users.fullName });