Optimizing Node.js Applications with Bun

Last Modified: January 2, 2025

Bun is revolutionizing the JavaScript runtime environment with its impressive performance improvements and developer-friendly features. Let's explore how to optimize your Node.js applications using Bun's powerful capabilities.

Getting Started with Bun

First, install Bun on your system:

# For macOS or Linux
curl -fsSL https://bun.sh/install | bash

# Verify installation
bun --version

Converting Node.js Projects to Bun

Package Management

Replace npm/yarn commands with Bun:

# Install dependencies
bun install

# Add new dependencies
bun add express

# Remove dependencies
bun remove lodash

Running Scripts

Update your package.json scripts:

{
  "scripts": {
    "start": "bun run src/index.ts",
    "dev": "bun --hot run src/index.ts",
    "test": "bun test"
  }
}

Performance Optimizations

Fast Server Setup

Create an optimized HTTP server:

import { serve } from "bun";

const server = serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url);

    switch (url.pathname) {
      case "/":
        return new Response("Welcome to Bun!");
      case "/api/users":
        return new Response(JSON.stringify({
          users: ["John", "Jane"]
        }));
      default:
        return new Response("Not Found", { status: 404 });
    }
  },
});

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

File Operations

Utilize Bun's optimized file system operations:

const config = {
  database: {
    host: "localhost",
    port: 5432
  }
};

// Write file
await Bun.write("config.json", JSON.stringify(config));

// Read file
const data = await Bun.file("config.json").json();

// Stream large files
const file = Bun.file("large-file.txt");
const stream = file.stream();
for await (const chunk of stream) {
  // Process chunk
}

Database Optimization

Implement efficient database connections:

import { Database } from "bun:sqlite";

const db = new Database("myapp.sqlite");

// Prepared statements for better performance
const stmt = db.prepare(
  "SELECT * FROM users WHERE age > ? AND active = ?"
);

function getActiveUsers(minAge: number) {
  return stmt.all(minAge, true);
}

// Transaction support
db.transaction((age: number) => {
  const user = stmt.get(age, true);
  if (user) {
    db.run(
      "UPDATE users SET last_seen = ? WHERE id = ?",
      [new Date(), user.id]
    );
  }
})(25);

Memory Management

Efficient Memory Usage

Implement memory-efficient practices:

// Use TypedArrays for better memory management
const buffer = new Uint8Array(1024);

// Stream processing for large datasets
async function processLargeDataset() {
  const stream = Bun.file("large-dataset.json").stream();
  const decoder = new TextDecoder();

  for await (const chunk of stream) {
    const data = decoder.decode(chunk);
    // Process data in chunks
  }
}

Resource Cleanup

Implement proper resource management:

class ResourceManager {
  private resources: Set<any> = new Set();

  async acquire(resource: any) {
    this.resources.add(resource);
    return resource;
  }

  async release(resource: any) {
    if (resource.close) {
      await resource.close();
    }
    this.resources.delete(resource);
  }

  async cleanup() {
    for (const resource of this.resources) {
      await this.release(resource);
    }
  }
}

Testing and Debugging

Unit Testing

Create efficient tests using Bun's test runner:

// test/api.test.ts
import { expect, test, describe } from "bun:test";

describe("API Tests", () => {
  test("GET /api/users returns users array", async () => {
    const res = await fetch("http://localhost:3000/api/users");
    const data = await res.json();

    expect(res.status).toBe(200);
    expect(Array.isArray(data.users)).toBe(true);
  });
});

Performance Monitoring

Implement performance monitoring:

class PerformanceMonitor {
  private metrics: Map<string, number[]> = new Map();

  measure(name: string, fn: () => Promise<any>) {
    return async (...args: any[]) => {
      const start = performance.now();
      const result = await fn(...args);
      const duration = performance.now() - start;

      if (!this.metrics.has(name)) {
        this.metrics.set(name, []);
      }
      this.metrics.get(name)!.push(duration);

      return result;
    };
  }

  getMetrics() {
    const results: Record<string, { avg: number; min: number; max: number }> = {};

    for (const [name, durations] of this.metrics) {
      results[name] = {
        avg: durations.reduce((a, b) => a + b) / durations.length,
        min: Math.min(...durations),
        max: Math.max(...durations)
      };
    }

    return results;
  }
}

Production Deployment

Docker Integration

Create an optimized Docker setup:

# Dockerfile
FROM oven/bun

WORKDIR /app

COPY package.json bun.lockb ./
RUN bun install --production

COPY . .

ENV NODE_ENV=production

CMD ["bun", "run", "src/index.ts"]

Load Balancing

Implement efficient load balancing:

import { serve } from "bun";
import cluster from "cluster";
import os from "os";

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;

  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on("exit", (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork(); // Replace dead worker
  });
} else {
  serve({
    port: 3000,
    fetch(req) {
      return new Response(`Hello from worker ${process.pid}!`);
    },
  });
}

Best Practices

  1. Use TypeScript for better type safety
  2. Implement proper error handling
  3. Use Bun's native APIs when possible
  4. Optimize file operations with Bun.file
  5. Leverage Bun's built-in testing capabilities
  6. Monitor memory usage and performance
  7. Implement proper resource cleanup
  8. Use Docker for consistent deployments

By following these optimization techniques and best practices, you can significantly improve your Node.js application's performance using Bun. Remember to profile and measure performance improvements to ensure your optimizations are effective.