createBunServer

createBunServer(app, options) devuelve { fetch, websocket } para expandir en Bun.serve: fetch atiende HTTP y hace el upgrade de los canales Socket con server.upgrade, y websocket conecta cada peer al hub con el WebSocket nativo de Bun. Registra además la IP de cada conexión (server.requestIP()), que leen context.clientAddress y rateLimit.

Es lo que usa la salida de meeko build --adapter bun (.meeko/output/bun/index.js). A diferencia de Node, no cierra el servidor ni instala la política de fallos del proceso: el host llama a server.stop() y a handleProcessErrors.

Uso#

import { createServerApp, handleProcessErrors } from "@meekojs/meeko/server";
import { createBunAssetReader, createBunServer } from "@meekojs/meeko/bun";

const app = await createServerApp({
  manifest, load, runtime, production: true,
  assets: createBunAssetReader({ root: new URL("./client/", import.meta.url), assets: manifest.assets ?? {} }),
});
const server = Bun.serve({ hostname: "0.0.0.0", port: 3000, ...createBunServer(app, { publicOrigin: "https://example.com" }) });
handleProcessErrors(app, { close: async () => { await server.stop(); await app.close(); } });

Tipo#

function createBunServer(app: ServerApp, options?: BunServerOptions): BunServeHandlers

interface BunServerOptions {
	readonly publicOrigin?: string
	readonly platform?: ServerPlatform
	readonly onError?: (error: unknown, requestId: string) => void
	readonly maxPayloadLength?: number
	readonly backpressureLimit?: number
	readonly idleTimeout?: number
	readonly sendPings?: boolean
}

interface BunServeHandlers {
	fetch(request: Request, server: BunServerLike): Promise<Response | undefined>
	readonly websocket: BunWebSocketHandler
}

Parámetros#

createBunServer(app, options?):

Valor devuelto#

Un BunServeHandlers:

Ejemplos#

Construir y ejecutar la salida de Bun#

npx meeko build --adapter bun
npx meeko preview --adapter bun                 # lanza bun sobre la salida
MEEKO_HOST=0.0.0.0 MEEKO_PORT=3000 bun .meeko/output/bun/index.js

index.js incluye @meekojs/meeko y las dependencias del servidor: copie la carpeta entera, sin node_modules. El build y el prerender se siguen ejecutando con Node.

Un contenedor de Bun#

FROM oven/bun:1.4
WORKDIR /app
COPY .meeko/output/bun ./
ENV MEEKO_HOST=0.0.0.0 MEEKO_PORT=3000
EXPOSE 3000
CMD ["bun", "index.js"]

server.host y server.port de meeko.config.ts sólo se aplican a Node: en Bun use MEEKO_HOST y MEEKO_PORT (o PORT).

Junto a otras rutas de Bun.serve#

const meeko = createBunServer(app);
Bun.serve({
  port: 3000,
  websocket: meeko.websocket,
  fetch(request, server) {
    if (new URL(request.url).pathname === "/healthz") return new Response("ok");
    return meeko.fetch(request, server);
  },
});

El handler websocket ignora los sockets que no abrió Meeko.

Errores comunes#

Usarlo fuera de Bun#

// node server.ts
createBunAssetReader({ root, assets }).get("/assets/entry.js", request);

Error: The Meeko Bun adapter requires the Bun runtime. meeko preview --adapter bun lanza bun; si no está en el PATH, falla con un mensaje explícito.

bun .meeko/output/bun/index.js

Un límite que no es un entero positivo#

Bun.serve({ port: 3000, ...createBunServer(app, { maxPayloadLength: 0 }) });

RangeError: Invalid maxPayloadLength (o Invalid backpressureLimit, Invalid idleTimeout).

Bun.serve({ port: 3000, ...createBunServer(app, { maxPayloadLength: 16 * 1024 }) });

Sin handleProcessErrors en un host propio#

Bun.serve({ port: 3000, ...createBunServer(app) });
setTimeout(() => { throw new Error("tarea programada"); }, 1000);

El proceso termina con el error sin pasar por onError ni cerrar las conexiones: createBunServer no instala la política processErrors.

const server = Bun.serve({ port: 3000, ...createBunServer(app) });
handleProcessErrors(app, { close: async () => { await server.stop(); await app.close(); } });

Un MEEKO_TRUST_PROXY no válido#

MEEKO_TRUST_PROXY=on bun .meeko/output/bun/index.js

El arranque se detiene con TypeError: MEEKO_TRUST_PROXY must be true, false or the number of trusted proxies (1-99), or cloudflare, not "on": createBunServer comprueba la variable al crearse.

MEEKO_TRUST_PROXY=1 bun .meeko/output/bun/index.js

Notas#

• Socket en Bun. WebSocket nativo de Bun.serve: maxPayloadLength corta los frames antes del hub (que además responde 1009 por encima de su propio límite), los mensajes binarios se cierran con 1003 y la compresión está desactivada. Un rechazo de sesión o autorización hace el upgrade y cierra con 4401 o 4403.
• Señales. La salida generada detiene Bun.serve y cierra la aplicación ante SIGINT y SIGTERM, y aplica processErrors; en un host propio, hágalo usted.
• Fallos del proceso. Bun conserva el requestId de la petición en las excepciones, no en los rechazos.
• IP. server.requestIP() da la IP de la conexión; tras un proxy, MEEKO_TRUST_PROXY.
• CSP y cabeceras (desde 1.7). server.contentSecurityPolicy y server.headers se aplican igual que en Node.
• Conformidad. pnpm run conformance:bun construye la aplicación de prueba con este adaptador y la ejecuta con Bun sin fuentes ni node_modules.

Relacionado#

• createBunAssetReaderSirve con Bun.file sólo los archivos del build listados en el manifiesto de assets, con ETag, HEAD, 304 y la política de caché de Meeko.
• handleProcessErrorsAplica a un host propio la política processErrors de server/runtime.ts para los rechazos sin manejar y las excepciones no capturadas fuera de una petición.
• createServerAppCrea la aplicación de servidor portable (páginas, API, RPC, Socket, assets, sesiones y middleware) a partir del manifiesto del build y un cargador de módulos.
• serveNodeSirve una aplicación de Meeko con el servidor HTTP de Node, sus canales Socket con ws, el cierre ordenado ante señales y la política de fallos del proceso.
• serverEl adaptador de meeko build (node, bun, deno, cloudflare o static) con sus opciones y, desde 1.7, la CSP y las cabeceras de las respuestas en los adaptadores con servidor.
• BunMeeko como framework full-stack
• Conformidad entre adaptadoresMeeko como framework full-stack