Production'da Bun: Neler Çalışıyor, Neler Çalışmıyor ve Neler Beni Şaşırttı

# Bun versiyonunu kontrol et
bun --version
 
# TypeScript dosyasını doğrudan çalıştır — tsconfig yok, derleme adımı yok
bun run server.ts
 
# Paketleri yükle
bun install
 
# Testleri çalıştır
bun test
 
# Production için bundle'la
bun build ./src/index.ts --outdir ./dist

# Başlangıç süresini ölçme — her birini 100 kez çalıştır
hyperfine --warmup 5 'node -e "console.log(1)"' 'bun -e "console.log(1)"'
 
# Tipik sonuçlar:
# node:  ~40ms
# bun:   ~6ms

# Temiz kurulum benchmark'ı — önce node_modules ve lockfile'ı sil
rm -rf node_modules bun.lockb package-lock.json
 
# npm'i ölç
time npm install
# Real: ~18.4s (tipik orta büyüklükte proje)
 
# bun'ı ölç
time bun install
# Real: ~2.1s

# Bombardier ile hızlı ve kirli benchmark
# Basit "Hello World" yanıtını test etme
 
# Bun sunucusu
bombardier -c 100 -d 10s http://localhost:3000
# Requests/sec: ~105,000
 
# Node.js (native http modülü)
bombardier -c 100 -d 10s http://localhost:3001
# Requests/sec: ~48,000
 
# Node.js (Express)
bombardier -c 100 -d 10s http://localhost:3002
# Requests/sec: ~15,000

// fibonacci.ts — bu motora bağlı, runtime'a bağlı değil
function fib(n: number): number {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
}
 
const start = performance.now();
console.log(fib(42));
console.log(`${(performance.now() - start).toFixed(0)}ms`);

bun run fibonacci.ts   # ~1650ms
node fibonacci.ts      # ~1580ms

# Düzgün benchmarking için hyperfine yükle
brew install hyperfine  # macOS
# veya: cargo install hyperfine
 
# Gerçek uygulamanın başlangıç + çalışmasını benchmark'la
hyperfine --warmup 3 \
  'node dist/server.js' \
  'bun src/server.ts' \
  --prepare 'sleep 0.1'
 
# HTTP sunucuları için bombardier veya wrk kullan
# Önemli: "Hello World" değil gerçekçi payload'larla test et
bombardier -c 50 -d 30s -l http://localhost:3000/api/users
 
# Bellek karşılaştırması
/usr/bin/time -v node server.js  # Linux
/usr/bin/time -l bun server.ts   # macOS

# package.json'dan tüm bağımlılıkları yükle
bun install
 
# Bağımlılık ekle
bun add express
 
# Dev bağımlılığı ekle
bun add -d vitest
 
# Bağımlılık kaldır
bun remove express
 
# Bağımlılık güncelle
bun update express
 
# Belirli versiyon yükle
bun add express@4.18.2

# Lockfile'ı okunabilir formata dök
bun bun.lockb > lockfile-dump.txt
 
# Veya yerleşik metin çıktısını kullan
bun install --yarn
# Bu bun.lockb'nin yanında bir yarn.lock oluşturur

{
  "name": "my-monorepo",
  "workspaces": ["packages/*", "apps/*"]
}

# Tüm workspace'ler için bağımlılıkları yükle
bun install
 
# Belirli workspace'te script çalıştır
bun run --filter packages/shared build
 
# Belirli workspace'e bağımlılık ekle
bun add react --filter apps/web

# Adım 1: Mevcut lockfile ve node_modules'u sil
rm -rf node_modules package-lock.json yarn.lock pnpm-lock.yaml
 
# Adım 2: Bun ile yükle
bun install
 
# Adım 3: Uygulamanın hâlâ çalıştığını doğrula
bun run dev
# veya: node dist/server.js  (Bun paket yöneticisi, Node runtime)

// Bunların hepsi Bun'da beklendiği gibi çalışır
import fs from "node:fs";
import path from "node:path";
import crypto from "node:crypto";
import { Buffer } from "node:buffer";
import { EventEmitter } from "node:events";
import { Readable, Writable } from "node:stream";
import http from "node:http";
import https from "node:https";
import { URL, URLSearchParams } from "node:url";
import os from "node:os";
import child_process from "node:child_process";

# Paketin native addon kullanıp kullanmadığını kontrol et
ls node_modules/your-package/binding.gyp  # Bu varsa native'dir

// Bu Bun'da ÇALIŞMAZ — V8'e özgü
const v8 = require("v8");
v8.serialize({ data: "test" });
 
// Bu ÇALIŞIR — Bun'ın eşdeğerini veya cross-runtime yaklaşımı kullan
const encoded = new TextEncoder().encode(JSON.stringify({ data: "test" }));

# Bun'ın yerleşik uyumluluk kontrolünü projen üzerinde çalıştır
bun --bun node_modules/.bin/your-tool
 
# --bun flag'i node_modules script'leri için bile Bun'ın runtime'ını zorlar

# Hızlı uyumluluk kontrolü — tam test suite'ini Bun altında çalıştır
bun test  # bun test runner kullanıyorsan
# veya
bun run vitest  # vitest kullanıyorsan

const server = Bun.serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url);
 
    if (url.pathname === "/") {
      return new Response("Hello from Bun!", {
        headers: { "Content-Type": "text/plain" },
      });
    }
 
    if (url.pathname === "/api/users") {
      const users = [
        { id: 1, name: "Alice" },
        { id: 2, name: "Bob" },
      ];
      return Response.json(users);
    }
 
    return new Response("Not Found", { status: 404 });
  },
});
 
console.log(`Server running at http://localhost:${server.port}`);

import { Database } from "bun:sqlite";
 
const db = new Database("app.db");
db.run(`
  CREATE TABLE IF NOT EXISTS todos (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    completed INTEGER DEFAULT 0,
    created_at TEXT DEFAULT (datetime('now'))
  )
`);
 
const server = Bun.serve({
  port: process.env.PORT || 3000,
 
  async fetch(req) {
    const url = new URL(req.url);
    const method = req.method;
 
    try {
      // GET /api/todos
      if (url.pathname === "/api/todos" && method === "GET") {
        const todos = db.query("SELECT * FROM todos ORDER BY created_at DESC").all();
        return Response.json(todos);
      }
 
      // POST /api/todos
      if (url.pathname === "/api/todos" && method === "POST") {
        const body = await req.json();
 
        if (!body.title || typeof body.title !== "string") {
          return Response.json({ error: "Title is required" }, { status: 400 });
        }
 
        const stmt = db.prepare("INSERT INTO todos (title) VALUES (?) RETURNING *");
        const todo = stmt.get(body.title);
        return Response.json(todo, { status: 201 });
      }
 
      // DELETE /api/todos/:id
      const deleteMatch = url.pathname.match(/^\/api\/todos\/(\d+)$/);
      if (deleteMatch && method === "DELETE") {
        const id = parseInt(deleteMatch[1], 10);
        db.run("DELETE FROM todos WHERE id = ?", [id]);
        return new Response(null, { status: 204 });
      }
 
      return Response.json({ error: "Not found" }, { status: 404 });
    } catch (error) {
      console.error("Request error:", error);
      return Response.json({ error: "Internal server error" }, { status: 500 });
    }
  },
});
 
console.log(`Server running on port ${server.port}`);

// Dosya okuma
const file = Bun.file("./config.json");
const text = await file.text(); // String olarak oku
const json = await file.json(); // Doğrudan JSON olarak parse et
const bytes = await file.arrayBuffer(); // ArrayBuffer olarak oku
const stream = file.stream(); // ReadableStream olarak oku
 
// Dosya metadata'sı
console.log(file.size); // Byte cinsinden boyut
console.log(file.type); // MIME tipi (ör. "application/json")
 
// Dosya yazma
await Bun.write("./output.txt", "Hello, World!");
await Bun.write("./data.json", JSON.stringify({ key: "value" }));
await Bun.write("./copy.png", Bun.file("./original.png"));
 
// Bir Response body'sini dosyaya yaz
const response = await fetch("https://example.com/data.json");
await Bun.write("./downloaded.json", response);

const server = Bun.serve({
  port: 3000,
 
  fetch(req, server) {
    const url = new URL(req.url);
 
    if (url.pathname === "/ws") {
      const upgraded = server.upgrade(req, {
        data: {
          userId: url.searchParams.get("userId"),
          joinedAt: Date.now(),
        },
      });
 
      if (!upgraded) {
        return new Response("WebSocket upgrade failed", { status: 400 });
      }
      return undefined;
    }
 
    return new Response("Use /ws for WebSocket connections");
  },
 
  websocket: {
    open(ws) {
      console.log(`Client connected: ${ws.data.userId}`);
      ws.subscribe("chat");
    },
 
    message(ws, message) {
      // Tüm subscriber'lara yayınla
      server.publish("chat", `${ws.data.userId}: ${message}`);
    },
 
    close(ws) {
      console.log(`Client disconnected: ${ws.data.userId}`);
      ws.unsubscribe("chat");
    },
  },
});

import { Database } from "bun:sqlite";
 
// Veritabanı aç veya oluştur
const db = new Database("myapp.db");
 
// Daha iyi eşzamanlı okuma performansı için WAL modu
db.exec("PRAGMA journal_mode = WAL");
 
// Tablo oluştur
db.run(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    email TEXT UNIQUE NOT NULL,
    name TEXT NOT NULL,
    created_at TEXT DEFAULT (datetime('now'))
  )
`);
 
// Prepared statement'lar (tekrar kullanılabilir, tekrarlanan sorgular için daha hızlı)
const insertUser = db.prepare("INSERT INTO users (email, name) VALUES ($email, $name) RETURNING *");
 
const findByEmail = db.prepare("SELECT * FROM users WHERE email = $email");
 
// Kullanım
const user = insertUser.get({
  $email: "alice@example.com",
  $name: "Alice",
});
console.log(user); // { id: 1, email: "alice@example.com", name: "Alice", ... }
 
// Transaction'lar
const insertMany = db.transaction((users: { email: string; name: string }[]) => {
  for (const user of users) {
    insertUser.run({ $email: user.email, $name: user.name });
  }
  return users.length;
});
 
const count = insertMany([
  { email: "bob@example.com", name: "Bob" },
  { email: "carol@example.com", name: "Carol" },
]);
console.log(`Inserted ${count} users`);

// math.test.ts
import { describe, it, expect } from "bun:test";
 
describe("math utilities", () => {
  it("adds numbers correctly", () => {
    expect(1 + 2).toBe(3);
  });
 
  it("handles floating point", () => {
    expect(0.1 + 0.2).toBeCloseTo(0.3);
  });
});

# Tüm testleri çalıştır
bun test
 
# Belirli dosyayı çalıştır
bun test math.test.ts
 
# Kalıba uyan testleri çalıştır
bun test --test-name-pattern "adds numbers"
 
# Watch modu
bun test --watch
 
# Coverage
bun test --coverage

import { describe, it, expect, mock, spyOn } from "bun:test";
import { fetchUsers } from "./api";
 
// Modül mock'la
mock.module("./database", () => ({
  query: mock(() => [{ id: 1, name: "Alice" }]),
}));
 
describe("fetchUsers", () => {
  it("returns users from database", async () => {
    const users = await fetchUsers();
    expect(users).toHaveLength(1);
    expect(users[0].name).toBe("Alice");
  });
});
 
// Nesne metoduna spy koy
describe("console", () => {
  it("tracks console.log calls", () => {
    const logSpy = spyOn(console, "log");
    console.log("test message");
    expect(logSpy).toHaveBeenCalledWith("test message");
    logSpy.mockRestore();
  });
});

# Tek bir giriş noktasını bundle'la
bun build ./src/index.ts --outdir ./dist
 
# Farklı hedefler için bundle'la
bun build ./src/index.ts --outdir ./dist --target browser
bun build ./src/index.ts --outdir ./dist --target bun
bun build ./src/index.ts --outdir ./dist --target node
 
# Minify
bun build ./src/index.ts --outdir ./dist --minify
 
# Sourcemap oluştur
bun build ./src/index.ts --outdir ./dist --sourcemap external

const result = await Bun.build({
  entrypoints: ["./src/index.ts", "./src/worker.ts"],
  outdir: "./dist",
  target: "browser",
  minify: {
    whitespace: true,
    identifiers: true,
    syntax: true,
  },
  splitting: true, // Kod bölme
  sourcemap: "external",
  external: ["react", "react-dom"], // Bunları bundle'lama
  naming: "[dir]/[name]-[hash].[ext]",
  define: {
    "process.env.NODE_ENV": JSON.stringify("production"),
  },
});
 
if (!result.success) {
  console.error("Build failed:");
  for (const log of result.logs) {
    console.error(log);
  }
  process.exit(1);
}
 
for (const output of result.outputs) {
  console.log(`${output.path} — ${output.size} bytes`);
}

// utils.ts
export function used() {
  return "I'll be in the bundle";
}
 
export function unused() {
  return "I'll be tree-shaken away";
}
 
// index.ts
import { used } from "./utils";
console.log(used());

bun build ./src/index.ts --outdir ./dist --minify
# `unused` fonksiyonu çıktıda görünmeyecek

// build-info.ts — bu dosya DERLEME ZAMANINDA çalışır, runtime'da değil
export function getBuildInfo() {
  return {
    builtAt: new Date().toISOString(),
    gitSha: require("child_process").execSync("git rev-parse --short HEAD").toString().trim(),
    nodeVersion: process.version,
  };
}

// app.ts
import { getBuildInfo } from "./build-info" with { type: "macro" };
 
// getBuildInfo() bundle zamanında çalışır
// Sonuç statik bir değer olarak satır içine alınır
const info = getBuildInfo();
console.log(`Built at ${info.builtAt}, commit ${info.gitSha}`);

# Bağımlılıkları yüklemek için Bun kullan, sonra Next.js'i çalıştırmak için Node.js kullan
bun install
bun run dev    # Aslında "dev" script'ini varsayılan olarak Node.js üzerinden çalıştırır
bun run build
bun run start

# Next.js'i Bun'ın runtime'ı altında çalışmaya zorla
bun --bun run dev

# Bun runtime ile build et
bun --bun run build
 
# Production sunucusunu Bun runtime ile başlat
bun --bun run start

{
  "scripts": {
    "dev": "next dev --turbopack",
    "build": "next build",
    "start": "next start"
  }
}

# Günlük iş akışı
bun install      # Hızlı paket kurulumu
bun run dev      # "next dev"i Node.js üzerinden çalıştırır
bun run build    # "next build"i Node.js üzerinden çalıştırır

FROM oven/bun:1 AS base
WORKDIR /app
 
# Bağımlılıkları yükle
FROM base AS deps
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
 
# Build (gerekirse)
FROM base AS build
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun run build
 
# Production
FROM base AS production
WORKDIR /app
 
# Root olarak çalıştırma
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=deps /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
COPY --from=build /app/package.json ./
 
EXPOSE 3000
CMD ["bun", "run", "dist/server.js"]

# Build aşaması: tüm bağımlılıklarla tam Bun image'ı
FROM oven/bun:1 AS builder
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun build ./src/index.ts --target bun --outdir ./dist --minify
 
# Runtime aşaması: daha küçük base image
FROM oven/bun:1-slim AS runtime
WORKDIR /app
 
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=builder /app/dist ./dist
 
EXPOSE 3000
CMD ["bun", "run", "dist/index.js"]

# Uygulamanı tek bir çalıştırılabilir dosyaya derle
bun build --compile ./src/server.ts --outfile server
 
# Çıktı bağımsız bir binary — çalıştırmak için Bun veya Node.js gerekmez
./server

# Derlenmiş binary kullanan ultra-minimal Docker image
FROM oven/bun:1 AS builder
WORKDIR /app
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile
COPY . .
RUN bun build --compile ./src/server.ts --outfile server
 
# Final image — sadece binary
FROM debian:bookworm-slim
WORKDIR /app
 
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser
USER appuser
 
COPY --from=builder /app/server ./server
 
EXPOSE 3000
CMD ["./server"]

# Node.js image'ı
docker images | grep node
# node:20-slim    ~180MB
 
# Bun image'ı
docker images | grep bun
# oven/bun:1-slim  ~130MB
 
# debian:bookworm-slim üzerinde derlenmiş binary
# ~80MB base + ~70MB binary = ~150MB toplam
 
# Alpine ile Node.js
# node:20-alpine   ~130MB + node_modules

# npm/yarn/pnpm'i bun install ile değiştir
# CI pipeline'ını değiştir:
# Önce:
npm ci
 
# Sonra:
bun install --frozen-lockfile

# Geliştirme script'lerini çalıştırmak için bun kullan
bun run dev
bun run lint
bun run format
 
# Tek seferlik script'ler için bun kullan
bun run scripts/seed-database.ts
bun run scripts/migrate.ts

# Basit test suite'leri için vitest/jest'i bun test ile değiştir
bun test
 
# Karmaşık test kurulumları için vitest'i tut
# (Testing Library, MSW, özel ortamlar)

// Yeni mikroservisler veya API'lar — ilk günden Bun ile başla
Bun.serve({
  port: 3000,
  fetch(req) {
    // Yeni servisin burada
  },
});

# Sadece kapsamlı testten sonra:
# Mevcut servisler için node'u bun ile değiştir
# Önce:
node dist/server.js
 
# Sonra:
bun dist/server.js

# .env
DATABASE_URL=postgresql://localhost:5432/myapp
API_KEY=sk-test-12345
PORT=3000

// Bunlar hiçbir import olmadan kullanılabilir
console.log(process.env.DATABASE_URL);
console.log(process.env.API_KEY);
console.log(Bun.env.PORT); // Bun'a özgü alternatif

# Bun'ın debugger'ı — VS Code ile çalışır
bun --inspect run server.ts
 
# Bun'ın inspect-brk'si — ilk satırda dur
bun --inspect-brk run server.ts

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "bun",
      "request": "launch",
      "name": "Debug Bun",
      "program": "${workspaceFolder}/src/server.ts",
      "cwd": "${workspaceFolder}",
      "stopOnEntry": false,
      "watchMode": false
    }
  ]
}

# Bağımlılık sayılarını karşılaştır
# Tipik bir Express + SQLite + WebSocket projesi:
npm ls --all | wc -l
# ~340 paket
 
# Aynı işlevsellik Bun yerleşik özellikleriyle:
bun pm ls --all | wc -l
# ~12 paket (sadece uygulama kodun)

// Production ayarları için Bun.serve() seçeneklerini kullan
Bun.serve({
  port: 3000,
 
  // Maksimum istek gövde boyutunu artır (varsayılan 128MB)
  maxRequestBodySize: 1024 * 1024 * 50, // 50MB
 
  // Daha iyi hata sayfaları için geliştirme modunu etkinleştir
  development: process.env.NODE_ENV !== "production",
 
  // Port'u yeniden kullan (sıfır kesinti yeniden başlatmalar için faydalı)
  reusePort: true,
 
  fetch(req) {
    return new Response("OK");
  },
});

// Runtime kod dönüşümü için Bun.Transpiler kullan
const transpiler = new Bun.Transpiler({
  loader: "tsx",
  target: "browser",
});
 
const code = transpiler.transformSync(`
  const App: React.FC = () => <div>Hello</div>;
  export default App;
`);

# Bun'ın bellek kullanımı flag'leri
bun --smol run server.ts  # Bellek ayak izini azalt (biraz daha yavaş)
 
# Maksimum heap boyutunu ayarla
BUN_JSC_forceRAMSize=512000000 bun run server.ts  # ~512MB limit

// Node.js 18+ fetch ve Bun'ın fetch'i belirli header'ları
// ve yönlendirmeleri nasıl işlediği konusunda biraz farklı
 
// Bun yönlendirmeleri varsayılan olarak takip eder (tarayıcılar gibi)
// Node.js fetch de yönlendirmeleri takip eder ama belirli durum kodlarıyla
// (303, 307, 308) davranış farklı olabilir
 
const response = await fetch("https://api.example.com/data", {
  redirect: "manual", // Yönlendirme işleme konusunda açık ol
});

// Bun olay döngüsü boşaldığında çıkar
// Node.js bazen kalan handle'lar yüzünden çalışmaya devam eder
 
// Bun script'in beklenmedik şekilde çıkıyorsa, bir şey
// olay döngüsünü canlı tutmuyor
 
// Bu Bun'da hemen çıkar:
setTimeout(() => {}, 0);
 
// Bu çalışmaya devam eder:
setTimeout(() => {}, 1000);
// (Bun timeout tetiklendikten sonra çıkar)

// Bun'ın kendi tsconfig varsayılanları var
// Bir projeyi Bun ve Node.js arasında paylaşıyorsan
// tsconfig.json'ında açık ol:
{
  "compilerOptions": {
    "target": "ESNext",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "types": ["bun-types"]  // Bun tip tanımlarını ekle
  }
}

# Bun tiplerini yükle
bun add -d @types/bun

# Bun'ın yerleşik watch modu
bun --watch run server.ts
 
# Bu dosya değişikliklerinde süreci yeniden başlatır
# HMR (Hot Module Replacement) değil — tam yeniden başlatma
# Ama Bun o kadar hızlı başladığı için anlık hissettiriyor

# bunfig.toml — Bun'ın yapılandırma dosyası (isteğe bağlı)
 
[install]
# Özel registry kullan
registry = "https://npm.mycompany.com"
 
# Scope'lu registry'ler
[install.scopes]
"@mycompany" = "https://npm.mycompany.com"
 
[test]
# Test yapılandırması
coverage = true
coverageReporter = ["text", "lcov"]
 
[run]
# bun run için shell
shell = "bash"