Bun with PostgreSQL

🐘 Introduction to Bun with PostgreSQL

If you're building high-performance backend applications, pairing Bun — the ultra-fast JavaScript runtime — with PostgreSQL — the most powerful open-source relational database — is a killer combo. This guide walks you through how to use Bun with PostgreSQL to handle data efficiently and scalably.

⚙️ Setting Up PostgreSQL Locally

Before connecting Bun with PostgreSQL, ensure PostgreSQL is installed and running on your system. You can install it using a package manager or via Docker:

# Using Docker
docker run --name my-postgres -e POSTGRES_PASSWORD=admin -p 5432:5432 -d postgres

Now create a test database:

CREATE DATABASE bun_db;

📦 Installing PostgreSQL Client for Bun

Bun doesn't have a built-in PostgreSQL driver yet, but it works great with the lightweight npm package postgres from porsager, which is fast and simple.

# Install the postgres client
bun add postgres

🔌 Connecting Bun to PostgreSQL

Once installed, create a db.ts file to initialize your connection:

import postgres from 'postgres';

const sql = postgres({
  host: 'localhost',
  port: 5432,
  username: 'postgres',
  password: 'admin',
  database: 'bun_db'
});

export default sql;

This sets up your connection using environment-friendly credentials. You can load them from a .env file using Bun’s native support.

📄 Creating and Querying Tables

Let’s create a simple users table and insert some data:

import sql from './db.ts';

await sql`
  CREATE TABLE IF NOT EXISTS users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL
  )
`;

await sql`
  INSERT INTO users (name, email)
  VALUES ('Alice', 'alice@example.com')
`;

Now let's fetch the data:

const users = await sql`SELECT * FROM users`;
console.log(users);

🧠 Using Parameterized Queries (Avoid SQL Injection)

Always use parameterized queries to avoid SQL injection vulnerabilities. The postgres library handles this naturally:

const userId = 1;
const user = await sql`SELECT * FROM users WHERE id = ${userId}`;

📈 Performance Considerations

Bun’s event loop is extremely fast, and when paired with PostgreSQL’s efficient engine, you can handle thousands of queries per second — just make sure to:

• Reuse connections (as shown above)
• Use indexes on searchable columns
• Avoid blocking I/O in main request loops

🧪 Testing the Connection

Here's a complete minimal server that responds with users from PostgreSQL:

import { serve } from "bun";
import sql from "./db.ts";

serve({
  port: 3000,
  async fetch(req) {
    const users = await sql`SELECT * FROM users`;
    return new Response(JSON.stringify(users), {
      headers: { "Content-Type": "application/json" }
    });
  }
});

Run the app and visit http://localhost:3000 — you’ll see a JSON response with all users!

🚀 Bonus: Using Bun with Prisma or Drizzle

For more complex projects, you can use ORMs like:

• Prisma (works with Bun if transpiled)
• Drizzle ORM — lightweight and fast, with Bun support

They provide schema validation, migrations, and TypeScript safety, which is useful for large-scale applications.

✅ Final Thoughts

Using Bun with PostgreSQL lets you build lightning-fast backends without sacrificing reliability or SQL power. Whether you're building APIs, admin dashboards, or data-heavy apps, this stack delivers speed, simplicity, and full control.

As Bun matures, expect even tighter integration with PostgreSQL and other databases. Until then, the current ecosystem already gives you everything you need to build scalable data-driven apps at warp speed 🚀.