@lastshotlabs/bunshot 0.0.21 → 0.0.25

package/dist/server.d.ts

@@ -1,6 +1,8 @@
 import type { Server, ServerWebSocket, WebSocketHandler } from "bun";
 import { type CreateAppConfig } from "./app";
 import { type SocketData } from "./ws/index";
+import { type HeartbeatConfig } from "./lib/wsHeartbeat";
+import { type WsMessageStore, type WsMessageDefaults } from "./lib/wsMessages";
 export interface WsConfig<T extends object = object> {
     /** Override or extend the default WebSocket handler */
     handler?: WebSocketHandler<SocketData<T>>;
@@ -18,6 +20,25 @@ export interface WsConfig<T extends object = object> {
      * Defaults to 65536 (64 KB).
      */
     maxMessageSize?: number;
+    /**
+     * Heartbeat / ping-pong keepalive. Set `true` for defaults (30s interval, 10s timeout)
+     * or provide an object to customize intervals.
+     */
+    heartbeat?: boolean | HeartbeatConfig;
+    /**
+     * Presence tracking. Set `true` for defaults or provide config.
+     * When enabled, `presence_join`/`presence_leave` events are broadcast to rooms.
+     */
+    presence?: boolean | {
+        broadcastEvents?: boolean;
+    };
+    /**
+     * Message persistence. Opt rooms in via `configureRoom()`.
+     */
+    persistence?: {
+        store?: WsMessageStore;
+        defaults?: WsMessageDefaults;
+    };
 }
 export interface CreateServerConfig<T extends object = object> extends CreateAppConfig {
     port?: number;
@@ -27,5 +48,10 @@ export interface CreateServerConfig<T extends object = object> extends CreateApp
     enableWorkers?: boolean;
     /** WebSocket configuration */
     ws?: WsConfig<T>;
+    /**
+     * Maximum request body size in bytes. Defaults to the upload config limit when present
+     * (maxFileSize * maxFiles), otherwise Bun's default (128 MB).
+     */
+    maxRequestBodySize?: number;
 }
 export declare const createServer: <T extends object = object>(config: CreateServerConfig<T>) => Promise<Server<SocketData<T>>>;

package/dist/server.js

@@ -1,17 +1,44 @@
 import { createApp } from "./app";
 import { websocket as defaultWebsocket, createWsUpgradeHandler } from "./ws/index";
-import { setWsServer, handleRoomActions, cleanupSocket } from "./lib/ws";
+import { setWsServer, handleRoomActions, cleanupSocket, setPresenceEnabled } from "./lib/ws";
+import { registerSocket, deregisterSocket, handlePong, startHeartbeat, stopHeartbeat } from "./lib/wsHeartbeat";
+import { trackSocket, untrackSocket } from "./lib/wsPresence";
+import { setWsMessageStore, setWsMessageDefaults } from "./lib/wsMessages";
 import { log } from "./lib/logger";
 export const createServer = async (config) => {
     const app = await createApp(config);
     const port = Number(process.env.PORT ?? config.port ?? 3000);
     const { workersDir, enableWorkers = true, ws: wsConfig = {} } = config;
-    const { handler: userWs, upgradeHandler: wsUpgradeHandler, onRoomSubscribe, maxMessageSize = 65_536 } = wsConfig;
+    // Compute maxRequestBodySize: explicit config wins, else derive from upload config
+    let maxRequestBodySize = config.maxRequestBodySize;
+    if (maxRequestBodySize === undefined && config.upload) {
+        const maxFileSize = config.upload.maxFileSize ?? 10 * 1024 * 1024;
+        const maxFiles = config.upload.maxFiles ?? 10;
+        maxRequestBodySize = maxFileSize * maxFiles;
+    }
+    const { handler: userWs, upgradeHandler: wsUpgradeHandler, onRoomSubscribe, maxMessageSize = 65_536, heartbeat: heartbeatConfig, presence: presenceConfig, persistence: persistenceConfig, } = wsConfig;
+    // Configure presence
+    if (presenceConfig)
+        setPresenceEnabled(true);
+    // Configure message persistence
+    if (persistenceConfig) {
+        if (persistenceConfig.store)
+            setWsMessageStore(persistenceConfig.store);
+        if (persistenceConfig.defaults)
+            setWsMessageDefaults(persistenceConfig.defaults);
+    }
     const defaultOpen = defaultWebsocket.open;
     const defaultClose = defaultWebsocket.close;
     const defaultDrain = defaultWebsocket.drain;
+    const heartbeatEnabled = !!heartbeatConfig;
     const ws = {
-        open: userWs?.open ?? defaultOpen,
+        open(socket) {
+            if (heartbeatEnabled)
+                registerSocket(socket, socket.data.id);
+            if (presenceConfig)
+                trackSocket(socket.data.id, socket.data.userId);
+            (userWs?.open ?? defaultOpen)(socket);
+        },
         async message(socket, message) {
             const size = typeof message === "string" ? message.length : message.byteLength;
             if (size > maxMessageSize) {
@@ -26,10 +53,18 @@ export const createServer = async (config) => {
             }
         },
         close(socket, code, reason) {
+            if (heartbeatEnabled)
+                deregisterSocket(socket.data.id);
+            if (presenceConfig)
+                untrackSocket(socket.data.id);
             cleanupSocket(socket.data.id, socket.data.rooms);
             socket.data.rooms.clear();
             (userWs?.close ?? defaultClose)(socket, code, reason);
         },
+        pong(socket) {
+            if (heartbeatEnabled)
+                handlePong(socket.data.id);
+        },
         drain: userWs?.drain ?? defaultDrain,
     };
     let server;
@@ -42,12 +77,20 @@ export const createServer = async (config) => {
         },
         fetch: app.fetch,
         websocket: ws,
+        ...(maxRequestBodySize !== undefined ? { maxRequestBodySize } : {}),
         error(err) {
             console.error(err);
             return Response.json({ error: "Internal Server Error" }, { status: 500 });
         },
     });
     setWsServer(server);
+    // Start heartbeat after server is ready
+    if (heartbeatEnabled)
+        startHeartbeat(heartbeatConfig);
+    // Graceful shutdown — stop heartbeat alongside existing cleanup
+    const gracefulShutdown = () => { stopHeartbeat(); };
+    process.on("SIGTERM", gracefulShutdown);
+    process.on("SIGINT", gracefulShutdown);
     if (enableWorkers && workersDir) {
         const glob = new Bun.Glob("**/*.ts");
         for await (const file of glob.scan({ cwd: workersDir })) {

package/dist/ws/index.js

@@ -1,6 +1,7 @@
 import { verifyToken } from "../lib/jwt";
 import { getSession } from "../lib/session";
 import { COOKIE_TOKEN } from "../lib/constants";
+import { trackSocket, untrackSocket } from "../lib/wsPresence";
 export const createWsUpgradeHandler = (server) => async (req) => {
     let userId = null;
     try {
@@ -22,6 +23,7 @@ export const createWsUpgradeHandler = (server) => async (req) => {
 };
 export const websocket = {
     open(ws) {
+        trackSocket(ws.data.id, ws.data.userId);
         console.log(`[ws] connected: ${ws.data.id}`);
         ws.send(JSON.stringify({ event: "connected", id: ws.data.id }));
     },
@@ -30,6 +32,7 @@ export const websocket = {
         // Override ws.handler.message in WsConfig for custom message handling.
     },
     close(ws) {
+        untrackSocket(ws.data.id);
         console.log(`[ws] disconnected: ${ws.data.id}`);
     },
 };