ORM options (Prisma, Drizzle) in Deno - Deep Dive

Overview - ORM options (Prisma, Drizzle)

What is it?

ORM stands for Object-Relational Mapping. It is a tool that helps programmers work with databases using code instead of writing raw database queries. Prisma and Drizzle are two popular ORM options for Deno, a modern JavaScript and TypeScript runtime. They let you create, read, update, and delete data in your database using simple code commands.

Why it matters

Without ORMs like Prisma or Drizzle, developers must write complex and repetitive database queries by hand, which can be error-prone and slow. ORMs simplify database work, making it easier to build apps faster and with fewer bugs. They also help keep your code organized and consistent, which is important as projects grow.

Where it fits

Before learning about ORMs, you should understand basic programming concepts and how databases work, including SQL queries. After mastering ORMs, you can explore advanced database topics like migrations, performance tuning, and complex query optimization.

Mental Model

Core Idea

An ORM acts like a translator between your code and the database, letting you work with data as objects instead of raw queries.

Think of it like...

Using an ORM is like ordering food at a restaurant through a waiter instead of going into the kitchen yourself. You tell the waiter what you want in simple terms, and they handle the complex cooking and serving behind the scenes.

Code (Objects)  <==>  ORM Layer  <==>  Database (Tables)
┌─────────────┐      ┌─────────────┐      ┌─────────────┐
│ Your Code   │ <--> │ Prisma/     │ <--> │ SQL Tables  │
│ (Objects)   │      │ Drizzle ORM │      │             │
└─────────────┘      └─────────────┘      └─────────────┘

Build-Up - 7 Steps

1

Foundation

What is an ORM and Why Use It

Concept: Introduce the basic idea of ORM and its purpose.

An ORM lets you use programming language objects to interact with your database instead of writing SQL queries. This means you can create, read, update, and delete data using familiar code structures. It saves time and reduces errors.

Result

You understand that ORMs simplify database work by letting you use code objects instead of raw SQL.

Understanding that ORMs translate between code and databases helps you see why they speed up development and reduce mistakes.

2

Foundation

Deno Environment and Database Basics

Concept: Explain the Deno runtime and basic database concepts needed for ORMs.

Deno is a modern runtime for JavaScript and TypeScript that runs outside the browser. It supports secure and fast development. Databases store data in tables with rows and columns. To work with databases, you usually write SQL queries, but ORMs help you avoid that.

Result

You know the environment where Prisma and Drizzle run and the basics of databases they work with.

Knowing the runtime and database basics prepares you to understand how ORMs fit into your app.

3

Intermediate

Prisma ORM Basics in Deno

🤔Before reading on: do you think Prisma uses raw SQL queries or code objects to manage data? Commit to your answer.

Concept: Learn how Prisma lets you define your database schema and interact with data using code.

Prisma uses a schema file where you define your database tables as models. Then, Prisma generates code that lets you query and update your database using simple commands like prisma.user.findMany() to get all users. It also supports migrations to update your database structure safely.

Result

You can define models and perform basic database operations in Deno using Prisma code.

Understanding Prisma's schema-driven approach shows how it keeps your database and code in sync.

4

Intermediate

Drizzle ORM Basics in Deno

🤔Before reading on: do you think Drizzle requires a separate schema file like Prisma, or does it define models directly in code? Commit to your answer.

Concept: Explore how Drizzle defines database models and queries directly in TypeScript code.

Drizzle lets you define your database tables and columns directly in your TypeScript files using functions and types. You write queries using a fluent API that feels like writing code, for example, drizzle.select().from(users).where(users.id.equals(1)). It focuses on type safety and simplicity.

Result

You can define tables and write queries directly in code with Drizzle in Deno.

Knowing Drizzle's code-first approach helps you appreciate its flexibility and type safety.

5

Intermediate

Comparing Prisma and Drizzle Features

🤔Before reading on: which ORM do you think offers automatic migrations, Prisma or Drizzle? Commit to your answer.

Concept: Understand the main differences and strengths of Prisma and Drizzle.

Prisma uses a schema file and automatic migrations, making it easy to evolve your database. Drizzle defines models in code and emphasizes type safety and minimalism but requires manual migration handling. Prisma has a larger ecosystem, while Drizzle is lightweight and modern.

Result

You can choose the right ORM based on your project needs and preferences.

Recognizing the tradeoffs between schema-driven and code-driven ORMs helps you pick the best tool.

6

Advanced

Handling Migrations and Schema Changes

🤔Before reading on: do you think both Prisma and Drizzle handle migrations automatically? Commit to your answer.

Concept: Learn how each ORM manages changes to your database structure safely.

Prisma provides built-in migration tools that generate SQL scripts from your schema changes and apply them safely. Drizzle requires you to write migration scripts manually or use external tools. Managing migrations is crucial to avoid data loss or corruption when updating your app.

Result

You understand how to keep your database schema and app code aligned over time.

Knowing migration strategies prevents common production bugs related to database updates.

7

Expert

Type Safety and Performance Tradeoffs

🤔Before reading on: which ORM do you think offers stronger compile-time type checking, Prisma or Drizzle? Commit to your answer.

Concept: Explore how Prisma and Drizzle differ in type safety and runtime performance.

Drizzle is designed with TypeScript-first principles, offering very strong type safety at compile time, reducing runtime errors. Prisma also provides type safety but relies on generated client code. Performance-wise, Drizzle's minimal runtime can be faster, while Prisma offers more features but with some overhead.

Result

You can balance type safety and performance needs when choosing or tuning your ORM.

Understanding these tradeoffs helps you optimize your app for reliability and speed.

Under the Hood

Both Prisma and Drizzle generate code that acts as a bridge between your app and the database. Prisma uses a schema file to generate a client that translates your code commands into SQL queries at runtime. Drizzle defines tables and queries directly in TypeScript, using types and functions to build SQL queries safely. Both send these queries to the database engine, which executes them and returns results.

Why designed this way?

Prisma was designed to simplify database management with a clear schema and automatic migrations, targeting developer productivity and safety. Drizzle was created to leverage TypeScript's type system fully, offering a lightweight and flexible ORM that fits modern Deno and TypeScript workflows. Both approaches reflect tradeoffs between ease of use, control, and type safety.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Your Code     │       │ ORM Layer     │       │ Database      │
│ (TypeScript)  │       │ (Prisma or    │       │ (SQL Engine)  │
│               │       │ Drizzle)      │       │               │
└──────┬────────┘       └──────┬────────┘       └──────┬────────┘
       │                       │                       │
       │ Generates client code  │ Builds SQL queries    │ Executes SQL
       │ or query objects       │ and sends to DB       │ and returns data
       ▼                       ▼                       ▼

Myth Busters - 4 Common Misconceptions

Quick: Do Prisma and Drizzle automatically handle all database migrations without developer input? Commit to yes or no.

Common Belief: Both Prisma and Drizzle automatically manage all database migrations for you.

Reality: Only Prisma provides built-in automatic migration tools; Drizzle requires manual migration scripts or external tools.

Why it matters: Assuming Drizzle handles migrations automatically can lead to data loss or schema mismatches in production.

Quick: Do you think ORMs always make your app slower than raw SQL? Commit to yes or no.

Common Belief: Using an ORM always slows down your app compared to writing raw SQL queries.

Reality: While ORMs add some overhead, modern ORMs like Drizzle are optimized for performance, and the productivity gains often outweigh minor speed differences.

Why it matters: Avoiding ORMs due to performance fears can slow development and increase bugs unnecessarily.

Quick: Can you use Prisma or Drizzle without knowing SQL? Commit to yes or no.

Common Belief: You don't need to understand SQL at all when using Prisma or Drizzle.

Reality: Basic SQL knowledge is important to understand how your queries work and to debug issues effectively, even when using ORMs.

Why it matters: Ignoring SQL fundamentals can cause confusion and harder debugging when things go wrong.

Quick: Do Prisma and Drizzle work exactly the same way under the hood? Commit to yes or no.

Common Belief: Prisma and Drizzle are just different names for the same ORM technology.

Reality: They have different designs: Prisma uses a schema file and generates a client, while Drizzle defines models in code with a focus on TypeScript type safety.

Why it matters: Treating them as identical can lead to wrong assumptions about features and usage.

Expert Zone

1

Prisma's generated client caches query results in memory during runtime, which can improve performance but requires careful cache invalidation strategies.

2

Drizzle's code-first approach allows for more flexible and dynamic query building, which can be leveraged for complex conditional queries not easily expressed in schema-first ORMs.

3

Prisma's migration system tracks schema changes in a migration history table, enabling safe rollbacks and version control integration, a feature Drizzle leaves to external tools.

When NOT to use

Avoid using Prisma if you need minimal runtime overhead or want full control over SQL queries; consider Drizzle or raw SQL instead. Avoid Drizzle if you want automatic migrations and a schema-driven workflow; Prisma is better suited. For very simple projects, raw SQL or lightweight query builders might be more appropriate.

Production Patterns

In production, Prisma is often used in large-scale applications requiring robust schema migrations and a rich ecosystem. Drizzle is favored in projects prioritizing TypeScript type safety and minimal dependencies. Both are integrated with testing frameworks and CI/CD pipelines to automate database updates and ensure data integrity.

Connections

TypeScript Type System

Drizzle builds on TypeScript's type system to provide compile-time safety for database queries.

Understanding TypeScript types deeply helps you write safer database code with Drizzle, reducing runtime errors.

Database Normalization

ORMs like Prisma and Drizzle map normalized database tables to objects in code.

Knowing normalization principles helps you design better schemas that ORMs can manage efficiently.

Human Translation

ORMs act like translators converting one language (code) into another (SQL).

Recognizing this translation role clarifies why ORMs add abstraction and where errors can occur.

Common Pitfalls

#1 Trying to use Drizzle without writing migration scripts.

Wrong approach:

Just changing table definitions in code and expecting the database to update automatically.

Correct approach:

Write and run explicit migration scripts to update the database schema safely.

Root cause:

Misunderstanding that Drizzle does not provide automatic migration management.

#2 Ignoring SQL errors because ORM code looks correct.

Wrong approach:

Assuming prisma.user.findMany() will always work without checking database constraints or indexes.

Correct approach:

Test queries and understand underlying SQL to catch errors early.

Root cause:

Overreliance on ORM abstraction without understanding the database.

#3 Mixing raw SQL queries and ORM queries without care.

Wrong approach:

Running raw SQL that changes data structure without updating ORM schema or models.

Correct approach:

Keep ORM schema and raw SQL changes synchronized to avoid inconsistencies.

Root cause:

Not maintaining a single source of truth for database schema.

Key Takeaways

ORMs like Prisma and Drizzle simplify database work by letting you use code objects instead of raw SQL queries.

Prisma uses a schema-driven approach with automatic migrations, while Drizzle defines models directly in TypeScript code focusing on type safety.

Understanding how each ORM handles migrations and type safety helps you choose the right tool for your project.

Knowing the underlying translation between code and SQL prevents common bugs and performance issues.

Mastering ORM usage requires basic SQL knowledge and careful schema management to keep your app reliable.

Practice

1. What is the main purpose of using an ORM like Prisma or Drizzle in a Deno project?

easy

A. To manage server configurations and deployments

B. To create user interfaces for web applications

C. To write low-level network protocols

D. To interact with databases using simple and safe code instead of raw SQL

Solution

1. Step 1: Understand what ORM stands for

   ORM means Object-Relational Mapping, which helps connect code with databases easily.

2. Step 2: Identify ORM's role in Deno projects

   ORMs like Prisma and Drizzle let you write code to manage database data without writing raw SQL queries.

3. Final Answer:

   To interact with databases using simple and safe code instead of raw SQL -> Option D

4. Quick Check:

   ORM = Simple database code [OK]

Hint: ORMs simplify database work by hiding raw SQL [OK]

Common Mistakes:

• Confusing ORM with UI libraries
• Thinking ORM manages server setup
• Assuming ORM handles network protocols

2. Which of the following is the correct way to import Prisma Client in a Deno project?

easy

A. import { PrismaClient } from "@prisma/client";

B. import PrismaClient from "prisma/client";

C. const PrismaClient = require("@prisma/client");

D. import prisma from "deno-prisma";

Solution

1. Step 1: Recall Prisma Client import syntax

   Prisma Client is imported using ES module syntax with curly braces from "@prisma/client".

2. Step 2: Check each option for correctness

   import { PrismaClient } from "@prisma/client"; uses correct ES import syntax. import PrismaClient from "prisma/client"; misses curly braces. const PrismaClient = require("@prisma/client"); uses CommonJS require which is not used in Deno. import prisma from "deno-prisma"; uses a wrong package name.

3. Final Answer:

   import { PrismaClient } from "@prisma/client"; -> Option A

4. Quick Check:

   Prisma import uses curly braces and correct package [OK]

Hint: Prisma uses named import from "@prisma/client" [OK]

Common Mistakes:

• Using require() instead of import
• Missing curly braces in import
• Wrong package names

3. Given this Drizzle code snippet in Deno, what will be the output if the database has two users named 'Alice' and 'Bob'?

const users = await db.select().from(usersTable);
console.log(users.map(u => u.name));

medium

A. [{name: "Alice"}, {name: "Bob"}]

B. undefined

C. ["Alice", "Bob"]

D. SyntaxError

Solution

1. Step 1: Understand the select query

   The code selects all rows from usersTable and stores them in users array.

2. Step 2: Map user objects to their names

   users.map(u => u.name) creates a new array with only the name values from each user object.

3. Final Answer:

   ["Alice", "Bob"] -> Option C

4. Quick Check:

   Mapping user objects to names returns array of names [OK]

Hint: Mapping extracts just the names from user objects [OK]

Common Mistakes:

• Expecting full objects instead of names array
• Confusing map output with original array
• Assuming syntax error due to async

4. You wrote this Prisma query in Deno but get an error: const users = await prisma.user.findMany(). What is the likely cause?

medium

A. You must import Drizzle instead of Prisma

B. You forgot to instantiate PrismaClient before using it

C. You need to use raw SQL instead of Prisma queries

D. The findMany method does not exist in Prisma

Solution

1. Step 1: Check PrismaClient usage

   Before calling prisma.user.findMany(), you must create an instance: const prisma = new PrismaClient();

2. Step 2: Understand error cause

   If prisma is not instantiated, calling findMany() causes an error because prisma is undefined.

3. Final Answer:

   You forgot to instantiate PrismaClient before using it -> Option B

4. Quick Check:

   Instantiate PrismaClient before queries [OK]

Hint: Always create PrismaClient instance before queries [OK]

Common Mistakes:

• Assuming findMany doesn't exist
• Trying raw SQL instead of ORM methods
• Mixing Prisma and Drizzle imports

5. You want to use Drizzle ORM in Deno to insert a new user only if the username is not empty and then fetch all users. Which code snippet correctly applies this logic?

hard

A. if (username) {
await db.insert(usersTable).values({ name: username });
}
const allUsers = await db.select().from(usersTable);

B. await db.insert(usersTable).values({ name: username });
if (username) {
const allUsers = await db.select().from(usersTable);
}

C. const allUsers = await db.select().from(usersTable);
if (username) {
await db.insert(usersTable).values({ name: username });
}

D. await db.insert(usersTable).values({ name: username });
const allUsers = await db.select().from(usersTable);

Solution

1. Step 1: Check condition before insert

   We must insert only if username is not empty, so the insert is inside the if (username) block.

2. Step 2: Fetch all users after conditional insert

   After the conditional insert, we fetch all users with db.select().from(usersTable) and store in allUsers.

3. Final Answer:

   if (username) { await db.insert(usersTable).values({ name: username }); } const allUsers = await db.select().from(usersTable); -> Option A

4. Quick Check:

   Insert only if username, then fetch all users [OK]

Hint: Put insert inside if, then select all users [OK]

Common Mistakes:

• Inserting without checking username
• Fetching users before insert
• Fetching users inside the if block