Skip to content
Engineering

Choosing a TypeScript ORM: Prisma, Drizzle, Kysely or TypeORM

AIDToolStack EditorialNovember 7, 20267 min read
TypeScriptORMPrismaDrizzleKyselyTypeORM
Share:Twitter

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:

Packagelatest tagNext lineWhat that means
prisma (CLI)8.0.0-rc.33prev is 7.10.1npm i prisma now installs a release candidate
@prisma/client7.10.18.x in devthe client you actually run is still 7
drizzle-orm0.45.4rc is 1.0.0-rc.50.x is stable; 1.0 is close
kysely0.29.8next is 0.30.0-beta.20.29 shipped in May 2026
typeorm1.1.2legacy is 0.3.311.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.

Diagram comparing where the schema, the TypeScript types and the migrations come from in Prisma 7, Drizzle 0.45, Kysely 0.29 and TypeORM 1.1
Diagram comparing where the schema, the TypeScript types and the migrations come from in Prisma 7, Drizzle 0.45, Kysely 0.29 and TypeORM 1.1

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-client generator is Rust-free, and its output path is required, so the client no longer lands in node_modules.
  • CLI config moves to prisma.config.ts; url and directUrl in 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.
  • $use middleware is gone (use Client Extensions), .env isn't loaded automatically, and migrate dev no longer runs generate for 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 prisma and @prisma/client to ^7 and call npx prisma@7 in 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 null in where. After upgrading to 1.x, grep for where objects built from optional request fields. That's where the new throw-by-default lands.
  • Drizzle's folder change. drizzle-kit up rewrites the migrations directory layout. Do it on its own branch, with nothing else in the diff.
Decision tree for picking Kysely, TypeORM, Drizzle or Prisma based on how you want to write queries and define the schema
Decision tree for picking Kysely, TypeORM, Drizzle or Prisma based on how you want to write queries and define the schema

The decision rule

Go down the tree in order and stop at the first yes:

  1. Your team wants to write SQL and just have it type-checked: Kysely 0.29, plus kysely-codegen in CI.
  2. 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.
  3. You want the schema in TypeScript and queries that look like SQL: Drizzle 0.45 today, with the 1.0 upgrade on the roadmap.
  4. 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.

AE

Written by AIDToolStack Editorial

Researched from official documentation, specifications and vendor pages, listed under Sources below. Last checked November 2026.

Sources

  1. registry.npmjs.org/prisma
  2. registry.npmjs.org/@prisma/client
  3. registry.npmjs.org/drizzle-orm
  4. registry.npmjs.org/kysely
  5. registry.npmjs.org/typeorm
  6. www.prisma.io/docs/orm/release-status
  7. www.prisma.io/docs/orm/more/upgrade-guides/upgrading-versions/upgrading-to-prisma-7
  8. orm.drizzle.team/docs/overview
  9. orm.drizzle.team/docs/latest-releases
  10. orm.drizzle.team/docs/upgrade-v1
  11. kysely.dev/docs/intro
  12. kysely.dev/docs/generating-types
  13. kysely.dev/docs/migrations
  14. kysely.dev/docs/dialects
  15. typeorm.io/
  16. typeorm.io/docs/releases/1.0/upgrading-from-0.3
  17. github.com/typeorm/typeorm/releases
  18. typeorm.io/docs/migrations/generating

Related Posts

Explore on AIDToolStack

Discover tools and servers featured in our directory.

MCP Servers

Trigger.dev Jobs MCP ServerManage Trigger.dev background jobs from your AI coding assistant. Monitor job runs, trigger tasks manually, inspect execution logs, manage schedules, and debug failed runs. The server provides operational visibility into your background job infrastructure — see which tasks are running, queued, or failed, and take action. Your AI can help diagnose job failures from execution logs, retry failed tasks, and optimize concurrency configurations for better throughput.Tailscale Network MCP ServerManage your Tailscale mesh VPN network from your AI coding assistant. View connected devices, manage ACLs, configure exit nodes, check device status, and manage DNS settings. The server provides visibility into your Tailscale network — see which machines are online, troubleshoot connectivity issues, manage network access policies, and configure routes. Useful for developers managing distributed infrastructure where Tailscale provides secure networking between services.Portainer Docker MCP ServerManage Docker environments through Portainer's API from your AI coding assistant. Control containers, images, networks, and volumes across multiple Docker hosts and Kubernetes clusters. The server provides tools for container lifecycle management, image pulling and building, stack deployment, and resource monitoring. Portainer's multi-environment management makes this server particularly valuable for teams managing containers across development, staging, and production environments.

Reviews

Sign in to leave a review.

No reviews yet. Be the first!

Comments

Sign in to leave a comment.

No comments yet. Be the first!

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.

Growing subscriber baseHigh open rates

All sponsored content is clearly labeled per our editorial policy.