Migrating from Prisma

Migrating from Prisma to Drizzle ORM is straightforward and can be done incrementally. This guide covers the migration process, API differences, and how to preserve your existing data.

Why Migrate to Drizzle?

Developers choose Drizzle over Prisma for several reasons:

Type Safety

Drizzle provides true TypeScript type inference without code generation

SQL-like API

Write queries that look like SQL but with full type safety

Zero Dependencies

Minimal bundle size with no runtime dependencies

Edge Compatible

Works in Cloudflare Workers, Vercel Edge, and other edge runtimes

Performance

No query engine overhead, direct database driver access

SQL Control

Full control over generated SQL with raw query support

Migration Strategies

Strategy 1: Side-by-Side (Recommended)

Run Prisma and Drizzle together during migration:

Install Drizzle

npm install drizzle-orm
npm install -D drizzle-kit

Generate Drizzle schema from Prisma

Use Drizzle Kit to introspect your existing database:

npx drizzle-kit introspect

This creates a Drizzle schema matching your current database structure.

Migrate routes incrementally

Convert one route/feature at a time from Prisma to Drizzle:

// Before: Prisma
const users = await prisma.user.findMany();

// After: Drizzle
const users = await db.select().from(usersTable);

Remove Prisma when complete

Once all code is migrated, uninstall Prisma:

npm uninstall prisma @prisma/client

Strategy 2: Fresh Start

Start a new project with Drizzle and migrate data:

Create new Drizzle schema from scratch
Export data from Prisma database
Import data into new Drizzle-managed database
Update application code

Schema Conversion

Prisma Schema to Drizzle

Here’s how Prisma schema elements map to Drizzle:

Basic Model

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';

export const users = pgTable('User', {
  id: serial('id').primaryKey(),
  email: text('email').notNull().unique(),
  name: text('name'),
  createdAt: timestamp('createdAt').notNull().defaultNow(),
  updatedAt: timestamp('updatedAt').notNull().defaultNow().$onUpdate(() => new Date()),
});

import { mysqlTable, serial, varchar, timestamp } from 'drizzle-orm/mysql-core';

export const users = mysqlTable('User', {
  id: serial('id').primaryKey(),
  email: varchar('email', { length: 255 }).notNull().unique(),
  name: varchar('name', { length: 255 }),
  createdAt: timestamp('createdAt').notNull().defaultNow(),
  updatedAt: timestamp('updatedAt').notNull().defaultNow().onUpdateNow(),
});

Enums

enum Role {
  USER
  ADMIN
}

model User {
  id   Int  @id @default(autoincrement())
  role Role @default(USER)
}

import { pgTable, serial, pgEnum } from 'drizzle-orm/pg-core';

export const roleEnum = pgEnum('Role', ['USER', 'ADMIN']);

export const users = pgTable('User', {
  id: serial('id').primaryKey(),
  role: roleEnum('role').notNull().default('USER'),
});

import { mysqlTable, serial, mysqlEnum } from 'drizzle-orm/mysql-core';

export const users = mysqlTable('User', {
  id: serial('id').primaryKey(),
  role: mysqlEnum('role', ['USER', 'ADMIN']).notNull().default('USER'),
});

Relations

model User {
  id    Int    @id @default(autoincrement())
  posts Post[]
}

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

import { pgTable, serial, text, integer } from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';

export const users = pgTable('User', {
  id: serial('id').primaryKey(),
});

export const posts = pgTable('Post', {
  id: serial('id').primaryKey(),
  title: text('title').notNull(),
  userId: integer('userId').notNull().references(() => users.id),
});

// Define relations for relational queries
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}));

export const postsRelations = relations(posts, ({ one }) => ({
  user: one(users, {
    fields: [posts.userId],
    references: [users.id],
  }),
}));

Many-to-Many Relations

model Post {
  id         Int        @id @default(autoincrement())
  categories Category[]
}

model Category {
  id    Int    @id @default(autoincrement())
  posts Post[]
}

import { pgTable, serial, integer, primaryKey } from 'drizzle-orm/pg-core';
import { relations } from 'drizzle-orm';

export const posts = pgTable('Post', {
  id: serial('id').primaryKey(),
});

export const categories = pgTable('Category', {
  id: serial('id').primaryKey(),
});

// Junction table (Prisma creates this automatically as _CategoryToPost)
export const postsToCategories = pgTable('_CategoryToPost', {
  postId: integer('postId').notNull().references(() => posts.id),
  categoryId: integer('categoryId').notNull().references(() => categories.id),
}, (t) => ({
  pk: primaryKey({ columns: [t.postId, t.categoryId] }),
}));

export const postsRelations = relations(posts, ({ many }) => ({
  categories: many(postsToCategories),
}));

export const categoriesRelations = relations(categories, ({ many }) => ({
  posts: many(postsToCategories),
}));

export const postsToCategoriesRelations = relations(postsToCategories, ({ one }) => ({
  post: one(posts, {
    fields: [postsToCategories.postId],
    references: [posts.id],
  }),
  category: one(categories, {
    fields: [postsToCategories.categoryId],
    references: [categories.id],
  }),
}));

Query API Comparison

Finding Records

// Find all
const users = await prisma.user.findMany();

// Find with where clause
const activeUsers = await prisma.user.findMany({
  where: { active: true },
});

// Find one
const user = await prisma.user.findUnique({
  where: { id: 1 },
});

// Find first
const firstUser = await prisma.user.findFirst({
  where: { active: true },
});

import { eq } from 'drizzle-orm';

// Find all
const users = await db.select().from(usersTable);

// Find with where clause
const activeUsers = await db.select()
  .from(usersTable)
  .where(eq(usersTable.active, true));

// Find one (use limit if multiple may exist)
const user = await db.select()
  .from(usersTable)
  .where(eq(usersTable.id, 1))
  .limit(1);

// Find first
const firstUser = await db.select()
  .from(usersTable)
  .where(eq(usersTable.active, true))
  .limit(1);

Creating Records

const user = await prisma.user.create({
  data: {
    email: 'john@example.com',
    name: 'John',
  },
});

// Create many
await prisma.user.createMany({
  data: [
    { email: 'john@example.com', name: 'John' },
    { email: 'jane@example.com', name: 'Jane' },
  ],
});

const user = await db.insert(usersTable)
  .values({
    email: 'john@example.com',
    name: 'John',
  })
  .returning(); // Returns inserted record

// Insert many
await db.insert(usersTable)
  .values([
    { email: 'john@example.com', name: 'John' },
    { email: 'jane@example.com', name: 'Jane' },
  ]);

Updating Records

const user = await prisma.user.update({
  where: { id: 1 },
  data: { name: 'John Updated' },
});

// Update many
await prisma.user.updateMany({
  where: { active: false },
  data: { deleted: true },
});

import { eq } from 'drizzle-orm';

const user = await db.update(usersTable)
  .set({ name: 'John Updated' })
  .where(eq(usersTable.id, 1))
  .returning();

// Update many
await db.update(usersTable)
  .set({ deleted: true })
  .where(eq(usersTable.active, false));

Deleting Records

await prisma.user.delete({
  where: { id: 1 },
});

await prisma.user.deleteMany({
  where: { active: false },
});

import { eq } from 'drizzle-orm';

await db.delete(usersTable)
  .where(eq(usersTable.id, 1));

await db.delete(usersTable)
  .where(eq(usersTable.active, false));

Filtering

// Equals
const users = await prisma.user.findMany({
  where: { role: 'ADMIN' },
});

// Not equals
const users = await prisma.user.findMany({
  where: { role: { not: 'ADMIN' } },
});

// In array
const users = await prisma.user.findMany({
  where: { role: { in: ['ADMIN', 'MODERATOR'] } },
});

// Greater than
const users = await prisma.user.findMany({
  where: { age: { gt: 18 } },
});

// Contains (string)
const users = await prisma.user.findMany({
  where: { name: { contains: 'John' } },
});

import { eq, ne, inArray, gt, like } from 'drizzle-orm';

// Equals
const users = await db.select()
  .from(usersTable)
  .where(eq(usersTable.role, 'ADMIN'));

// Not equals
const users = await db.select()
  .from(usersTable)
  .where(ne(usersTable.role, 'ADMIN'));

// In array
const users = await db.select()
  .from(usersTable)
  .where(inArray(usersTable.role, ['ADMIN', 'MODERATOR']));

// Greater than
const users = await db.select()
  .from(usersTable)
  .where(gt(usersTable.age, 18));

// Contains (string)
const users = await db.select()
  .from(usersTable)
  .where(like(usersTable.name, '%John%'));

Combining Filters

// AND
const users = await prisma.user.findMany({
  where: {
    AND: [
      { active: true },
      { role: 'ADMIN' },
    ],
  },
});

// OR
const users = await prisma.user.findMany({
  where: {
    OR: [
      { role: 'ADMIN' },
      { role: 'MODERATOR' },
    ],
  },
});

import { eq, and, or } from 'drizzle-orm';

// AND
const users = await db.select()
  .from(usersTable)
  .where(
    and(
      eq(usersTable.active, true),
      eq(usersTable.role, 'ADMIN')
    )
  );

// OR
const users = await db.select()
  .from(usersTable)
  .where(
    or(
      eq(usersTable.role, 'ADMIN'),
      eq(usersTable.role, 'MODERATOR')
    )
  );

Selecting Specific Fields

const users = await prisma.user.findMany({
  select: {
    id: true,
    name: true,
    email: true,
  },
});

const users = await db.select({
  id: usersTable.id,
  name: usersTable.name,
  email: usersTable.email,
}).from(usersTable);

Relations and Joins

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

// Nested includes
const users = await prisma.user.findMany({
  include: {
    posts: {
      include: {
        comments: true,
      },
    },
  },
});

// Requires relations definitions in schema
const users = await db.query.users.findMany({
  with: {
    posts: true,
  },
});

// Nested relations
const users = await db.query.users.findMany({
  with: {
    posts: {
      with: {
        comments: true,
      },
    },
  },
});

import { eq } from 'drizzle-orm';

const usersWithPosts = await db.select()
  .from(usersTable)
  .leftJoin(postsTable, eq(usersTable.id, postsTable.userId));

Sorting and Pagination

const users = await prisma.user.findMany({
  orderBy: { createdAt: 'desc' },
  skip: 10,
  take: 20,
});

import { desc } from 'drizzle-orm';

const users = await db.select()
  .from(usersTable)
  .orderBy(desc(usersTable.createdAt))
  .offset(10)
  .limit(20);

Aggregations

const result = await prisma.user.aggregate({
  _count: true,
  _avg: { age: true },
  _sum: { age: true },
});

import { count, avg, sum } from 'drizzle-orm';

const result = await db.select({
  count: count(),
  avgAge: avg(usersTable.age),
  sumAge: sum(usersTable.age),
}).from(usersTable);

Transactions

await prisma.$transaction(async (tx) => {
  await tx.user.create({ data: { name: 'John' } });
  await tx.post.create({ data: { title: 'Post' } });
});

await db.transaction(async (tx) => {
  await tx.insert(usersTable).values({ name: 'John' });
  await tx.insert(postsTable).values({ title: 'Post' });
});

Data Migration

Preserving Existing Data

Your data stays in the database during migration. Only your application code changes.

Introspect existing database

npx drizzle-kit introspect

This generates a Drizzle schema matching your current Prisma database structure.

Review generated schema

Check drizzle/schema.ts and adjust as needed. The introspection tool maps:

Table names
Column types
Constraints
Indexes
Foreign keys

Test queries

Write equivalent Drizzle queries and verify they return the same data:

// Test script
const prismaUsers = await prisma.user.findMany();
const drizzleUsers = await db.select().from(usersTable);

console.log('Match:', JSON.stringify(prismaUsers) === JSON.stringify(drizzleUsers));

Handling Prisma-Specific Features

@updatedAt

Prisma’s @updatedAt automatically updates timestamps. In Drizzle:

import { timestamp } from 'drizzle-orm/pg-core';

export const users = pgTable('User', {
  updatedAt: timestamp('updatedAt')
    .notNull()
    .defaultNow()
    .$onUpdate(() => new Date()),
});

@default(uuid())

import { uuid } from 'drizzle-orm/pg-core';

export const users = pgTable('User', {
  id: uuid('id').defaultRandom().primaryKey(),
});

@default(cuid())

Drizzle doesn’t have built-in CUID. Use a library:

import { text } from 'drizzle-orm/pg-core';
import { createId } from '@paralleldrive/cuid2';

export const users = pgTable('User', {
  id: text('id').$defaultFn(() => createId()).primaryKey(),
});

Drizzle Kit vs Prisma Migrate

Feature	Prisma Migrate	Drizzle Kit
Auto-generate migrations	Yes	Yes
Push schema without migrations	`db push`	`drizzle-kit push`
Migration history	`_prisma_migrations` table	`__drizzle_migrations` table
Introspection	`prisma db pull`	`drizzle-kit introspect`
Studio (GUI)	Prisma Studio	Drizzle Studio

Migration Commands

# Generate migration
prisma migrate dev --name add_users

# Apply migrations
prisma migrate deploy

# Reset database
prisma migrate reset

# Generate migration
drizzle-kit generate

# Apply migrations
drizzle-kit migrate

# Push schema (like db push)
drizzle-kit push

Common Pitfalls

No automatic ID generation: Unlike Prisma’s @default(autoincrement()), Drizzle requires explicit specification:

// Use serial() for auto-increment
id: serial('id').primaryKey()

// Or uuid()
id: uuid('id').defaultRandom().primaryKey()

Explicit table names: Drizzle uses the first argument as table name:

// This creates a table named "User" (matches Prisma)
export const users = pgTable('User', { ... });

// Variable name doesn't affect table name
export const usersTable = pgTable('users', { ... });

Relations are optional: Foreign keys work without defining relations. Relations are only needed for the relational query API:

// This works fine
export const posts = pgTable('posts', {
  userId: integer('userId').references(() => users.id),
});

// Relations only needed for db.query.posts.findMany({ with: ... })
export const postsRelations = relations(posts, ({ one }) => ({ ... }));

Type Inference Differences

Drizzle provides direct type inference without code generation:

// Prisma: Generated in node_modules/.prisma/client
type User = Prisma.User;

// Drizzle: Inferred from schema
import { users } from './schema';

type User = typeof users.$inferSelect;
type NewUser = typeof users.$inferInsert;

Performance Comparison

Drizzle typically performs better than Prisma because:

No query engine: Direct database driver usage
Smaller bundle: No Prisma engines to download
Prepared statements: Built-in support reduces parsing overhead
Edge runtime: Works in Cloudflare Workers, Vercel Edge

Benchmark example (Next.js API route):

// Prisma: ~150ms cold start
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

// Drizzle: ~50ms cold start
import { drizzle } from 'drizzle-orm/neon-http';
const db = drizzle({ connection: process.env.DATABASE_URL! });

Complete Example: Before & After

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

export async function getUsers(role: string) {
  return await prisma.user.findMany({
    where: { role },
    include: {
      posts: {
        orderBy: { createdAt: 'desc' },
        take: 10,
      },
    },
    orderBy: { name: 'asc' },
  });
}

export async function createUser(data: {
  email: string;
  name: string;
  role: string;
}) {
  return await prisma.user.create({ data });
}

import { drizzle } from 'drizzle-orm/neon-http';
import { users } from './schema';
import { eq, desc, asc } from 'drizzle-orm';

const db = drizzle({ connection: process.env.DATABASE_URL! });

export async function getUsers(role: string) {
  return await db.query.users.findMany({
    where: eq(users.role, role),
    with: {
      posts: {
        orderBy: desc(posts.createdAt),
        limit: 10,
      },
    },
    orderBy: asc(users.name),
  });
}

export async function createUser(data: {
  email: string;
  name: string;
  role: string;
}) {
  const [user] = await db.insert(users)
    .values(data)
    .returning();
  return user;
}

Next Steps

Schema Design

Learn Drizzle schema syntax in depth

Query API

Master Drizzle’s query builder

Best Practices

Optimize your Drizzle implementation

Relational Queries

Use the relational query API

​Why Migrate to Drizzle?

Type Safety

SQL-like API

Zero Dependencies

Edge Compatible

Performance

SQL Control

​Migration Strategies

​Strategy 1: Side-by-Side (Recommended)

​Strategy 2: Fresh Start

​Schema Conversion

​Prisma Schema to Drizzle

​Basic Model

​Enums

​Relations

​Many-to-Many Relations

​Query API Comparison

​Finding Records

​Creating Records

​Updating Records

​Deleting Records

​Filtering

​Combining Filters

​Selecting Specific Fields

​Relations and Joins

​Sorting and Pagination

​Aggregations

​Transactions

​Data Migration

​Preserving Existing Data

​Handling Prisma-Specific Features

​@updatedAt

​@default(uuid())

​@default(cuid())

​Drizzle Kit vs Prisma Migrate

​Migration Commands

​Common Pitfalls

​Type Inference Differences

​Performance Comparison

​Complete Example: Before & After

​Next Steps