typescript

TypeScript 数据访问层：Prisma、Drizzle 与类型安全 ORM

系统覆盖 TypeScript 下类型安全 ORM 的完整选型与实践：Prisma schema 驱动与类型生成、Drizzle 的 SQL 式类型推导、TypeORM 装饰器风格、数据库迁移与 schema 演进、查询构造的类型推导机制、类型化查询与 raw SQL 的边界取舍、事务与连接池的工程实践，以及 N+1、索引、预编译等性能基准，帮助开发者选出并用好适合自己项目的类型安全数据访问层。

spcent 6 分钟阅读 2980 字

引言

数据访问层是类型安全的重灾区：raw SQL 返回 any、ORM 查询对象丢类型、迁移与代码不同步到运行期才炸。Prisma、Drizzle、TypeORM 三家的类型哲学差异很大——Prisma 用 schema 生成类型，Drizzle 让类型跟着 SQL 走，TypeORM 靠装饰器反射。本文讲透三家类型机制、迁移策略、查询推导原理，再落到事务、连接池、N+1 与性能基准这些真实工程问题，帮你选出「类型最不塌方」的组合。

前置：/typescript-nodejs-backend/（Node 服务端）、/typescript-runtime-validation-typesafe/（运行时校验）、/typescript-generic-api-design-performance/（泛型与性能）。

目录

1. 类型安全 ORM 的选型地图

三家核心差异决定选型：

维度PrismaDrizzleTypeORM
类型来源schema.prisma 生成SQL 模板类型推导实体类装饰器
学习曲线中（schema DSL）低（贴近 SQL）中（装饰器）
迁移工具内置 migratedrizzle-kit内置 migration
与 SQL 距离远（抽象高）近中
适合场景schema 即契约追求 SQL 控制力ActiveRecord 偏好

选型建议：团队想让数据库结构成为唯一类型真相 → Prisma；熟悉 SQL 又不想学 DSL → Drizzle；遗留项目在用/偏爱 Active Record → TypeORM；查询全是窗口函数/CTE → raw SQL + 手动类型（§7）。别用「类型看着安全」却 any 化的查询库——类型安全 = 编译期检查 + 运行期行为一致。

2. Prisma：schema 驱动的类型生成

模型定义在 schema.prisma，prisma generate 生成类型安全客户端：

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
  posts     Post[]
}
model Post {
  id        Int      @id @default(autoincrement())
  title     String
  author    User     @relation(fields: [authorId], references: [id])
  authorId  Int
}

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

const user = await prisma.user.create({ data: { email: "a@b.com", name: "Ada" } });
user.name;             // ✅ string
user.nonExistent;      // ❌ 编译错误

const posts = await prisma.post.findMany({
  where: { authorId: user.id },
  include: { author: true },   // 关系类型内联
});
posts[0].author.name; // ✅ 关联实体类型存在

要点：prisma generate 挂 postinstall（CI clone 后即用）；Prisma.UserWhereInput 等类型可当 DTO 用，配 zod 校验入站；select 投影会收窄返回类型，比宽返回安全。坑：改 schema 忘 generate 会类型漂移，把它挂进 prebuild/pretest 强制刷新。

3. Drizzle：轻量 SQL 式类型推导

Drizzle 不生成代码，让 SQL 模板的类型推导落到 TS 泛型：

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

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

const rows = await db.select().from(users).where(eq(users.email, "a@b.com"));
rows[0].email; // ✅ string
rows[0].posts; // ❌ 表里没有这个字段

关系查询用 relations + db.query：

export const userRelations = relations(users, ({ many }) => ({ posts: many(posts) }));
const u = await db.query.users.findFirst({ where: eq(users.id, 1), with: { posts: true } });
u?.posts[0].title; // ✅ 类型推导

要点：表定义即类型真相，无 generate 步骤；运算符贴近原生（eq/gt/isNull/inArray）；$inferSelect/$inferInsert 标注 SQL 模板类型。坑：跨库迁移要换 pg-core 为 mysql-core 对应 API，方言不通。

4. TypeORM 与 ActiveRecord 风格

实体类 + 装饰器定义模型，支持 Active Record 与 Repository 两种模式：

import { Entity, PrimaryGeneratedColumn, Column, OneToMany, CreateDateColumn, BaseEntity } from "typeorm";

@Entity("users")
export class User extends BaseEntity {
  @PrimaryGeneratedColumn() id!: number;
  @Column({ unique: true }) email!: string;
  @Column() name!: string;
  @CreateDateColumn() createdAt!: Date;
  @OneToMany(() => Post, (p) => p.author) posts!: Post[];
}

// Active Record：实体自带静态查询
const ada = await User.findOneBy({ email: "a@b.com" });
await User.update({ id: ada.id }, { name: "Ada L." });

Repository 风格利于 DI 与测试：

const dataSource = new DataSource({ type: "postgres", entities: [User, Post], synchronize: false });
await dataSource.initialize();
const user = await dataSource.getRepository(User).findOne({ where: { id: 1 }, relations: { posts: true } });

要点与坑：! 非空断言是装饰器风格的类型代价（编译期 undefined、运行时 ORM 填充）；生产禁止 synchronize: true（按实体 diff 自动改表，不可控）；relations 不写就是空，极易 N+1（§9）。

5. 迁移与 schema 演进

迁移是「数据库结构与代码类型」同步的唯一可靠手段：

prisma migrate dev --name add_post_published   # Prisma：diff 生成迁移
drizzle-kit generate                           # Drizzle：schema → SQL
npm run typeorm migration:generate -- -d src/db/ds.ts src/migrations/AddPublished  # TypeORM

核心纪律：迁移是唯一变更渠道，任何手改数据库都要回写为迁移；生成后审查 SQL——自动迁移可能带 DROP；迁移按序执行，生产用 prisma migrate deploy（不带 dev）；已有数据的表加 NOT NULL 列必失败——先加可空列、回填、再改非空，三家通用。

6. 查询构造的类型推导

理解「类型为什么能推导」是正确使用的前提。核心机制是泛型约束 + 字面量类型收窄：

// Prisma：where 对象所有字段被编译器检查
const where: Prisma.PostWhereInput = { title: { contains: "TS" } };
where.typo; // ❌ 不存在字段

// Drizzle：select 投影收窄返回类型
const q = db.select({ id: users.id, email: users.email }).from(users)
  .where(and(eq(users.email, "x@y.z"), gte(users.id, 1)));
// q 的类型 = { id: number; email: string }[]

关键理解：字段名是字面量类型，SQL 生成器与类型检查共用同一来源；投影决定返回（select 显式投影时返回跟着走）；动态拼接 where 会宽化返回类型，用 satisfies 或显式类型稳住。坑：别把查询对象 any 化传进函数，类型推导在此断裂。

7. 类型化查询 vs raw SQL 的边界

再强的 ORM 压不住复杂 SQL。边界策略：常规 CRUD 用 ORM，报表/复杂查询用 raw SQL + 手动类型：

const rows = await prisma.$queryRaw<{ month: string; total: number }>`
  SELECT to_char(created_at, 'YYYY-MM') AS month, COUNT(*) AS total
  FROM orders GROUP BY month ORDER BY month
`;
rows[0].total; // ✅ number
rows[0].typo;  // ❌ 编译错误

$queryRaw<T> 与 Drizzle 的 sql<T> 都支持模板参数化（防注入），绝不用字符串拼接：

const safe = await prisma.$queryRaw<{ id: number }[]>
  `SELECT id FROM users WHERE email = ${email}`; // 参数化

判断清单：CRUD、关系加载、分页、单表过滤用 ORM；窗口函数、CTE、聚合、复杂 join 用 raw SQL；两者之间用 ORM 的 raw 逃生舱。坑：raw SQL 类型是你的「承诺」，与真实列名不符时编译期不提醒——投影别名对齐类型，测试里跑真实库。

8. 事务与连接池

事务保原子性，连接池保并发复用：

// Prisma 交互式事务
await prisma.$transaction(async (tx) => {
  const user = await tx.user.create({ data: { email: "a@b.com", name: "Ada" } });
  await tx.post.create({ data: { title: "T", authorId: user.id } });
});

// Drizzle
await db.transaction(async (tx) => {
  await tx.insert(users).values({ email: "a@b.com", name: "Ada" });
});

// TypeORM
await dataSource.transaction(async (em) => {
  await em.insert(User, { email: "a@b.com", name: "Ada" });
});

连接池要点：Prisma 在 DATABASE_URL 加 connection_limit/pool_timeout 调参；Drizzle/TypeORM 传 pg 驱动 pool.max；池大小 ≈ CPU 核数 × 2 + 1，不是越大越好；事务内禁做外部 HTTP 慢调用（长时间持有连接是池耗尽的头号原因）。坑：事务回调里用全局连接而非事务句柄 tx 会绕过事务边界，读到不一致——事务内一律用 tx。

9. 性能与基准：N+1、索引与预编译

ORM 经典性能坑是 N+1：主记录 1 次 + 每条子记录再查一次。

// ❌ N+1：100 用户 → 1 次主查 + 100 次 posts 查
for (const u of await prisma.user.findMany())
  await prisma.post.findMany({ where: { authorId: u.id } });

// ✅ 预加载：include 一次 join
const withPosts = await prisma.user.findMany({ include: { posts: true } });

性能清单：include/relations/with 预加载防 N+1；select 投影只选所需列；take/skip 或游标分页；where 常用列建索引，EXPLAIN ANALYZE 验证；高频同构查询用预编译（Drizzle prepared）；批量 upsert 用 INSERT ... ON CONFLICT 替代 N 次操作。坑：include 过深会出巨型 join 与重复列，关系超两层拆多次查询在应用层组装。

10. 速查表与一句话记忆

场景推荐方案
schema 驱动类型Prisma + prisma generate
贴近 SQL 的类型安全Drizzle + SQL 模板
Active Record 风格TypeORM + BaseEntity
表结构变更迁移工具 + 审查 SQL + 回填
复杂报表/CTEraw SQL + 手动类型 + 参数化
原子操作$transaction / db.transaction
关系预加载include/relations/with，防 N+1
高频查询预编译 + 索引 + EXPLAIN 验证

一句话记忆：类型安全数据层 = 单一真相（schema/表定义）+ 投影收窄（select 决定返回）+ 迁移纪律（diff 审查 + 回填）+ 事务用句柄（tx 贯穿）+ 性能三连（预加载 / 索引 / 预编译）——ORM 是「让数据库结构进入类型系统」的桥梁。

延伸阅读

  • /typescript-nodejs-backend/ — Node 服务端与数据库集成
  • /typescript-runtime-validation-typesafe/ — 入站数据运行时校验
  • /typescript-generic-api-design-performance/ — 泛型 API 设计与性能
  • /typescript-zod-validation/ — 与 ORM 配合的入站校验
  • /typescript-error-handling-result/ — 数据库错误的 Result 建模
  • PostgreSQL 专题 — SQL 优化、索引与 EXPLAIN

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「typescript」更多文章

  1. TypeScript 应用安全加固：依赖、注入与敏感信息防护
  2. TypeScript Monorepo 工程化：pnpm、Turborepo 与多包协作
  3. Node.js Worker Threads：TypeScript 并行计算实战