Picking a data access layer in a TypeScript + PostgreSQL project is one of those decisions that's easy to undo early on and painful to change later. I've used all three approaches across different projects, and they each have a clear place. Here's how they actually compare.

The three options:

1. Prisma: schema-first, type-safe ORM with great DX
2. TypeORM: decorator-based ORM, closer to SQL, more flexible
3. Direct DB Client: raw node-postgres, maximum control

The Same Query, Three Ways

Fetching users with their posts:

Prisma

// schema.prisma
model User {
  id    Int     @id @default(autoincrement())
  name  String
  posts Post[]
}

model Post {
  id     Int    @id @default(autoincrement())
  title  String
  userId Int
  user   User   @relation(fields: [userId], references: [id])
}

// query
const users = await prisma.user.findMany({
  include: { posts: true }
});

TypeORM

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @OneToMany(() => Post, (post) => post.user)
  posts: Post[];
}

@Entity()
export class Post {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @ManyToOne(() => User, (user) => user.posts)
  user: User;
}

// query
const users = await dataSource.getRepository(User).find({
  relations: ['posts']
});

Direct Database Client

const { rows: users } = await client.query(`
  SELECT u.id, u.name, json_agg(p.*) as posts
  FROM users u
  LEFT JOIN posts p ON p."userId" = u.id
  GROUP BY u.id;
`);

Comparison

My Take

Prisma is my default for most projects. The schema-first workflow, auto-generated types, and prisma studio make the day-to-day faster. The Rust query engine adds a small startup overhead, but in practice you won't notice it.

TypeORM is the right call when you need more control over queries or when your team already thinks in SQL. The decorator syntax takes some getting used to, but the query builder is genuinely powerful.

Direct DB client is for when performance is the only thing that matters, or when the query is complex enough that an ORM would fight you. You'll write more code and maintain it manually, but you'll never wonder what SQL it's generating under the hood.

– Ramin ✌️