دليل Bun 2.0 الشامل: بيئة تشغيل JavaScript الكل-في-واحد لعام 2026

curl -fsSL https://bun.sh/install | bash

brew install oven-sh/bun/bun

bun --version
# 2.x.x

bun upgrade

mkdir bun-demo && cd bun-demo
bun init

bun run index.ts
# Hello via Bun!

# تثبيت جميع الاعتماديات من package.json
bun install
 
# إضافة اعتمادية
bun add zod
 
# إضافة اعتمادية تطوير
bun add -d @types/node
 
# إزالة اعتمادية
bun remove zod

bun install --yarn
# يُنشئ yarn.lock بجانب bun.lockb

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

# تثبيت جميع اعتماديات مساحات العمل
bun install
 
# تشغيل سكربت في مساحة عمل محددة
bun run --filter @myorg/api start

interface User {
  id: number;
  name: string;
  email: string;
}
 
function greet(user: User): string {
  return `Hello, ${user.name}! Your email is ${user.email}.`;
}
 
const user: User = {
  id: 1,
  name: "أحمد",
  email: "ahmed@example.com",
};
 
console.log(greet(user));

bun run types-demo.ts
# Hello, أحمد! Your email is ahmed@example.com.

// كتابة ملف
await Bun.write("output.txt", "Hello from Bun!");
 
// قراءة ملف
const file = Bun.file("output.txt");
const text = await file.text();
console.log(text); // "Hello from Bun!"
 
// الحصول على بيانات الملف الوصفية
console.log(file.size);  // بالبايت
console.log(file.type);  // نوع MIME

# .env
DATABASE_URL=postgres://localhost:5432/mydb
API_KEY=secret123

// الوصول مباشرة — لا حاجة لاستيراد dotenv
console.log(Bun.env.DATABASE_URL);
console.log(Bun.env.API_KEY);

// تجزئة كلمة مرور (bcrypt تحت الغطاء)
const hash = await Bun.password.hash("my-secure-password");
 
// التحقق من كلمة مرور
const isValid = await Bun.password.verify("my-secure-password", hash);
console.log(isValid); // true

import { Database } from "bun:sqlite";
 
const db = new Database("myapp.db");
 
// إنشاء جدول
db.run(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL,
    created_at TEXT DEFAULT (datetime('now'))
  )
`);
 
// إدخال بيانات
const insert = db.prepare("INSERT INTO users (name, email) VALUES (?, ?)");
insert.run("أحمد", "ahmed@example.com");
insert.run("سارة", "sara@example.com");
 
// استعلام البيانات
const users = db.query("SELECT * FROM users").all();
console.log(users);

// تجزئة سريعة
const hash = Bun.hash("hello world");
console.log(hash);
 
// تجزئة تشفيرية
const hasher = new Bun.CryptoHasher("sha256");
hasher.update("hello world");
console.log(hasher.digest("hex"));

// server.ts
Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("Hello from Bun!");
  },
});
 
console.log("Server running at http://localhost:3000");

bun run server.ts

// router.ts
Bun.serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url);
 
    if (url.pathname === "/" && req.method === "GET") {
      return Response.json({ message: "Welcome to the API" });
    }
 
    if (url.pathname === "/health" && req.method === "GET") {
      return Response.json({ status: "ok", uptime: process.uptime() });
    }
 
    return new Response("Not Found", { status: 404 });
  },
});

Bun.serve({
  port: 3000,
  async fetch(req) {
    if (req.method === "POST" && new URL(req.url).pathname === "/users") {
      const body = await req.json();
      // معالجة الجسم...
      return Response.json(
        { message: "User created", user: body },
        { status: 201 }
      );
    }
    return new Response("Not Found", { status: 404 });
  },
});

mkdir bun-tasks-api && cd bun-tasks-api
bun init
mkdir -p src/handlers tests

// src/types.ts
export interface Task {
  id: number;
  title: string;
  description: string | null;
  completed: boolean;
  created_at: string;
  updated_at: string;
}
 
export interface CreateTaskInput {
  title: string;
  description?: string;
}
 
export interface UpdateTaskInput {
  title?: string;
  description?: string;
  completed?: boolean;
}

// src/db.ts
import { Database } from "bun:sqlite";
 
const db = new Database("tasks.db");
 
// تفعيل وضع WAL لأداء أفضل في التزامن
db.run("PRAGMA journal_mode = WAL");
 
// إنشاء الجداول
db.run(`
  CREATE TABLE IF NOT EXISTS tasks (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    description TEXT,
    completed INTEGER DEFAULT 0,
    created_at TEXT DEFAULT (datetime('now')),
    updated_at TEXT DEFAULT (datetime('now'))
  )
`);
 
export default db;

// src/handlers/tasks.ts
import db from "../db";
import type { CreateTaskInput, UpdateTaskInput, Task } from "../types";
 
export function getAllTasks(): Task[] {
  return db.query("SELECT * FROM tasks ORDER BY created_at DESC").all() as Task[];
}
 
export function getTaskById(id: number): Task | null {
  return db.query("SELECT * FROM tasks WHERE id = ?").get(id) as Task | null;
}
 
export function createTask(input: CreateTaskInput): Task {
  const stmt = db.prepare(
    "INSERT INTO tasks (title, description) VALUES (?, ?) RETURNING *"
  );
  return stmt.get(input.title, input.description ?? null) as Task;
}
 
export function updateTask(id: number, input: UpdateTaskInput): Task | null {
  const existing = getTaskById(id);
  if (!existing) return null;
 
  const title = input.title ?? existing.title;
  const description = input.description ?? existing.description;
  const completed = input.completed !== undefined
    ? (input.completed ? 1 : 0)
    : existing.completed;
 
  const stmt = db.prepare(`
    UPDATE tasks 
    SET title = ?, description = ?, completed = ?, updated_at = datetime('now')
    WHERE id = ?
    RETURNING *
  `);
  return stmt.get(title, description, completed, id) as Task;
}
 
export function deleteTask(id: number): boolean {
  const result = db.run("DELETE FROM tasks WHERE id = ?", [id]);
  return result.changes > 0;
}

// src/router.ts
import {
  getAllTasks,
  getTaskById,
  createTask,
  updateTask,
  deleteTask,
} from "./handlers/tasks";
 
export async function handleRequest(req: Request): Promise<Response> {
  const url = new URL(req.url);
  const path = url.pathname;
  const method = req.method;
 
  // رؤوس CORS
  const headers = {
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
    "Access-Control-Allow-Headers": "Content-Type",
  };
 
  if (method === "OPTIONS") {
    return new Response(null, { status: 204, headers });
  }
 
  // GET /api/tasks
  if (path === "/api/tasks" && method === "GET") {
    const tasks = getAllTasks();
    return Response.json({ data: tasks }, { headers });
  }
 
  // GET /api/tasks/:id
  const taskMatch = path.match(/^\/api\/tasks\/(\d+)$/);
  if (taskMatch && method === "GET") {
    const task = getTaskById(Number(taskMatch[1]));
    if (!task) {
      return Response.json(
        { error: "Task not found" },
        { status: 404, headers }
      );
    }
    return Response.json({ data: task }, { headers });
  }
 
  // POST /api/tasks
  if (path === "/api/tasks" && method === "POST") {
    const body = await req.json();
    if (!body.title || typeof body.title !== "string") {
      return Response.json(
        { error: "Title is required" },
        { status: 400, headers }
      );
    }
    const task = createTask(body);
    return Response.json({ data: task }, { status: 201, headers });
  }
 
  // PUT /api/tasks/:id
  if (taskMatch && method === "PUT") {
    const body = await req.json();
    const task = updateTask(Number(taskMatch[1]), body);
    if (!task) {
      return Response.json(
        { error: "Task not found" },
        { status: 404, headers }
      );
    }
    return Response.json({ data: task }, { headers });
  }
 
  // DELETE /api/tasks/:id
  if (taskMatch && method === "DELETE") {
    const deleted = deleteTask(Number(taskMatch[1]));
    if (!deleted) {
      return Response.json(
        { error: "Task not found" },
        { status: 404, headers }
      );
    }
    return Response.json({ message: "Task deleted" }, { headers });
  }
 
  return Response.json({ error: "Not Found" }, { status: 404, headers });
}

// src/index.ts
import { handleRequest } from "./router";
 
const server = Bun.serve({
  port: Bun.env.PORT ? Number(Bun.env.PORT) : 3000,
  fetch: handleRequest,
});
 
console.log(`Tasks API running at http://localhost:${server.port}`);

bun run src/index.ts

# إنشاء مهمة
curl -X POST http://localhost:3000/api/tasks \
  -H "Content-Type: application/json" \
  -d '{"title": "تعلّم Bun", "description": "إكمال دليل Bun التطبيقي"}'
 
# عرض جميع المهام
curl http://localhost:3000/api/tasks
 
# تحديث مهمة
curl -X PUT http://localhost:3000/api/tasks/1 \
  -H "Content-Type: application/json" \
  -d '{"completed": true}'
 
# حذف مهمة
curl -X DELETE http://localhost:3000/api/tasks/1

// tests/tasks.test.ts
import { describe, it, expect, beforeAll, afterAll } from "bun:test";
 
const BASE_URL = "http://localhost:3000";
let createdTaskId: number;
 
beforeAll(async () => {
  // بدء الخادم للاختبار
  const module = await import("../src/index");
});
 
describe("Tasks API", () => {
  it("should create a task", async () => {
    const res = await fetch(`${BASE_URL}/api/tasks`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        title: "Test Task",
        description: "A test task",
      }),
    });
    expect(res.status).toBe(201);
    const json = await res.json();
    expect(json.data.title).toBe("Test Task");
    createdTaskId = json.data.id;
  });
 
  it("should list all tasks", async () => {
    const res = await fetch(`${BASE_URL}/api/tasks`);
    expect(res.status).toBe(200);
    const json = await res.json();
    expect(json.data).toBeInstanceOf(Array);
    expect(json.data.length).toBeGreaterThan(0);
  });
 
  it("should get a task by ID", async () => {
    const res = await fetch(`${BASE_URL}/api/tasks/${createdTaskId}`);
    expect(res.status).toBe(200);
    const json = await res.json();
    expect(json.data.id).toBe(createdTaskId);
  });
 
  it("should update a task", async () => {
    const res = await fetch(`${BASE_URL}/api/tasks/${createdTaskId}`, {
      method: "PUT",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ completed: true }),
    });
    expect(res.status).toBe(200);
    const json = await res.json();
    expect(json.data.completed).toBe(1);
  });
 
  it("should return 400 for missing title", async () => {
    const res = await fetch(`${BASE_URL}/api/tasks`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({}),
    });
    expect(res.status).toBe(400);
  });
 
  it("should return 404 for non-existent task", async () => {
    const res = await fetch(`${BASE_URL}/api/tasks/99999`);
    expect(res.status).toBe(404);
  });
});

# تشغيل جميع الاختبارات
bun test
 
# تشغيل ملف اختبار محدد
bun test tests/tasks.test.ts
 
# وضع المراقبة
bun test --watch
 
# مع التغطية
bun test --coverage

# تجميع ملف للمتصفح
bun build ./src/client.ts --outdir ./dist
 
# تجميع لتوافق Node.js
bun build ./src/index.ts --target node --outdir ./dist
 
# تجميع لـ Bun
bun build ./src/index.ts --target bun --outdir ./dist

// build.ts
const result = await Bun.build({
  entrypoints: ["./src/index.ts"],
  outdir: "./dist",
  target: "bun",
  minify: true,
  splitting: true,
  sourcemap: "external",
});
 
if (!result.success) {
  console.error("Build failed:");
  for (const log of result.logs) {
    console.error(log);
  }
  process.exit(1);
}
 
console.log(`Build complete: ${result.outputs.length} files`);

bun build ./src/index.ts --compile --outfile tasks-api

./tasks-api
# Tasks API running at http://localhost:3000

// ws-server.ts
Bun.serve({
  port: 3001,
  fetch(req, server) {
    // ترقية طلب HTTP إلى WebSocket
    if (server.upgrade(req)) {
      return; // الترقية ناجحة
    }
    return new Response("WebSocket server", { status: 200 });
  },
  websocket: {
    open(ws) {
      console.log("Client connected");
      ws.subscribe("chat");
    },
    message(ws, message) {
      // البث لجميع المشتركين
      ws.publish("chat", `User: ${message}`);
    },
    close(ws) {
      console.log("Client disconnected");
      ws.unsubscribe("chat");
    },
  },
});
 
console.log("WebSocket server running on ws://localhost:3001");

{
  "name": "bun-tasks-api",
  "scripts": {
    "dev": "bun --watch run src/index.ts",
    "start": "bun run src/index.ts",
    "build": "bun build src/index.ts --compile --outfile dist/tasks-api",
    "test": "bun test",
    "test:watch": "bun test --watch",
    "lint": "bunx @biomejs/biome check ./src",
    "db:seed": "bun run scripts/seed.ts"
  }
}

bunx create-next-app my-app
bunx prisma migrate dev
bunx @biomejs/biome check ./src

FROM oven/bun:2 AS base
WORKDIR /app
 
# تثبيت الاعتماديات
COPY package.json bun.lockb ./
RUN bun install --frozen-lockfile --production
 
# نسخ المصدر
COPY src/ src/
 
# التشغيل
EXPOSE 3000
CMD ["bun", "run", "src/index.ts"]

docker build -t bun-tasks-api .
docker run -p 3000:3000 bun-tasks-api

# البناء على جهازك
bun build src/index.ts --compile --outfile tasks-api
 
# النسخ إلى الخادم والتشغيل
scp tasks-api user@server:/opt/app/
ssh user@server "chmod +x /opt/app/tasks-api && /opt/app/tasks-api"

# fly.toml
app = "bun-tasks-api"
 
[build]
  dockerfile = "Dockerfile"
 
[http_service]
  internal_port = 3000
  force_https = true
 
[[vm]]
  size = "shared-cpu-1x"
  memory = "256mb"

fly launch
fly deploy

bun run --smol src/index.ts  # يقلل استهلاك الذاكرة على حساب بعض الأداء