伺服器

index.ts複製

const server = Bun.serve({
  // `routes` 需要 Bun v1.2.3+
  routes: {
    // 靜態路由
    "/api/status": new Response("OK"),

    // 動態路由
    "/users/:id": req => {
      return new Response(`你好，使用者 ${req.params.id}!`);
    },

    // 按 HTTP 方法處理
    "/api/posts": {
      GET: () => new Response("帖子列表"),
      POST: async req => {
        const body = await req.json();
        return Response.json({ created: true, ...body });
      },
    },

    // 萬用字元路由，匹配所有以 "/api/" 開頭且未被其他路由匹配的請求
    "/api/*": Response.json({ message: "未找到" }, { status: 404 }),

    // 從 /blog/hello 重定向到 /blog/hello/world
    "/blog/hello": Response.redirect("/blog/hello/world"),

    // 懶載入檔案並提供服務
    "/favicon.ico": Bun.file("./favicon.ico"),
  },

  // （可選）未匹配路由的回退處理：
  // 如果 Bun 版本低於 1.2.3，則需要
  fetch(req) {
    return new Response("未找到", { status: 404 });
  },
});

console.log(`伺服器正在運行於 ${server.url}`);

import myReactSinglePageApp from "./index.html";

Bun.serve({
  routes: {
    "/": myReactSinglePageApp,
  },
});

Bun.serve({
  port: 8080, // 預設使用 $BUN_PORT、$PORT、$NODE_PORT，否則為 3000 // [!code ++]
  hostname: "mydomain.com", // 預設使用 "0.0.0.0" // [!code ++]
  fetch(req) {
    return new Response("404!");
  },
});

const server = Bun.serve({
  port: 0, // 隨機埠 // [!code ++]
  fetch(req) {
    return new Response("404!");
  },
});

// server.port 是隨機選擇的埠
console.log(server.port);

console.log(server.port); // 3000
console.log(server.url); // http://localhost:3000

bun --port=4002 server.ts

BUN_PORT=4002 bun server.ts

PORT=4002 bun server.ts

NODE_PORT=4002 bun server.ts

Bun.serve({
  unix: "/tmp/my-socket.sock", // 套接字路徑
  fetch(req) {
    return new Response(`404!`);
  },
});

Bun.serve({
  unix: "\0my-abstract-socket", // 抽象名稱空間套接字
  fetch(req) {
    return new Response(`404!`);
  },
});

Bun.serve({
  tls: {
    key: Bun.file("./key.pem"),
    cert: Bun.file("./cert.pem"),
  },
  http3: true, // [!code ++]
  fetch(req) {
    return new Response("通過 HTTP/3 你好！");
  },
});

Bun.serve({
  tls: {
    key: Bun.file("./key.pem"),
    cert: Bun.file("./cert.pem"),
  },
  http3: true,
  http1: false, // [!code ++]
  fetch(req) {
    return new Response("僅 HTTP/3");
  },
});

Bun.serve({
  tls: {
    key: Bun.file("./key.pem"),
    cert: Bun.file("./cert.pem"),
  },
  http2: true, // [!code ++]
  fetch(req) {
    return new Response("通過 HTTP/2 你好！");
  },
});

Bun.serve({
  // 30 秒（預設值為 10）
  idleTimeout: 30,

  fetch(req) {
    return new Response("Bun!");
  },
});

import type { Serve } from "bun";

export default {
  fetch(req) {
    return new Response("Bun!");
  },
} satisfies Serve.Options<undefined>;

const server = Bun.serve({
  routes: {
    "/api/version": () => Response.json({ version: "1.0.0" }),
  },
});

// 部署新路由無停機
server.reload({
  routes: {
    "/api/version": () => Response.json({ version: "2.0.0" }),
  },
});

const server = Bun.serve({
  fetch(req) {
    return new Response("Hello!");
  },
});

// 優雅停止伺服器（等待正在進行的請求完成）
await server.stop();

// 強制停止並關閉所有活躍連線
await server.stop(true);

const closed = server.closeIdleConnections();
console.log(`closed ${closed} idle connections`);

// 如果伺服器是唯一執行的東西，不阻止行程退出
server.unref();

// 恢復預設行為 - 保持行程存活
server.ref();

const server = Bun.serve({
  routes: {
    "/api/version": Response.json({ version: "v1" }),
  },
  fetch(req) {
    return new Response("v1");
  },
});

// 更新為新處理器
server.reload({
  routes: {
    "/api/version": Response.json({ version: "v2" }),
  },
  fetch(req) {
    return new Response("v2");
  },
});

const server = Bun.serve({
  async fetch(req, server) {
    // 給這個請求最多 60 秒的無活動時間，而不是預設的 10 秒
    server.timeout(req, 60);

    // 如果請求體傳送超過 60 秒，則請求將被中止
    await req.text();

    return new Response("Done!");
  },
});

Bun.serve({
  routes: {
    "/events": (req, server) => {
      // 為此流式響應停用空閒超時。
      // 否則如果 10 秒內（預設的 idleTimeout）
      // 沒有傳送位元組，連線將被關閉。
      server.timeout(req, 0);

      return new Response(
        async function* () {
          yield "data: hello\n\n";
          // 事件可以零星到達，而不會導致連線被終止
        },
        { headers: { "Content-Type": "text/event-stream" } },
      );
    },
  },
});

const server = Bun.serve({
  fetch(req, server) {
    const address = server.requestIP(req);
    if (address) {
      return new Response(`Client IP: ${address.address}, Port: ${address.port}`);
    }
    return new Response("Unknown client");
  },
});

const server = Bun.serve({
  fetch(req, server) {
    return new Response(
      `活動請求數：${server.pendingRequests}\n` + `活動 WebSocket 數：${server.pendingWebSockets}`,
    );
  },
});

const server = Bun.serve({
  fetch(req, server) {
    const chatUsers = server.subscriberCount("chat");
    return new Response(`${chatUsers} 位使用者正在聊天`);
  },
  websocket: {
    message(ws) {
      ws.subscribe("chat");
    },
  },
});

Bun.serve({
  fetch(req: Request) {
    return new Response("Bun!");
  },
  port: 3000,
});

require("http")
  .createServer((req, res) => res.end("Bun!"))
  .listen(8080);

interface Server extends Disposable {
  /**
   * 停止伺服器接受新連線。
   * @param closeActiveConnections 如果為 true，則立即終止所有連線
   * @returns 伺服器停止時解析的 Promise
   */
  stop(closeActiveConnections?: boolean): Promise<void>;

  /**
   * Close idle keep-alive connections without stopping the server.
   * @returns The number of connections closed
   */
  closeIdleConnections(): number;

  /**
   * Update handlers without restarting the server.
   * Only fetch, error, routes, and websocket can be updated.
   */
  reload(options: Serve.Options<undefined>): Server;

  /**
   * 向執行中的伺服器發出請求。
   * 用於測試或內部路由。
   */
  fetch(request: Request | string): Response | Promise<Response>;

  /**
   * 將 HTTP 請求升級為 WebSocket 連線。
   * @returns 升級成功時為 true，否則為 false
   */
  upgrade<T = undefined>(
    request: Request,
    options?: {
      headers?: Bun.HeadersInit;
      data?: T;
    },
  ): boolean;

  /**
   * 向所有訂閱了某個主題的 WebSocket 客戶端釋出訊息。
   * @returns 傳送的位元組數；如果訊息被丟棄則為 0；如果應用了背壓則為 -1
   */
  publish(
    topic: string,
    data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
    compress?: boolean,
  ): ServerWebSocketSendStatus;

  /**
   * 獲取訂閱了某個主題的 WebSocket 客戶端數量。
   */
  subscriberCount(topic: string): number;

  /**
   * 獲取客戶端 IP 地址和埠。
   * @returns 對於已關閉的請求或 Unix 套接字，傳回 null
   */
  requestIP(request: Request): SocketAddress | null;

  /**
   * 為請求設定自定義空閒超時時間。
   * @param seconds 超時時間（以秒為單位），設為 0 可停用
   */
  timeout(request: Request, seconds: number): void;

  /**
   * 伺服器執行環境保持行程處於活動狀態。
   */
  ref(): void;

  /**
   * 允許伺服器作為唯一執行中的執行環境行程退出。
   */
  unref(): void;

  /** 當前正在處理的 HTTP 請求數量 */
  readonly pendingRequests: number;

  /** 當前活動的 WebSocket 連線數量 */
  readonly pendingWebSockets: number;

  /** 完整的伺服器 URL，包括協議、主機名和埠 */
  readonly url: URL;

  /** 伺服器正在監聽的埠 */
  readonly port: number;

  /** 伺服器繫結到的主機名 */
  readonly hostname: string;

  /** 伺服器是否處於開發模式 */
  readonly development: boolean;

  /** 伺服器例項 ID */
  readonly id: string;
}

interface WebSocketHandler<T = undefined> {
  /** WebSocket 訊息的最大大小（以位元組為單位） */
  maxPayloadLength?: number;

  /** 應用背壓前排隊訊息的位元組數 */
  backpressureLimit?: number;

  /** 達到背壓限制時是否關閉連線 */
  closeOnBackpressureLimit?: boolean;

  /** 背壓解除時呼叫 */
  drain?(ws: ServerWebSocket<T>): void | Promise<void>;

  /** 空閒超時時間（以秒為單位） */
  idleTimeout?: number;

  /** 啟用按訊息進行的 deflate 壓縮 */
  perMessageDeflate?:
    | boolean
    | {
        compress?: WebSocketCompressor | boolean;
        decompress?: WebSocketCompressor | boolean;
      };

  /** 傳送 Ping 幀以保持連線處於活動狀態 */
  sendPings?: boolean;

  /** Whether ws.publish() also sends the message to the socket that published it, if subscribed */
  publishToSelf?: boolean;

  /** 連線開啟時呼叫 */
  open?(ws: ServerWebSocket<T>): void | Promise<void>;

  /** 收到訊息時呼叫 */
  message(ws: ServerWebSocket<T>, message: string | Buffer): void | Promise<void>;

  /** 連線關閉時呼叫 */
  close?(ws: ServerWebSocket<T>, code: number, reason: string): void | Promise<void>;

  /** 收到 Ping 幀時呼叫 */
  ping?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;

  /** 收到 Pong 幀時呼叫 */
  pong?(ws: ServerWebSocket<T>, data: Buffer): void | Promise<void>;
}

interface TLSOptions {
  /** 證書頒發機構鏈 */
  ca?: string | Buffer | BunFile | Array<string | Buffer | BunFile>;

  /** 伺服器證書 */
  cert?: string | Buffer | BunFile | Array<string | Buffer | BunFile>;

  /** DH 引數檔案的路徑 */
  dhParamsFile?: string;

  /** 私鑰 */
  key?: string | Buffer | BunFile | Array<string | Buffer | BunFile>;

  /** 降低 TLS 記憶體使用量 */
  lowMemoryMode?: boolean;

  /** 私鑰密碼短語 */
  passphrase?: string;

  /** OpenSSL 選項標誌 */
  secureOptions?: number;

  /** SNI 伺服器名稱 */
  serverName?: string;
}