Choosing a TypeScript ORM: Prisma, Drizzle, Kysely or TypeORM
You're starting a new TypeScript service on Postgres, and someone in the planning doc has written "ORM: TBD". The four names that come up are Prisma, Drizzle, Kysely and TypeORM. A year ago the choice was mostly about taste. In November 2026 it's also about timing, because Prisma and Drizzle are both partway through a major release, Kysely has its next line in beta, and TypeORM only just shipped 1.0.
So before the trade-offs, here's where each project actually is.
Where each one stands in November 2026
These are the npm registry's dist-tags as of 7 November 2026, read straight from registry.npmjs.org:
| Package | latest tag | Next line | What that means |
|---|---|---|---|
prisma (CLI) | 8.0.0-rc.33 | prev is 7.10.1 | npm i prisma now installs a release candidate |
@prisma/client | 7.10.1 | 8.x in dev | the client you actually run is still 7 |
drizzle-orm | 0.45.4 | rc is 1.0.0-rc.5 | 0.x is stable; 1.0 is close |
kysely | 0.29.8 | next is 0.30.0-beta.2 | 0.29 shipped in May 2026 |
typeorm | 1.1.2 | legacy is 0.3.31 | 1.0 went GA on 19 May 2026 |
The Prisma row is the one that bites. Prisma's release status page says ORM 8 "is a release candidate", that GA "is expected in October 2026", and that the version-8 CLI doesn't read schema.prisma and has no generate, migrate dev or db push. It also lists features version 8 doesn't have yet, including $extends, filtering inside JSON columns and atomic increment. Meanwhile the CLI's latest tag already points at the RC. If your team runs npx prisma migrate dev on a fresh machine without a pinned version, you're going to have a confusing morning.
The same page says ORM 7 gets bug fixes and security updates for 18 months after ORM 8 reaches GA, and ORM 6 gets security patches only until 19 November 2026. If you're on 6, that's twelve days from now.
How they differ: where the schema lives
The question that separates these four isn't really "ORM or not". It's where your schema is defined and what produces the types and the migrations.
Prisma 7: a schema file and a generated client
You describe models in schema.prisma, run prisma generate, and get a typed client. Version 7 changed a lot about how that client runs. The upgrade guide lists the ones you'll notice:
- Every database needs a driver adapter, such as
@prisma/adapter-pg, passed to the constructor. - The new
prisma-clientgenerator is Rust-free, and itsoutputpath is required, so the client no longer lands innode_modules. - CLI config moves to
prisma.config.ts;urlanddirectUrlin the schema's datasource block are deprecated. - The project should be ESM, with Node 20.19.0 or later and TypeScript 5.4.0 or later.
$usemiddleware is gone (use Client Extensions),.envisn't loaded automatically, andmigrate devno longer runsgeneratefor you.
Here's what a query looks like on 7, with a generator output of ../src/generated/prisma:
import { PrismaClient } from "./generated/prisma/client";
import { PrismaPg } from "@prisma/adapter-pg";
const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL });
const prisma = new PrismaClient({ adapter });
const users = await prisma.user.findMany({
where: { email: { endsWith: "@acme.dev" } },
include: { posts: true },
});
Two more things in the guide matter for production. Connection pools now follow the underlying driver's defaults, and pg has no connection timeout by default. And Accelerate standalone and hosted Prisma Postgres connections retire on 1 December 2026. If you're tuning pools, our connection pooling explainer and the Prisma 7 production patterns post go deeper. MongoDB users should note that v7 doesn't support MongoDB at all; the guide says to stay on 6 for now.
Drizzle: the schema is TypeScript
Drizzle's overview sums up its pitch as "If you know SQL, you know Drizzle", calls itself "a headless TypeScript ORM with a head", and claims "exactly 0 dependencies". Tables are TypeScript objects, so the types come from the same file with no generate step. You get two query styles: a SQL-like builder, and a relational API that the docs say "always outputs exactly 1 SQL query".
import { drizzle } from "drizzle-orm/node-postgres";
import { eq, like } from "drizzle-orm";
import { users, posts } from "./schema";
const db = drizzle(process.env.DATABASE_URL!);
const rows = await db
.select()
.from(users)
.leftJoin(posts, eq(posts.authorId, users.id))
.where(like(users.email, "%@acme.dev"));
The thing to plan for is 1.0. The release notes list 1.0.0-rc.5 on 21 October 2026, and the upgrade guide has you install with npm i drizzle-orm@rc and npm i -D drizzle-kit@rc, then run npx drizzle-kit up to convert your migrations folder. The guide says journal.json is removed, each migration gets its own folder, drizzle-kit drop is gone, and drizzle-kit moves "from database snapshots to DDL snapshots". If you use relational queries, there's a separate v1-to-v2 migration for those too. None of that is hard, but I wouldn't start a new project on 0.45 and ignore it: budget the upgrade into the first few months.
Our Prisma vs Drizzle comparison has the feature-by-feature table, and if you're moving an existing schema across, the Prisma to Drizzle converter gives you a starting point to check by hand.
Kysely: no models, just typed SQL
Kysely describes itself as "a type-safe and autocompletion-friendly TypeScript SQL query builder" in its introduction. There's no model layer and no relation loading. You write the query; Kysely checks the table and column names against a Database interface.
const rows = await db
.selectFrom("user")
.innerJoin("post", "post.author_id", "user.id")
.select(["user.email", "post.title"])
.where("user.email", "like", "%@acme.dev")
.execute();
That interface has to come from somewhere, and Kysely doesn't generate it. The generating types page lists third-party tools: kysely-codegen introspects PostgreSQL, MySQL, SQLite or SQL Server; prisma-kysely builds types from an existing Prisma schema; kanel-kysely is PostgreSQL-only. Migrations are hand-written up and down functions run in name order, and the docs say plainly that "Migrations should never depend on the current code of your app". Built-in dialects are PostgreSQL, MySQL, MS SQL Server, SQLite and PGlite, with community dialects for Neon, PlanetScale, Cloudflare D1 and others (dialects page).
That's more assembly than the others, and it's the right amount if your team already thinks in SQL. Our Drizzle vs Kysely comparison covers that pairing directly.
TypeORM 1.x: decorators, now with a cleanup
TypeORM is the classic decorator-based ORM. Entities are classes marked up with @Entity() and @Column(), the homepage says it supports both Data Mapper and Active Record, and typeorm migration:generate writes migrations by, in the docs' words, "comparing them with existing database schema on the server". The database list is the widest of the four, from PostgreSQL and MySQL to SAP HANA, Spanner and MongoDB.
import { Like } from "typeorm";
const users = await dataSource.getRepository(User).find({
where: { email: Like("%@acme.dev") },
relations: { posts: true },
});
The 1.0 release cleared out a lot of old API. Per the upgrade guide, you need Node.js 20 or later, Connection is replaced by DataSource, the mysql and sqlite3 drivers give way to mysql2 and better-sqlite3, string-based relations and select are removed, and .env/ormconfig.env loading is gone. The change most likely to break a running app is that invalidWhereValuesBehavior now throws on null or undefined in a where clause instead of ignoring it. There's a codemod: npx @typeorm/codemod v1 src/, with --dry to preview. The 1.1.0 notes go further and reject empty where criteria on update and delete, which is a safety net I'm glad exists.
Gotchas that show up after week one
- Unpinned Prisma CLI. Covered above, but it's the most likely surprise this month. Pin
prismaand@prisma/clientto^7and callnpx prisma@7in scripts. - Migrations you didn't review. Prisma, Drizzle and TypeORM all generate SQL from a diff. Read it before it runs, especially for renames, which a diff can't tell apart from drop-and-add. Our zero-downtime migrations post has the lock-safe patterns.
- Kysely type drift. If someone changes the database and nobody reruns the type generator, the compiler happily checks your queries against a stale schema. Run the generator in CI and fail on a diff.
- TypeORM
nullin where. After upgrading to 1.x, grep forwhereobjects built from optional request fields. That's where the new throw-by-default lands. - Drizzle's folder change.
drizzle-kit uprewrites the migrations directory layout. Do it on its own branch, with nothing else in the diff.
The decision rule
Go down the tree in order and stop at the first yes:
- Your team wants to write SQL and just have it type-checked: Kysely 0.29, plus
kysely-codegenin CI. - You have a large codebase already on TypeORM entities: upgrade to 1.x with the codemod rather than rewriting. Rewrites of a working data layer rarely pay for themselves.
- You want the schema in TypeScript and queries that look like SQL: Drizzle 0.45 today, with the 1.0 upgrade on the roadmap.
- You want a separate schema file, a guided migration workflow and the most hand-holding: Prisma 7, pinned, with ORM 8 evaluated once it reaches GA and closes the gaps on its own status page.
If you're genuinely torn between two, write the three gnarliest queries from your app in both. It takes an afternoon, and you'll learn more from that than from any comparison table, including ours.
Written by AIDToolStack Editorial
Researched from official documentation, specifications and vendor pages, listed under Sources below. Last checked November 2026.
Sources
- registry.npmjs.org/prisma
- registry.npmjs.org/@prisma/client
- registry.npmjs.org/drizzle-orm
- registry.npmjs.org/kysely
- registry.npmjs.org/typeorm
- www.prisma.io/docs/orm/release-status
- www.prisma.io/docs/orm/more/upgrade-guides/upgrading-versions/upgrading-to-prisma-7
- orm.drizzle.team/docs/overview
- orm.drizzle.team/docs/latest-releases
- orm.drizzle.team/docs/upgrade-v1
- kysely.dev/docs/intro
- kysely.dev/docs/generating-types
- kysely.dev/docs/migrations
- kysely.dev/docs/dialects
- typeorm.io/
- typeorm.io/docs/releases/1.0/upgrading-from-0.3
- github.com/typeorm/typeorm/releases
- typeorm.io/docs/migrations/generating
Related Posts
Explore on AIDToolStack
Discover tools and servers featured in our directory.
AI Tools
MCP Servers
Sponsor Our Newsletter
Reach thousands of developers who are actively evaluating AI tools, MCP servers, and dev infrastructure. Our weekly newsletter goes to engaged technical decision-makers.
All sponsored content is clearly labeled per our editorial policy.