What a rename breaks: six TypeScript ORMs

Sep 21, 2026

You pick a TypeScript ORM also for the type safety, right? Then press F2, the editor renames what it can see (automatically), and the rest of the schema quietly keeps the old name (unsynced).

One model, 19 places that name three of its members: indexes, both sides of a relation, a check constraint, a projection, raw SQL in a filter.

I pressed F2 on emailAddress to email, employerId to workplaceId, employer to workplace in each and counted what got left behind.

1
import { count, eq, relations, type SQL, sql } from 'drizzle-orm';
2
import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
3
import {
4
  check,
5
  index,
6
  integer,
7
  pgTable,
8
  serial,
9
  text,
10
  uniqueIndex,
11
} from 'drizzle-orm/pg-core';
12

13
export const companies = pgTable('Company', { id: serial().primaryKey() });
14

15
export const users = pgTable(
16
  'User',
17
  {
18
    id: serial().primaryKey(),
19
    emailAddress: text().notNull(),
20
    employerId: integer().references(() => companies.id),
21
    // Generated column
22
    emailLower: text().generatedAlwaysAs(
23
      (): SQL => sql`lower(${users.emailAddress})`,
24
    ),
25
  },
26
  (t) => [
27
    // Index on the field
28
    index().on(t.emailAddress),
29
    // Composite unique index
30
    uniqueIndex().on(t.emailAddress, t.employerId),
31
    // Covering index column | n/a: Drizzle's index builder has no INCLUDE
32
    // Expression index
33
    index().on(sql`lower(${t.emailAddress})`),
34
    // Partial index condition
35
    index()
36
      .on(t.employerId)
37
      .where(sql`${t.emailAddress} <> ''`),
38
    // Check constraint
39
    check('address_present', sql`${t.emailAddress} <> ''`),
40
  ],
41
);
42

43
export const usersRelations = relations(users, ({ one }) => ({
44
  // Foreign key of a relation
45
  employer: one(companies, {
46
    fields: [users.employerId],
47
    references: [companies.id],
48
  }),
49
}));
50

51
export const companiesRelations = relations(companies, ({ many }) => ({
52
  // Inverse side of a relation
53
  staff: many(users),
54
}));
55

56
const schema = { companies, users, usersRelations, companiesRelations };
57
declare const db: NodePgDatabase<typeof schema>;
58

59
// Field in the projection
60
await db.select({ id: users.id, address: users.emailAddress }).from(users);
61

62
// Field in the filter
63
await db.select().from(users).where(eq(users.emailAddress, 'ada@example.com'));
64

65
// Field in the sort
66
await db.select().from(users).orderBy(users.emailAddress);
67

68
// Field inside a loaded relation
69
await db.query.companies.findMany({
70
  with: { staff: { columns: { emailAddress: true } } },
71
});
72

73
// Relation loaded by name
74
await db.query.users.findMany({ with: { employer: true } });
75

76
// Field in inserted data
77
await db.insert(users).values({ emailAddress: 'ada@example.com' });
78

79
// Field in updated data
80
await db
81
  .update(users)
82
  .set({ emailAddress: 'ada@example.com' })
83
  .where(eq(users.id, 1));
84

85
// Foreign key in a grouped count
86
await db
87
  .select({ company: users.employerId, total: count() })
88
  .from(users)
89
  .groupBy(users.employerId);
90

91
// Field read off the result
92
const [user] = await db.select().from(users);
93
export const address = user.emailAddress;
94

95
// Raw SQL in a filter
96
await db
97
  .select()
98
  .from(users)
99
  .where(sql`lower(${users.emailAddress}) = ${'ada@example.com'}`);

rename-safety/drizzle.ts · static preview

Two ways to miss

A name the rename missed fails in one of two ways (and they’re not the same problem).

Some stop compiling. That costs an afternoon: tsc hands you the list, you work through it, nothing reaches production.

The rest compile. The build is green, the tests that don’t touch that query pass, and the failure turns up later as a column that isn’t there.

ORM	Followed the rename	Stopped by the compiler	Left behind silently
UQL	19	0	0
Drizzle	14	4	0
TypeORM	12	0	5
Prisma	4	7	3
Sequelize	4	0	12
MikroORM	3	13	3

Rows don’t all add up to 19: where an ORM can’t express a probe, there’s nothing to rename and nothing to count.

Don’t read the first column on its own

MikroORM follows the fewest of the six, and it’s still the second safest.

Its defineEntity builder types index properties against the entity, so the stale name in { properties: ['emailAddress'] } is a compile error. 13 of its misses stop the build, 3 get through. Go by the leftmost column and you’d worry about the wrong tool. I did, for about a day.

Sequelize is the one to worry about. Its classes are properly typed and InferAttributes does real work on the model, but everything around the model takes strings, and nothing checks them:

1
// an index on a column that will not exist
2
User.init(attributes, { sequelize, indexes: [{ fields: ['emailAddress'] }] });
3

4
// an association pointing at a key that will not exist
5
User.belongsTo(Company, { foreignKey: 'employerId', as: 'employer' });
6

7
// queries asking for an attribute and a relation that will not exist
8
await User.findAll({ attributes: ['id', 'emailAddress'] });
9
await User.findAll({ include: ['employer'] });

All four compile after the rename. So do 12 of the 19 probes, and nothing warns you about any of them.

TypeORM: decorators fine, strings not

TypeORM is the interesting one, because the decorators aren’t the problem. @Index((user: User) => [user.employerId]) takes a callback, so F2 edits it and a stale name is a type error. That part works.

The SQL inside those same decorators doesn’t:

1
@Index((user: User) => [user.employerId], { where: `"emailAddress" <> ''` })
2
@Check(`"emailAddress" <> ''`)
3
@Column({ generatedType: 'STORED', asExpression: 'lower("emailAddress")' })

The callback half renames, the string half doesn’t, and there’s no seam between them. Three of TypeORM’s 5 silent misses are that pattern; the other two are an inverse relation and a query.

That’s what the whole table comes down to: whether the name goes through something the compiler resolves. mappedBy((user) => user.employer) is a property read. as: 'employer' is a string that looks like one. Drizzle sits high because its schema is values its queries import, so a stale name either follows or fails to compile. UQL follows all 19 because it never took a string option anywhere, indexes, checks and raw SQL included.

The files, the renames and every verdict are ts-orm-benchmark’s, on each ORM’s current stable release and its most type-safe entity API. Every rename is TypeScript 7.0.2’s own, or prisma-language-server 31.12.10’s for schema.prisma. I wrote UQL, so weigh that last row accordingly and then go check it: the rename page runs the real compiler in your browser instead of showing you my screenshot of it. Press F2 yourself.

UQL is a JSON-native TypeScript ORM for Node.js, Bun and Deno. Supports PostgreSQL, PGlite, MySQL, MariaDB, MSSQL, SQLite, CockroachDB, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.

UQL MIT License GitHub npm RSS llms.txt