Why I Switched from Prisma ORM to Drizzle ORM: A Journey Towards Simplicity and Speed 🚀

Hey folks! 👋 Today, I want to share my journey of switching from Prisma ORM to Drizzle ORM, a move that has significantly streamlined my development workflow. If you’re looking for an ORM that offers simplicity, type safety, and an overall better experience in managing your database interactions, then buckle up! I’ll break down my reasons for this switch and provide some insights into how Drizzle ORM has transformed my development process. 💻✨

My first ORM

At the beginning, I started with the Drizzle, but found that the settings were more complicated than expected. Especially in the matter of creating schema, which made me feel discouraged in the beginning Makes you decide to use Prisma instead, which provides convenience in starting and easier settings

Drizzle ORM

Drizzle ORM has a clear and flexible schema way. But at that time it felt too complicated for me. As in the example below:

// src/db/schema.ts
import { index, pgEnum, pgTable, serial, text, varchar } from 'drizzle-orm/pg-core';

export const projectStatus = pgEnum('ProjectStatus', [
    'NOT_STARTED',
    'IN_PROGRESS',
    'COMPLETED',
    'ON_HOLD',
]);

export const project = pgTable(
    'project',
    {
        description: text(),
        id: serial().primaryKey().notNull(),
        link: text().notNull(),
        status: projectStatus().default('NOT_STARTED').notNull(),
        title: varchar({ length: 255 }).notNull(),
    },
    (table) => {
        return {
            statusIdx: index('project_status_idx').using('btree', table.status.asc().nullsLast()),
        };
    },
);

Prisma ORM

Prisma ORM makes the settings easy and quickly. Help me focus on development by creating a straightforward schema. As in this example:

// prisma/schema.prisma
generator client {
  provider        = "prisma-client-js"
}

datasource db {
  provider  = "postgresql"
  url       = env("DATABASE_URL")
}

model project {
  id          Int           @id @default(autoincrement())
  title       String        @db.VarChar(255)
  description String?
  status      ProjectStatus @default(NOT_STARTED)
  link        String

  @@index([status])
}

enum ProjectStatus {
  NOT_STARTED
  IN_PROGRESS
  COMPLETED
  ON_HOLD
}

Why Drizzle ORM?

As developers, we often face the challenge of balancing productivity and complexity in our projects. Prisma has been a reliable companion for a while, but as my projects grew, I found myself entangled in its extensive features that, while powerful, often felt overwhelming. That’s when I discovered Drizzle ORM, which has become my go-to solution for managing database operations. Here’s why Drizzle ORM won me over:

• Lightweight and fast: Drizzle ORM has been designed to Lightweight, Powerful, Simple, Flexible, and serverless-rady by design.
• Type Safety and TypeScript Support: If you’re a TypeScript enthusiast like me, you’ll appreciate the robust type safety that Drizzle offers. It enhances the developer experience by catching errors during compile time rather than at runtime.
• Focused on SQL: Drizzle ORM allows you to write SQL directly, giving you more control over your queries. This approach feels natural, especially for developers who are comfortable with SQL syntax.

My Drizzle ORM Setup

Here’s a sneak peek into how I’ve integrated Drizzle ORM into my workflow and how it has simplified my interactions with the database. Let’s dive into the configuration and some code examples to illustrate its elegance.

1. Installation and Configuration

Setting up Drizzle ORM is a breeze. First, you need to install the necessary packages:

npm i drizzle-orm pg dotenv
npm i -D drizzle-kit tsx @types/pg

Next, let’s configure the database connection. Here’s how my db.ts looks:

// db.ts
import 'dotenv/config';
import { drizzle } from 'drizzle-orm/node-postgres';

const db = drizzle(process.env.DATABASE_URL!);

2. Defining Schemas

Drizzle ORM lets you define your database schemas easily. Here’s a sample schema for a simple blog application:

// schema.ts
import { integer, pgTable, varchar } from "drizzle-orm/pg-core";

export const postsTable = pgTable("posts", {
  id: integer().primaryKey().generatedAlwaysAsIdentity(),
  title: varchar({ length: 255 }).notNull(),
  content: varchar().notNull(),
});

type NewPost = typeof postsTable.$inferInsert;

3. CRUD Operations

Performing CRUD operations with Drizzle ORM is straightforward and intuitive. Here’s how you can insert a new post:

// index.ts
import db from './db';
import { postsTable, type NewPost } from './schema';

function async createPost(post: NewPost) {
	const result = await db.insert(postsTable).values(post);
	return result;
}

4. Querying Data

Fetching data feels just as simple. Here’s how I retrieve all posts from the database:

// index.ts
import db from './db';
import { postsTable } from './schema';

function async getPosts() {
	const allPosts = await db.select().from(postsTable);
	return allPosts;
}

This simplicity makes Drizzle ORM a joy to work with, especially compared to the more convoluted syntax found in other ORMs.

Why I Love Drizzle ORM

Switching to Drizzle ORM has brought several benefits to my development workflow:

• Simplicity: The lightweight design allows me to focus more on writing code and less on ORM configurations.
• Familiarity: Writing SQL feels natural, and I can easily manipulate queries without being hindered by ORM abstractions.
• Serverless: Because Drizzle ORM supports serverless since the design. It can be confident that there is no problem with the Next.js Middleware like prisma.

Performance Comparison

To illustrate the performance gains, I don’t need to do much testing because the Drizzle ORM has already done it for us website

Wrap-Up: Making the Switch

If you’re looking for an ORM that combines simplicity with powerful features, I highly recommend giving Drizzle ORM a try. It’s been a game-changer for my projects, allowing me to write clean, maintainable code while enhancing my productivity. Whether you’re a solo developer or part of a larger team, the switch to Drizzle ORM could simplify your database interactions and improve your development experience.

Let me know in the comments if you have any questions or want to share your own experiences with different ORMs! Happy coding! 🚀