prisma-generator-drizzle

prisma-generator-drizzle is a Prisma generator that lets you generate a Drizzle schema. It is specifically designed for (existing) projects that are using Prisma and want to migrate to Drizzle, or for projects that want to use both Prisma and Drizzle together.

In this version, the focus is still on the query and mutation capabilities of the generated Drizzle schema.

Features

https://github.com/farreldarian/prisma-generator-drizzle/assets/62016900/35b57135-614e-4e07-920b-9e9a487eb6cb

• 🤝 1:1 Prisma to Drizzle schema generation
• ✨ Compatible with all *scalars, enums, and *constraints
• 📦 Supports drizzle relational query
• 🚀 Generates drizzle-specific features like the .$type<..>() method

*Only supports default scalar for now and more constraints will be added in future

This project is still considered as experimental, but you can safely use it for production. Follow the progress on v1.

Get started

• Installation
• Usages
• Configuration
• Example
• Gotchas

Installation

1. Install the package

npm install -D prisma-generator-drizzle
npm install drizzle-orm

2. Add to your Prisma schema

generator drizzle {
  provider = "prisma-generator-drizzle"

  // Specify the output directory
  // output = "./lib/drizzle/models"
}

See configuration for more options.

3. Run the generator

prisma generate

Usages

Note: This generator will use the default Prisma field mapping, meaning any @db.* modifiers will be ignored for now.

prisma-generator-drizzle aims for 1:1 compatibility with Prisma, this means that you can use the generated Drizzle schema as a complete and familiar drop-in replacement for the Prisma client.

• Setup drizzle-kit
• Setup relational query

In addition to the Prisma features, you can also generate Drizzle-specific features:

Directive syntax is still experimental, feel free to suggest a better approach.

1. Generate .$defaultFn<..>()
2. Generate .$type<..>()

Configuration

| Key | Description | Default | Example | | --------------- | --------------------------------- | ----------- | ----------- | | output | Change the output | "./drizzle" | "../models" | | | Generate single output file | | "drizzle.ts" | | formatter | Run prettier after generation | - | "prettier" | | relationalQuery | Flag to generate relational query | true | false | | moduleResolution | Specify the module resolution that will affect the import style | *auto | nodenext | | verbose | Flag to enable verbose logging | - | true | | abortOnFailedFormatting | Flag to throw exception when formatting fails | true | false | | **dateMode | Change the generated mode for date | "date" ||

* It will find the closest tsconfig from the current working directory. Note that extends is not supported

**Does not work with sqlite

Setting up relational query

import { drizzle } from 'drizzle-orm/node-postgres'

// `schema` contains all table and relation definitions
import { schema } from 'prisma/drizzle/schema'

const client = ... // database client
const db = drizzle(client, { schema })

Setting up drizzle-kit

Use the glob pattern (see example 3) to reference the generated table definitions.

import { defineConfig } from 'drizzle-kit'
export default defineConfig({
  // Using the default output path
  schema: './prisma/drizzle/*',
})

Generate .$defaultFn() Custom Default Initializer

⚠️ DEPRECATED , will be replace by drizzle.custom directive

Add /// drizzle.default <module>::<named-function-import> directive above the field definition to generate a custom default initializer.

NOTE: This will override any @default(...) attribute from the schema.

model User {
  /// drizzle.default @paralleldrive/cuid2::createId
  id     String @id
  ...
}

This will result to:

import { createId } from '@paralleldrive/cuid2'
...

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

Or with a custom code

model User {
  /// drizzle.default crypto::randomBytes `() => randomBytes(16).toString('hex')`
  salt      String?
  ...
}

import { randomBytes } from 'node:crypto'
...

export const users = pgTable('User', {
  salt: text('salt')
    .$defaultFn(() => randomBytes(16).toString('hex'))
    .notNull(),
  ...
})

Generate .$type<..>() Type Customization

⚠️ DEPRECATED , will be replace by drizzle.custom directive

Add /// drizzle.type <module>::<named-import> directive above the field definition.

model Wallet {
  /// drizzle.type viem::Address
  address     String?
  ...
}

This will result to:

import { Wallet } from 'viem'
...

export const wallets = pgTable('Wallet', {
  address: text('address').$type<Address>(),
  ...
})

Or with a relative import

model User {
  /// drizzle.type ../my-type::Email
  email     String?
  ...
}

import { Email } from '../my-type'
...

export const users = pgTable('User', {
  email: text('email').$type<Email>(),
  ...
})

Example

1. with-drizzle-prisma: using drizzle's prisma extension

Gotchas

Relative import paths need explicit file extensions in ECMAScript imports when '--moduleResolution' is 'node16' or 'nodenext'.

By default, the generator will try to find the closest tsconfig from the current working directory to determine the import style, whether to add .js or not. When there's no config found, it will use the common import (e.g. import { users } from './users').

You can explicitly set the moduleResolution option in the generator configuration.

Check also the discussion

SqliteError: NOT NULL constraint failed: <table-name>.id

Currently having @default(autoincrement()) only work for postgres and mysql.