DEV Community: Aidan McAlister

How to use Prisma with Bun

Aidan McAlister — Mon, 17 Nov 2025 16:56:11 +0000

Bun is a fast JavaScript runtime that's been making waves in the developer community. It includes a bundler, test runner, and package manager all in one. In this tutorial, we'll explore how to integrate Prisma ORM with Prisma Postgres in Bun to build a simple HTTP server.

The workflow is straightforward: set up Prisma with a Prisma Postgres database, create a simple data model, and build an HTTP server that queries your database. We'll even compile it into a single executable file for deployment.

What We'll Build

In this tutorial, we'll create a simple user management system with:

Type-safe database queries using Prisma
A basic HTTP server with Bun
Seed data for development
A compiled executable for production deployment

Quick Setup

1. Create your project

mkdir bun-prisma
cd bun-prisma
bun init -y

This creates a basic Bun project with a package.json and index.ts file.

2. Install dependencies

bun add -d prisma
bun add @prisma/client

3. Initialize database

bun prisma init --db

This command does several things:

-db: Automatically configures Prisma Postgres for you
Creates a prisma/ directory with your schema.prisma file
Generates a new Prisma Postgres database
Creates a prisma.config.ts file
Sets up a .env file with your DATABASE_URL

You'll need to answer a few questions while setting up your Prisma Postgres database. Select the region closest to your location and a memorable name like "My Bun Project".

4. Configure direct connection

We're going to use a direct connection string for connecting to Prisma Postgres. To get your direct connection string:

Navigate to your recently created Prisma Postgres project dashboard
Click the API Keys tab in the project's sidebar
Click Create API key
Provide a name and click Create
Copy the connection string starting with postgres://

Update your .env file to replace the DATABASE_URL:

DATABASE_URL="your_direct_connection_string_here"

5. Define your data model

Open prisma/schema.prisma and update it to include a simple User model:

generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
}

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

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

You can learn more about the Prisma schema in the official documentation.

Setting Up Database Utilities

6. Create a database utility file

Create a db.ts file in your project root to configure PrismaClient:

import { PrismaClient } from "./generated/prisma/client";

export const prisma = new PrismaClient();

This centralizes your Prisma Client instance so you can import it anywhere in your application.

7. Create a seed script

During development, it's helpful to have test data. Create prisma/seed.ts:

import { PrismaClient } from "../generated/prisma/client";

const prisma = new PrismaClient();

async function main() {
  await prisma.user.createMany({
    data: [
      { email: "alice@example.com", name: "Alice" },
      { email: "bob@example.com", name: "Bob" },
      { email: "charlie@example.com", name: "Charlie" },
      { email: "diana@example.com", name: "Diana" },
      { email: "eve@example.com", name: "Eve" },
      { email: "frank@example.com", name: "Frank" },
      { email: "grace@example.com", name: "Grace" },
      { email: "henry@example.com", name: "Henry" },
      { email: "isabella@example.com", name: "Isabella" },
      { email: "jack@example.com", name: "Jack" },
    ],
    skipDuplicates: true,
  });

  console.log("Seed data inserted!");
}

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

8. Add the seed script to Prisma config

Update prisma.config.ts to include the seed command:

import { defineConfig, env } from 'prisma/config';

export default defineConfig({
  schema: 'prisma/schema.prisma',
  migrations: {
    path: 'prisma/migrations',
    seed: `bun run prisma/seed.ts`
  },
  engine: 'classic',
  datasource: {
    url: env('DATABASE_URL'),
  },
});

Generate Client and Run Migrations

9. Push schema to database

Now we need to migrate the schema to the actual database and generate the Prisma Client:

bunx --bun prisma migrate dev --name init

This command will:

Create the database tables based on your schema
Generate the Prisma Client in the generated/prisma directory

10. Seed the Database

Run the seed script to populate your database:

bunx --bun prisma db seed

Building Your Bun Server

11. create the HTTP server

Replace the contents of index.ts with the following code:

import { prisma } from './db'

const server = Bun.serve({
  port: 3000,
  async fetch(req) {
    const { pathname } = new URL(req.url)

    // Skip favicon route
    if (pathname === '/favicon.ico') {
      return new Response(null, { status: 204 })
    }

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

    // Count all users
    const count = await prisma.user.count()

    // Format the response with JSON
    return new Response(
      JSON.stringify({
        users: users,
        totalUsers: count,
      }),
      { headers: { 'Content-Type': 'application/json' } },
    )
  },
})

console.log(`Listening on http://localhost:${server.port}`)

This creates a simple HTTP server that fetches all users from the database and returns them as JSON along with the total count.

Running your application

Start your Bun server:

bun run index.ts

You should see Listening on http://localhost:3000 in the console. Visit http://localhost:3000 in your browser to see a JSON response with all the users in your database.

Building a Production Executable

One of Bun's coolest features is the ability to compile your TypeScript application into a single executable file. This is incredibly useful for deployment and distribution.

12. Build the Executable

bun build --compile index.ts

This creates an executable file named index (or index.exe on Windows) in your project directory.

13. Run the executable

./index

You should see the same Listening on http://localhost:3000 message, and your application will work exactly the same as before. The executable includes all dependencies and can be deployed to any compatible system without requiring Bun or Node.js to be installed.

Why use Bun executables?

Deployment: Ship a single file instead of managing dependencies
Distribution: Share your application without requiring users to install Bun
Performance: Faster startup times compared to running TypeScript files
Security: Your source code is compiled and not easily readable

Key advantages of this approach

Fast Runtime: Bun is significantly faster than Node.js for many operations, including server startup and package installation.

Type Safety: Prisma provides full type safety for your database queries, catching errors at compile time rather than runtime.

Simple Deployment: The compiled executable makes deployment straightforward - just copy one file to your server.

All-in-One Tooling: Bun includes everything you need (bundler, test runner, package manager) without additional dependencies.

Build a Next.js App with Prisma Postgres

Aidan McAlister — Tue, 30 Sep 2025 11:23:49 +0000

Introduction

This guide walks through building a Next.js 15 app with Prisma Postgres as the database. Prisma Postgres is a fully managed, serverless Postgres that integrates directly with the Prisma ORM. No separate hosting or setup needed.

You’ll connect Next.js to Prisma Postgres, run migrations, seed data, query with Prisma Client, and deploy to Vercel.

Full example here: GitHub repo.

Prerequisites

Node.js 18+
A Vercel account (for deployment)

1) Create the app

First, scaffold a new Next.js 15 project.

npx create-next-app@latest nextjs-prisma
cd nextjs-prisma

This creates a new project folder with Next.js defaults. Choose TypeScript, ESLint, Tailwind, and the App Router.

2) Install Prisma and init Prisma Postgres

Next, install Prisma and set it up with Prisma Postgres.

npm i -D prisma tsx
npm i @prisma/client @prisma/extension-accelerate
npx prisma init --db --output ../app/generated/prisma

During init, you’ll be asked to create a Prisma Postgres database. Pick a region close to your users and give it a name.

This step gives you:

a prisma/schema.prisma file
a Prisma Postgres database provisioned automatically
.env with DATABASE_URL prefilled
a generated Prisma Client in app/generated/prisma

If you’re using your own Postgres database, you can skip @prisma/extension-accelerate and provide your own DATABASE_URL.

3) Define the schema

Now define your models in the Prisma schema.

generator client {
  provider = "prisma-client"
  output   = "../app/generated/prisma"
}

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

model User {
  id    Int    @id @default(autoincrement())
  email String @unique
  name  String?
  posts Post[]
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  published Boolean  @default(false)
  authorId  Int
  author    User     @relation(fields: [authorId], references: [id])
}

This creates a User model with a one-to-many relationship to Post.

Apply the schema to your Prisma Postgres database:

npx prisma migrate dev --name init

This runs a migration and creates the corresponding tables inside Prisma Postgres.

4) Seed data

To test your app, add some initial users and posts. Create prisma/seed.ts:

import { PrismaClient } from "../app/generated/prisma/client";
const prisma = new PrismaClient();

async function main() {
  await prisma.user.create({
    data: {
      name: "Alice",
      email: "alice@prisma.io",
      posts: {
        create: [
          { title: "Join the Prisma Discord", content: "<https://pris.ly/discord>", published: true },
          { title: "Prisma on YouTube", content: "<https://pris.ly/youtube>" }
        ]
      }
    }
  });
  await prisma.user.create({
    data: {
      name: "Bob",
      email: "bob@prisma.io",
      posts: {
        create: [{ title: "Follow Prisma on Twitter", content: "<https://twitter.com/prisma>", published: true }]
      }
    }
  });
}

main();

Tell Prisma how to run the seed script by adding to package.json:

{
  "prisma": { "seed": "tsx prisma/seed.ts" }
}

Run the seed and open Prisma Studio to view data in Prisma Postgres:

npx prisma db seed
npx prisma studio

5) Create a single Prisma Client

Next.js hot reload can create multiple Prisma clients, which can exhaust connections. To prevent that, create a single shared client in lib/prisma.ts:

import { PrismaClient } from "../app/generated/prisma/client";
import { withAccelerate } from "@prisma/extension-accelerate";

const globalForPrisma = global as unknown as { prisma?: PrismaClient };

const prisma =
  globalForPrisma.prisma ??
  new PrismaClient().$extends(withAccelerate());

if (process.env.NODE_ENV !== "production") {
  globalForPrisma.prisma = prisma;
}

export default prisma;

This reuses the client in dev. In production, Prisma Postgres handles pooling and scaling automatically.

6) Read data in Server Components

With Prisma Client ready, query Prisma Postgres directly inside async Server Components.

Example home page showing all users:

// app/page.tsx
import prisma from "@/lib/prisma";

export default async function Home() {
  const users = await prisma.user.findMany();
  return (
    <div className="min-h-screen flex flex-col items-center justify-center">
      <h1 className="text-4xl font-bold mb-8">Superblog</h1>
      <ol className="list-decimal">
        {users.map(u => <li key={u.id}>{u.name}</li>)}
      </ol>
    </div>
  );
}

Posts page including authors:

// app/posts/page.tsx
import prisma from "@/lib/prisma";

export default async function Posts() {
  const posts = await prisma.post.findMany({ include: { author: true } });
  return (
    <div className="min-h-screen flex flex-col items-center justify-center">
      <h1 className="text-4xl font-bold mb-8">Posts</h1>
      <ul className="space-y-4">
        {posts.map(p => (
          <li key={p.id}>
            <strong>{p.title}</strong> by {p.author?.name ?? "Anonymous"}
          </li>
        ))}
      </ul>
    </div>
  );
}

Dynamic post detail route:

// app/posts/[id]/page.tsx
import prisma from "@/lib/prisma";
import { notFound } from "next/navigation";

export default async function Post({ params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const post = await prisma.post.findUnique({
    where: { id: Number(id) },
    include: { author: true }
  });
  if (!post) notFound();

  return (
    <article className="max-w-2xl mx-auto p-6">
      <h1 className="text-3xl font-bold">{post.title}</h1>
      <p className="text-gray-600">by {post.author?.name ?? "Anonymous"}</p>
      <div className="mt-6">{post.content || "No content available."}</div>
    </article>
  );
}

7) Create data with Server Actions

Now add a form that writes to Prisma Postgres using a Server Action.

// app/posts/new/page.tsx
import Form from "next/form";
import prisma from "@/lib/prisma";
import { revalidatePath } from "next/cache";
import { redirect } from "next/navigation";

export default function NewPost() {
  async function createPost(formData: FormData) {
    "use server";
    const title = String(formData.get("title") || "");
    const content = String(formData.get("content") || "");
    await prisma.post.create({ data: { title, content, authorId: 1 } });
    revalidatePath("/posts");
    redirect("/posts");
  }

  return (
    <div className="max-w-2xl mx-auto p-6">
      <h1 className="text-2xl font-bold mb-6">Create New Post</h1>
      <Form action={createPost} className="space-y-4">
        <input name="title" placeholder="Title" className="w-full border px-3 py-2 rounded" />
        <textarea name="content" placeholder="Content" rows={6} className="w-full border px-3 py-2 rounded" />
        <button type="submit" className="w-full bg-blue-600 text-white py-2 rounded">Create Post</button>
      </Form>
    </div>
  );
}

Server Actions run directly against Prisma Postgres, with no need for API routes.

8) Dev notes

On Next.js 15.2.0 or 15.2.1, avoid Turbopack (bug). Change your package.json dev script to "dev": "next dev".
Prisma Studio is handy for quickly viewing your Prisma Postgres data.

9) Deploy to Vercel

Finally, deploy the app with Prisma Postgres as the backing DB.

npm i -g vercel
vercel login

Update package.json so Prisma Client is generated on install:

{
  "scripts": {
    "postinstall": "prisma generate --no-engine"
  }
}

If you’re not using Prisma Postgres, remove --no-engine.

Deploy:

vercel

Vercel builds and deploys your app, while Prisma Postgres provides the globally available database — no extra hosting needed.

Docs for further reading: