Benchmark: Prisma 6 vs. Drizzle ORM 0.30 vs. TypeORM 0.3 for 2026 TypeScript Database Queries

// prisma-benchmark.ts// Benchmark Prisma 6 single-row lookups, batch inserts, and complex joins// Requirements: @prisma/client@6.0.1, prisma@6.0.1, PostgreSQL 16, ts-node 10.9import { PrismaClient, Prisma } from '@prisma/client';import { performance } from 'node:perf_hooks';import { promisify } from 'node:util';import { exec } from 'node:child_process';const execAsync = promisify(exec);const prisma = new PrismaClient({  log: [{ level: 'query', emit: 'event' }],});// Error handling: wrap Prisma queries in try/catch with typed errorsconst runPrismaBenchmark = async () => {  let totalQueries = 0;  let totalLatencyMs = 0;  const latencyBuckets = { under10ms: 0, 10to50ms: 0, over50ms: 0 };  try {    // 1. Single-row primary key lookup benchmark (10k iterations)    console.log('Running Prisma 6 single-row PK lookup benchmark...');    for (let i = 0; i < 10_000; i++) {      const start = performance.now();      try {        // Pre-seeded user with id=1 exists in test DB        const user = await prisma.user.findUnique({          where: { id: 1 },          select: { id: true, email: true, createdAt: true },        });        if (!user) throw new Error('Seeded user not found');      } catch (err) {        if (err instanceof Prisma.PrismaClientKnownRequestError) {          console.error(`Prisma known error: ${err.message}, Code: ${err.code}`);        } else {          console.error(`Unexpected error: ${err}`);        }        continue;      }      const latency = performance.now() - start;      totalLatencyMs += latency;      totalQueries++;      if (latency < 10) latencyBuckets.under10ms++;      else if (latency <= 50) latencyBuckets['10to50ms']++;      else latencyBuckets.over50ms++;    }    // 2. Batch insert benchmark (1k batches of 10 rows)    console.log('Running Prisma 6 batch insert benchmark...');    for (let batch = 0; batch < 1_000; batch++) {      const start = performance.now();      try {        await prisma.user.createMany({          data: Array.from({ length: 10 }, (_, idx) => ({            email: `prisma-batch-${batch}-${idx}@test.com`,            passwordHash: 'bench_hash',          })),          skipDuplicates: true,        });      } catch (err) {        console.error(`Batch insert error: ${err}`);        continue;      }      totalLatencyMs += performance.now() - start;      totalQueries++;    }    // 3. Complex join benchmark (user + posts + comments, 1k iterations)    console.log('Running Prisma 6 complex join benchmark...');    for (let i = 0; i < 1_000; i++) {      const start = performance.now();      try {        const userWithRelations = await prisma.user.findUnique({          where: { id: 1 },          include: {            posts: {              include: { comments: { select: { id: true, content: true } } },            },          },        });        if (!userWithRelations) throw new Error('User not found for join');      } catch (err) {        console.error(`Join query error: ${err}`);        continue;      }      totalLatencyMs += performance.now() - start;      totalQueries++;    }    // Calculate and log results    const avgLatency = totalLatencyMs / totalQueries;    console.log(`Prisma 6 Benchmark Results:      Total Queries: ${totalQueries}      Avg Latency: ${avgLatency.toFixed(2)}ms      Latency Buckets: ${JSON.stringify(latencyBuckets)}`);  } catch (err) {    console.error('Fatal benchmark error:', err);    process.exit(1);  } finally {    await prisma.$disconnect();  }};// Run benchmark if this is the main moduleif (require.main === module) {  runPrismaBenchmark();}

// drizzle-benchmark.ts// Benchmark Drizzle ORM 0.30 single-row lookups, batch inserts, and complex joins// Requirements: drizzle-orm@0.30.4, @drizzle-team/node-postgres@0.30.1, pg@8.11, PostgreSQL 16import { drizzle } from 'drizzle-orm/node-postgres';import { pgTable, serial, varchar, text, integer, timestamp, foreignKey } from 'drizzle-orm/pg-core';import { eq, sql } from 'drizzle-orm';import { performance } from 'node:perf_hooks';import { Pool } from 'pg';// Define schema matching Prisma benchmark for parityconst users = pgTable('users', {  id: serial('id').primaryKey(),  email: varchar('email', { length: 255 }).notNull().unique(),  passwordHash: varchar('password_hash', { length: 255 }).notNull(),  createdAt: timestamp('created_at').defaultNow().notNull(),});const posts = pgTable('posts', {  id: serial('id').primaryKey(),  userId: integer('user_id').notNull().references(() => users.id),  title: varchar('title', { length: 255 }).notNull(),  content: text('content'),  createdAt: timestamp('created_at').defaultNow().notNull(),});const comments = pgTable('comments', {  id: serial('id').primaryKey(),  postId: integer('post_id').notNull().references(() => posts.id),  content: text('content').notNull(),  createdAt: timestamp('created_at').defaultNow().notNull(),});// Initialize Drizzle with connection poolconst pool = new Pool({  host: 'localhost',  port: 5432,  user: 'bench_user',  password: 'bench_pass',  database: 'orm_benchmark',  max: 20, // Match Prisma connection pool size});const db = drizzle(pool, { schema: { users, posts, comments } });const runDrizzleBenchmark = async () => {  let totalQueries = 0;  let totalLatencyMs = 0;  const latencyBuckets = { under10ms: 0, 10to50ms: 0, over50ms: 0 };  try {    // 1. Single-row primary key lookup (10k iterations)    console.log('Running Drizzle 0.30 single-row PK lookup benchmark...');    for (let i = 0; i < 10_000; i++) {      const start = performance.now();      try {        const [user] = await db.select({          id: users.id,          email: users.email,          createdAt: users.createdAt,        }).from(users).where(eq(users.id, 1)).limit(1);        if (!user) throw new Error('Seeded user not found');      } catch (err) {        console.error(`Drizzle lookup error: ${err}`);        continue;      }      const latency = performance.now() - start;      totalLatencyMs += latency;      totalQueries++;      if (latency < 10) latencyBuckets.under10ms++;      else if (latency <= 50) latencyBuckets['10to50ms']++;      else latencyBuckets.over50ms++;    }    // 2. Batch insert benchmark (1k batches of 10 rows)    console.log('Running Drizzle 0.30 batch insert benchmark...');    for (let batch = 0; batch < 1_000; batch++) {      const start = performance.now();      try {        await db.insert(users).values(          Array.from({ length: 10 }, (_, idx) => ({            email: `drizzle-batch-${batch}-${idx}@test.com`,            passwordHash: 'bench_hash',          }))        ).onConflictDoNothing(); // Equivalent to Prisma skipDuplicates      } catch (err) {        console.error(`Drizzle batch insert error: ${err}`);        continue;      }      totalLatencyMs += performance.now() - start;      totalQueries++;    }    // 3. Complex join benchmark (user + posts + comments, 1k iterations)    console.log('Running Drizzle 0.30 complex join benchmark...');    for (let i = 0; i < 1_000; i++) {      const start = performance.now();      try {        const userWithRelations = await db.query.users.findFirst({          where: eq(users.id, 1),          with: {            posts: {              with: {                comments: {                  columns: { id: true, content: true },                },              },            },          },        });        if (!userWithRelations) throw new Error('User not found for join');      } catch (err) {        console.error(`Drizzle join error: ${err}`);        continue;      }      totalLatencyMs += performance.now() - start;      totalQueries++;    }    // Calculate and log results    const avgLatency = totalLatencyMs / totalQueries;    console.log(`Drizzle ORM 0.30 Benchmark Results:      Total Queries: ${totalQueries}      Avg Latency: ${avgLatency.toFixed(2)}ms      Latency Buckets: ${JSON.stringify(latencyBuckets)}`);  } catch (err) {    console.error('Fatal Drizzle benchmark error:', err);    process.exit(1);  } finally {    await pool.end();  }};if (require.main === module) {  runDrizzleBenchmark();}

// typeorm-benchmark.ts// Benchmark TypeORM 0.3 single-row lookups, batch inserts, and complex joins// Requirements: typeorm@0.3.20, pg@8.11, reflect-metadata@0.2.2, PostgreSQL 16import 'reflect-metadata';import { Entity, PrimaryGeneratedColumn, Column, OneToMany, ManyToOne, CreateDateColumn, BaseEntity } from 'typeorm';import { createConnection, Connection } from 'typeorm';import { performance } from 'node:perf_hooks';// Define entities matching benchmark schema parity@Entity('users')class User extends BaseEntity {  @PrimaryGeneratedColumn()  id!: number;  @Column({ unique: true, length: 255 })  email!: string;  @Column({ length: 255 })  passwordHash!: string;  @CreateDateColumn()  createdAt!: Date;  @OneToMany(() => Post, (post) => post.user)  posts!: Post[];}@Entity('posts')class Post extends BaseEntity {  @PrimaryGeneratedColumn()  id!: number;  @Column({ length: 255 })  title!: string;  @Column({ type: 'text', nullable: true })  content?: string;  @CreateDateColumn()  createdAt!: Date;  @ManyToOne(() => User, (user) => user.posts)  user!: User;  @Column()  userId!: number;  @OneToMany(() => Comment, (comment) => comment.post)  comments!: Comment[];}@Entity('comments')class Comment extends BaseEntity {  @PrimaryGeneratedColumn()  id!: number;  @Column({ type: 'text' })  content!: string;  @CreateDateColumn()  createdAt!: Date;  @ManyToOne(() => Post, (post) => post.comments)  post!: Post;  @Column()  postId!: number;}const runTypeORMBenchmark = async () => {  let connection: Connection | null = null;  let totalQueries = 0;  let totalLatencyMs = 0;  const latencyBuckets = { under10ms: 0, 10to50ms: 0, over50ms: 0 };  try {    // Initialize TypeORM connection    connection = await createConnection({      type: 'postgres',      host: 'localhost',      port: 5432,      username: 'bench_user',      password: 'bench_pass',      database: 'orm_benchmark',      entities: [User, Post, Comment],      synchronize: false, // Schema pre-seeded for parity      logging: false,      poolSize: 20, // Match other ORMs    });    // 1. Single-row primary key lookup (10k iterations)    console.log('Running TypeORM 0.3 single-row PK lookup benchmark...');    for (let i = 0; i < 10_000; i++) {      const start = performance.now();      try {        const user = await User.findOne({          where: { id: 1 },          select: ['id', 'email', 'createdAt'],        });        if (!user) throw new Error('Seeded user not found');      } catch (err) {        console.error(`TypeORM lookup error: ${err}`);        continue;      }      const latency = performance.now() - start;      totalLatencyMs += latency;      totalQueries++;      if (latency < 10) latencyBuckets.under10ms++;      else if (latency <= 50) latencyBuckets['10to50ms']++;      else latencyBuckets.over50ms++;    }    // 2. Batch insert benchmark (1k batches of 10 rows)    console.log('Running TypeORM 0.3 batch insert benchmark...');    for (let batch = 0; batch < 1_000; batch++) {      const start = performance.now();      try {        const usersToInsert = Array.from({ length: 10 }, (_, idx) => {          const user = new User();          user.email = `typeorm-batch-${batch}-${idx}@test.com`;          user.passwordHash = 'bench_hash';          return user;        });        await User.save(usersToInsert, { chunk: 10 }); // Batch save      } catch (err) {        // Handle duplicate key errors gracefully        if (err instanceof Error && err.message.includes('duplicate key')) {          // Skip duplicates, same as other ORMs        } else {          console.error(`TypeORM batch insert error: ${err}`);        }        continue;      }      totalLatencyMs += performance.now() - start;      totalQueries++;    }    // 3. Complex join benchmark (user + posts + comments, 1k iterations)    console.log('Running TypeORM 0.3 complex join benchmark...');    for (let i = 0; i < 1_000; i++) {      const start = performance.now();      try {        const userWithRelations = await User.findOne({          where: { id: 1 },          relations: ['posts', 'posts.comments'],          select: ['id', 'email', 'createdAt'],        });        if (!userWithRelations) throw new Error('User not found for join');      } catch (err) {        console.error(`TypeORM join error: ${err}`);        continue;      }      totalLatencyMs += performance.now() - start;      totalQueries++;    }    // Calculate and log results    const avgLatency = totalLatencyMs / totalQueries;    console.log(`TypeORM 0.3 Benchmark Results:      Total Queries: ${totalQueries}      Avg Latency: ${avgLatency.toFixed(2)}ms      Latency Buckets: ${JSON.stringify(latencyBuckets)}`);  } catch (err) {    console.error('Fatal TypeORM benchmark error:', err);    process.exit(1);  } finally {    if (connection) await connection.close();  }};if (require.main === module) {  runTypeORMBenchmark();}

// Profile any ORM query with this wrapperconst profileQuery = async (queryFn: () => Promise, queryName: string): Promise => {  const start = performance.now();  try {    const result = await queryFn();    const latency = performance.now() - start;    console.log(`Query ${queryName} took ${latency.toFixed(2)}ms`);    return result;  } catch (err) {    console.error(`Query ${queryName} failed: ${err}`);    throw err;  }};// Usage:const user = await profileQuery(  () => prisma.user.findUnique({ where: { id: 1 } }),  'prisma-single-user-lookup');

# Add to your package.json scripts"check-bundle": "npx webpack --mode production --target node --entry ./src/index.ts --output-path ./dist && npx gzip-size ./dist/main.js"

// drizzle.config.tsimport type { Config } from 'drizzle-kit';export default {  schema: './src/schema.ts',  out: './drizzle/migrations',  driver: 'pg',  dbCredentials: {    connectionString: process.env.DATABASE_URL!,  },  verbose: true,  strict: true,} satisfies Config;