ORM options (Prisma, Drizzle) in Deno

Introduction

ORMs help you work with databases using simple code instead of writing complex queries. Prisma and Drizzle make it easier to save, find, and change data in your app.

When you want to avoid writing raw SQL queries and prefer using JavaScript or TypeScript code to manage data.

When building a Deno app that needs to connect to a database like PostgreSQL or MySQL.

When you want to keep your database code organized and easy to read.

When you want to use type safety to catch errors early while working with database data.

When you want to switch databases easily without rewriting all your queries.

Syntax

Deno

import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

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

// Drizzle example
import { drizzle } from 'drizzle-orm/deno-postgres';
import { Client } from 'deno-postgres';

const client = new Client({ /* connection options */ });
await client.connect();
const db = drizzle(client);

// Example: Select all users
const users = await db.select().from(usersTable);

Prisma uses a generated client based on your database schema.

Drizzle works directly with SQL-like queries but keeps type safety and simplicity.

Examples

Prisma example to get all posts from the database.

Deno

import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

// Get all posts
const posts = await prisma.post.findMany();

Drizzle example to select all posts using a connected client.

Deno

import { drizzle } from 'drizzle-orm/deno-postgres';
import { Client } from 'deno-postgres';

const client = new Client({ /* config */ });
await client.connect();
const db = drizzle(client);

const posts = await db.select().from(postsTable);

Sample Program

This Deno program uses Prisma to add a new user and then fetch all users from the database. It shows how simple it is to create and read data with Prisma.

Deno

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

const prisma = new PrismaClient();

async function main() {
  // Create a new user
  const newUser = await prisma.user.create({
    data: { name: 'Alice', email: '[e-mail]' }
  });

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

  console.log('New user created:', newUser);
  console.log('All users:', users);
}

main()
  .catch(e => console.error(e))
  .finally(async () => {
    await prisma.$disconnect();
  });

Important Notes

Prisma requires generating the client after defining your schema.

Drizzle is lightweight and works well with Deno's native Postgres client.

Both ORMs improve code readability and reduce errors compared to raw SQL.

Summary

ORMs like Prisma and Drizzle let you work with databases using simple code.

They help you avoid writing raw SQL and keep your code clean and safe.

Prisma is more schema-driven, while Drizzle is lightweight and flexible for Deno.

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