@buenojs/bueno 0.8.9 → 0.8.11

package/dist/websocket/index.js

@@ -0,0 +1,749 @@
+/**
+ * WebSocket Helpers
+ *
+ * Utilities for WebSocket connections, pub/sub patterns,
+ * and real-time communication in Bueno applications.
+ */
+export class WebSocketServer {
+    options;
+    connections = new Map();
+    rooms = new Map();
+    messageHandlers = new Map();
+    constructor(options = {}) {
+        this.options = {
+            idleTimeout: 255,
+            maxPayloadLength: 1024 * 1024, // 1MB
+            perMessageDeflate: true,
+            ...options,
+        };
+    }
+    /**
+     * Get Bun WebSocket configuration
+     */
+    getWebSocketConfig() {
+        return {
+            idleTimeout: this.options.idleTimeout,
+            maxPayloadLength: this.options.maxPayloadLength,
+            perMessageDeflate: this.options.perMessageDeflate,
+            open: (ws) => {
+                this.connections.set(ws.data.id, ws);
+                this.options.onOpen?.(ws);
+            },
+            message: (ws, message) => {
+                let parsed;
+                if (typeof message === "string") {
+                    try {
+                        parsed = JSON.parse(message);
+                    }
+                    catch {
+                        parsed = { type: "raw", payload: message, timestamp: Date.now() };
+                    }
+                }
+                else {
+                    parsed = { type: "binary", payload: message, timestamp: Date.now() };
+                }
+                // Call global handler
+                this.options.onMessage?.(ws, parsed);
+                // Call type-specific handlers
+                const handlers = this.messageHandlers.get(parsed.type);
+                if (handlers) {
+                    for (const handler of handlers) {
+                        handler(ws, parsed);
+                    }
+                }
+            },
+            close: (ws, code, reason) => {
+                this.connections.delete(ws.data.id);
+                // Remove from all rooms
+                for (const [room, members] of this.rooms) {
+                    members.delete(ws.data.id);
+                }
+                this.options.onClose?.(ws, code, reason);
+            },
+        };
+    }
+    /**
+     * Register a message type handler
+     */
+    on(type, handler) {
+        const handlers = this.messageHandlers.get(type) ?? [];
+        handlers.push(handler);
+        this.messageHandlers.set(type, handlers);
+        return this;
+    }
+    /**
+     * Broadcast to all connections
+     */
+    broadcast(type, payload) {
+        const message = { type, payload, timestamp: Date.now() };
+        const data = JSON.stringify(message);
+        for (const ws of this.connections.values()) {
+            ws.send(data);
+        }
+    }
+    /**
+     * Send to specific connection
+     */
+    send(connectionId, type, payload) {
+        const ws = this.connections.get(connectionId);
+        if (!ws)
+            return false;
+        const message = { type, payload, timestamp: Date.now() };
+        ws.send(JSON.stringify(message));
+        return true;
+    }
+    /**
+     * Broadcast to a room
+     */
+    broadcastToRoom(room, type, payload) {
+        const members = this.rooms.get(room);
+        if (!members)
+            return;
+        const message = { type, payload, timestamp: Date.now() };
+        const data = JSON.stringify(message);
+        for (const id of members) {
+            const ws = this.connections.get(id);
+            if (ws) {
+                ws.send(data);
+            }
+        }
+    }
+    /**
+     * Join a room
+     */
+    joinRoom(connectionId, room) {
+        if (!this.rooms.has(room)) {
+            this.rooms.set(room, new Set());
+        }
+        this.rooms.get(room)?.add(connectionId);
+    }
+    /**
+     * Leave a room
+     */
+    leaveRoom(connectionId, room) {
+        this.rooms.get(room)?.delete(connectionId);
+    }
+    /**
+     * Get room members
+     */
+    getRoomMembers(room) {
+        return Array.from(this.rooms.get(room) ?? []);
+    }
+    /**
+     * Get all connection IDs
+     */
+    getConnectionIds() {
+        return Array.from(this.connections.keys());
+    }
+    /**
+     * Get connection count
+     */
+    get connectionCount() {
+        return this.connections.size;
+    }
+    /**
+     * Check if connection exists
+     */
+    hasConnection(connectionId) {
+        return this.connections.has(connectionId);
+    }
+    /**
+     * Close a connection
+     */
+    closeConnection(connectionId, code = 1000, reason = "Closed by server") {
+        const ws = this.connections.get(connectionId);
+        if (!ws)
+            return false;
+        ws.close(code, reason);
+        return true;
+    }
+    /**
+     * Close all connections
+     */
+    closeAll(code = 1000, reason = "Server shutting down") {
+        for (const ws of this.connections.values()) {
+            ws.close(code, reason);
+        }
+    }
+}
+export class WebSocketClient {
+    ws = null;
+    options;
+    reconnectAttempts = 0;
+    shouldReconnect = true;
+    messageQueue = [];
+    constructor(options) {
+        this.options = {
+            reconnect: true,
+            reconnectInterval: 1000,
+            maxReconnectAttempts: 5,
+            ...options,
+        };
+    }
+    /**
+     * Connect to WebSocket server
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.options.url, this.options.protocols);
+                this.shouldReconnect = true;
+                this.ws.onopen = () => {
+                    this.reconnectAttempts = 0;
+                    // Send queued messages
+                    while (this.messageQueue.length > 0) {
+                        const message = this.messageQueue.shift();
+                        this.ws?.send(message);
+                    }
+                    this.options.onOpen?.();
+                    resolve();
+                };
+                this.ws.onclose = (event) => {
+                    this.options.onClose?.(event);
+                    if (this.shouldReconnect && this.options.reconnect) {
+                        this.attemptReconnect();
+                    }
+                };
+                this.ws.onmessage = (event) => {
+                    let message;
+                    try {
+                        message = JSON.parse(event.data);
+                    }
+                    catch {
+                        message = {
+                            type: "raw",
+                            payload: event.data,
+                            timestamp: Date.now(),
+                        };
+                    }
+                    this.options.onMessage?.(message);
+                };
+                this.ws.onerror = (event) => {
+                    this.options.onError?.(event);
+                    reject(event);
+                };
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Attempt to reconnect
+     */
+    attemptReconnect() {
+        if (this.reconnectAttempts >= (this.options.maxReconnectAttempts ?? 5)) {
+            return;
+        }
+        this.reconnectAttempts++;
+        setTimeout(() => {
+            this.connect().catch(() => {
+                // Reconnect failed, will try again if attempts remaining
+            });
+        }, this.options.reconnectInterval);
+    }
+    /**
+     * Send a message
+     */
+    send(type, payload) {
+        const message = { type, payload, timestamp: Date.now() };
+        const data = JSON.stringify(message);
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(data);
+        }
+        else {
+            // Queue message for when connection is ready
+            this.messageQueue.push(data);
+        }
+    }
+    /**
+     * Send raw data
+     */
+    async sendRaw(data) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            if (data instanceof Blob) {
+                this.ws.send(await data.arrayBuffer());
+            }
+            else {
+                this.ws.send(data);
+            }
+        }
+    }
+    /**
+     * Close the connection
+     */
+    close(code = 1000, reason = "Client closing") {
+        this.shouldReconnect = false;
+        this.ws?.close(code, reason);
+    }
+    /**
+     * Check if connected
+     */
+    get isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Get ready state
+     */
+    get readyState() {
+        return this.ws?.readyState ?? WebSocket.CLOSED;
+    }
+}
+// ============= In-Memory Pub/Sub (Fallback) =============
+class InMemoryPubSub {
+    channels = new Map();
+    patterns = new Map();
+    async publish(channel, data) {
+        const message = {
+            channel,
+            data,
+            timestamp: Date.now(),
+        };
+        let deliveredCount = 0;
+        // Direct channel subscribers
+        const subscribers = this.channels.get(channel);
+        if (subscribers) {
+            for (const callback of subscribers) {
+                await callback(message);
+                deliveredCount++;
+            }
+        }
+        // Pattern subscribers
+        for (const [pattern, callbacks] of this.patterns) {
+            if (this.matchPattern(pattern, channel)) {
+                const patternMessage = { ...message, pattern };
+                for (const callback of callbacks) {
+                    await callback(patternMessage);
+                    deliveredCount++;
+                }
+            }
+        }
+        return deliveredCount;
+    }
+    async subscribe(channel, callback) {
+        if (!this.channels.has(channel)) {
+            this.channels.set(channel, new Set());
+        }
+        this.channels.get(channel)?.add(callback);
+        return () => {
+            this.channels.get(channel)?.delete(callback);
+        };
+    }
+    async psubscribe(pattern, callback) {
+        if (!this.patterns.has(pattern)) {
+            this.patterns.set(pattern, new Set());
+        }
+        this.patterns.get(pattern)?.add(callback);
+        return () => {
+            this.patterns.get(pattern)?.delete(callback);
+        };
+    }
+    async unsubscribe(channel) {
+        this.channels.delete(channel);
+    }
+    async punsubscribe(pattern) {
+        this.patterns.delete(pattern);
+    }
+    getChannelSubscribers(channel) {
+        return this.channels.get(channel)?.size ?? 0;
+    }
+    getPatternSubscribers(pattern) {
+        return this.patterns.get(pattern)?.size ?? 0;
+    }
+    getTotalSubscribers() {
+        let total = 0;
+        for (const subscribers of this.channels.values()) {
+            total += subscribers.size;
+        }
+        for (const subscribers of this.patterns.values()) {
+            total += subscribers.size;
+        }
+        return total;
+    }
+    async clear() {
+        this.channels.clear();
+        this.patterns.clear();
+    }
+    destroy() {
+        this.channels.clear();
+        this.patterns.clear();
+    }
+    /**
+     * Match a pattern against a channel name
+     * Supports * (match any characters) and ? (match single character)
+     */
+    matchPattern(pattern, channel) {
+        const regex = new RegExp(`^${pattern
+            .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special regex chars except * and ?
+            .replace(/\*/g, ".*") // * matches any characters
+            .replace(/\?/g, ".")}$`);
+        return regex.test(channel);
+    }
+}
+// ============= Redis Pub/Sub (Bun.redis Native) =============
+class RedisPubSub {
+    publisher = null;
+    subscriber = null;
+    url;
+    keyPrefix;
+    channelCallbacks = new Map();
+    patternCallbacks = new Map();
+    _isConnected = false;
+    reconnect;
+    reconnectInterval;
+    maxReconnectAttempts;
+    reconnectAttempts = 0;
+    constructor(config) {
+        this.url = config.url ?? "redis://localhost:6379";
+        this.keyPrefix = config.keyPrefix ?? "";
+        this.reconnect = config.reconnect ?? true;
+        this.reconnectInterval = config.reconnectInterval ?? 1000;
+        this.maxReconnectAttempts = config.maxReconnectAttempts ?? 5;
+    }
+    async connect() {
+        try {
+            // Use Bun's native Redis client
+            const { RedisClient } = await import("bun");
+            // Create separate connections for pub and sub
+            // (Subscriber connections enter a special mode and can't run other commands)
+            this.publisher = new RedisClient(this.url);
+            this.subscriber = new RedisClient(this.url);
+            this._isConnected = true;
+            this.reconnectAttempts = 0;
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to Redis: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async disconnect() {
+        const pub = this.publisher;
+        const sub = this.subscriber;
+        if (pub?.close)
+            await pub.close();
+        if (sub?.close)
+            await sub.close();
+        this._isConnected = false;
+        this.publisher = null;
+        this.subscriber = null;
+    }
+    get isConnected() {
+        return this._isConnected;
+    }
+    async publish(channel, data) {
+        if (!this._isConnected) {
+            throw new Error("Redis Pub/Sub not connected");
+        }
+        const fullChannel = this.keyPrefix + channel;
+        const message = JSON.stringify({
+            channel,
+            data,
+            timestamp: Date.now(),
+        });
+        const client = this.publisher;
+        return client.publish(fullChannel, message);
+    }
+    async subscribe(channel, callback) {
+        if (!this._isConnected) {
+            throw new Error("Redis Pub/Sub not connected");
+        }
+        const fullChannel = this.keyPrefix + channel;
+        // Store callback
+        if (!this.channelCallbacks.has(channel)) {
+            this.channelCallbacks.set(channel, new Set());
+        }
+        this.channelCallbacks.get(channel)?.add(callback);
+        // Subscribe to Redis channel
+        const client = this.subscriber;
+        // Create wrapper callback for Redis
+        const wrappedCallback = (message, redisChannel) => {
+            try {
+                const parsed = JSON.parse(message);
+                callback({
+                    channel: parsed.channel ?? channel,
+                    data: parsed.data,
+                    timestamp: parsed.timestamp ?? Date.now(),
+                });
+            }
+            catch {
+                // Handle raw string messages
+                callback({
+                    channel,
+                    data: message,
+                    timestamp: Date.now(),
+                });
+            }
+        };
+        await client.subscribe(fullChannel, wrappedCallback);
+        // Return unsubscribe function
+        return async () => {
+            this.channelCallbacks.get(channel)?.delete(callback);
+            // If no more callbacks for this channel, unsubscribe from Redis
+            if (this.channelCallbacks.get(channel)?.size === 0) {
+                this.channelCallbacks.delete(channel);
+                const unsubClient = this.subscriber;
+                await unsubClient.unsubscribe(fullChannel);
+            }
+        };
+    }
+    async psubscribe(pattern, callback) {
+        if (!this._isConnected) {
+            throw new Error("Redis Pub/Sub not connected");
+        }
+        const fullPattern = this.keyPrefix + pattern;
+        // Store callback
+        if (!this.patternCallbacks.has(pattern)) {
+            this.patternCallbacks.set(pattern, new Set());
+        }
+        this.patternCallbacks.get(pattern)?.add(callback);
+        // Subscribe to Redis pattern
+        const client = this.subscriber;
+        // Create wrapper callback for Redis
+        const wrappedCallback = (message, redisChannel, redisPattern) => {
+            try {
+                const parsed = JSON.parse(message);
+                callback({
+                    channel: parsed.channel ?? redisChannel.replace(this.keyPrefix, ""),
+                    pattern: pattern,
+                    data: parsed.data,
+                    timestamp: parsed.timestamp ?? Date.now(),
+                });
+            }
+            catch {
+                callback({
+                    channel: redisChannel.replace(this.keyPrefix, ""),
+                    pattern: pattern,
+                    data: message,
+                    timestamp: Date.now(),
+                });
+            }
+        };
+        await client.psubscribe(fullPattern, wrappedCallback);
+        // Return unsubscribe function
+        return async () => {
+            this.patternCallbacks.get(pattern)?.delete(callback);
+            // If no more callbacks for this pattern, unsubscribe from Redis
+            if (this.patternCallbacks.get(pattern)?.size === 0) {
+                this.patternCallbacks.delete(pattern);
+                const unsubClient = this.subscriber;
+                await unsubClient.punsubscribe(fullPattern);
+            }
+        };
+    }
+    async unsubscribe(channel) {
+        if (!this._isConnected)
+            return;
+        const fullChannel = this.keyPrefix + channel;
+        this.channelCallbacks.delete(channel);
+        const client = this.subscriber;
+        await client.unsubscribe(fullChannel);
+    }
+    async punsubscribe(pattern) {
+        if (!this._isConnected)
+            return;
+        const fullPattern = this.keyPrefix + pattern;
+        this.patternCallbacks.delete(pattern);
+        const client = this.subscriber;
+        await client.punsubscribe(fullPattern);
+    }
+    getChannelSubscribers(channel) {
+        return this.channelCallbacks.get(channel)?.size ?? 0;
+    }
+    getPatternSubscribers(pattern) {
+        return this.patternCallbacks.get(pattern)?.size ?? 0;
+    }
+    getTotalSubscribers() {
+        let total = 0;
+        for (const subscribers of this.channelCallbacks.values()) {
+            total += subscribers.size;
+        }
+        for (const subscribers of this.patternCallbacks.values()) {
+            total += subscribers.size;
+        }
+        return total;
+    }
+    async clear() {
+        // Unsubscribe from all channels
+        for (const channel of this.channelCallbacks.keys()) {
+            await this.unsubscribe(channel);
+        }
+        // Unsubscribe from all patterns
+        for (const pattern of this.patternCallbacks.keys()) {
+            await this.punsubscribe(pattern);
+        }
+    }
+    destroy() {
+        this.disconnect().catch(() => { });
+        this.channelCallbacks.clear();
+        this.patternCallbacks.clear();
+    }
+}
+// ============= Pub/Sub Class (Unified Interface) =============
+export class PubSub {
+    driver;
+    driverType;
+    _isConnected = false;
+    constructor(config = {}) {
+        this.driverType = config.driver ?? "memory";
+        if (this.driverType === "redis" && config.url) {
+            this.driver = new RedisPubSub(config);
+        }
+        else {
+            this.driver = new InMemoryPubSub();
+            // Memory driver is always "connected"
+            this._isConnected = true;
+        }
+    }
+    /**
+     * Connect to the pub/sub backend (Redis only)
+     */
+    async connect() {
+        if (this.driver instanceof RedisPubSub) {
+            await this.driver.connect();
+        }
+        this._isConnected = true;
+    }
+    /**
+     * Disconnect from the pub/sub backend
+     */
+    async disconnect() {
+        if (this.driver instanceof RedisPubSub) {
+            await this.driver.disconnect();
+        }
+        else {
+            this.driver.destroy();
+        }
+        this._isConnected = false;
+    }
+    /**
+     * Check if connected
+     */
+    get isConnected() {
+        return this._isConnected;
+    }
+    /**
+     * Get the driver type
+     */
+    getDriverType() {
+        return this.driverType;
+    }
+    /**
+     * Publish a message to a channel
+     * Returns the number of subscribers that received the message
+     */
+    async publish(channel, data) {
+        return this.driver.publish(channel, data);
+    }
+    /**
+     * Subscribe to a channel
+     * Returns an unsubscribe function
+     */
+    async subscribe(channel, callback) {
+        return this.driver.subscribe(channel, callback);
+    }
+    /**
+     * Subscribe to channels matching a pattern
+     * Supports * (any characters) and ? (single character)
+     * Returns an unsubscribe function
+     */
+    async psubscribe(pattern, callback) {
+        return this.driver.psubscribe(pattern, callback);
+    }
+    /**
+     * Unsubscribe all callbacks from a channel
+     */
+    async unsubscribe(channel) {
+        return this.driver.unsubscribe(channel);
+    }
+    /**
+     * Unsubscribe all callbacks from a pattern
+     */
+    async punsubscribe(pattern) {
+        return this.driver.punsubscribe(pattern);
+    }
+    /**
+     * Get subscriber count for a specific channel
+     */
+    getChannelSubscribers(channel) {
+        return this.driver.getChannelSubscribers(channel);
+    }
+    /**
+     * Get subscriber count for a specific pattern
+     */
+    getPatternSubscribers(pattern) {
+        return this.driver.getPatternSubscribers(pattern);
+    }
+    /**
+     * Get total subscriber count across all channels and patterns
+     */
+    getTotalSubscribers() {
+        return this.driver.getTotalSubscribers();
+    }
+    /**
+     * Clear all subscriptions
+     */
+    async clear() {
+        return this.driver.clear();
+    }
+    /**
+     * Destroy the pub/sub instance and release resources
+     */
+    destroy() {
+        this.driver.destroy();
+        this._isConnected = false;
+    }
+}
+// ============= Factory Functions =============
+/**
+ * Create a WebSocket server
+ */
+export function createWebSocketServer(options) {
+    return new WebSocketServer(options);
+}
+/**
+ * Create a WebSocket client
+ */
+export function createWebSocketClient(options) {
+    return new WebSocketClient(options);
+}
+/**
+ * Create a pub/sub instance
+ * @param config Configuration options including driver type and Redis URL
+ */
+export function createPubSub(config) {
+    return new PubSub(config);
+}
+/**
+ * Create a Redis pub/sub instance (convenience function)
+ */
+export function createRedisPubSub(url, options) {
+    return new PubSub({ driver: "redis", url, ...options });
+}
+/**
+ * Create an in-memory pub/sub instance (convenience function)
+ */
+export function createMemoryPubSub() {
+    return new PubSub({ driver: "memory" });
+}
+// ============= Upgrade Helper =============
+/**
+ * Check if request is a WebSocket upgrade request
+ */
+export function isWebSocketRequest(request) {
+    return request.headers.get("upgrade")?.toLowerCase() === "websocket";
+}
+/**
+ * Generate WebSocket connection ID
+ */
+export function generateConnectionId() {
+    return crypto.randomUUID();
+}
+/**
+ * Create WebSocket data for new connection
+ */
+export function createWebSocketData(data) {
+    return {
+        id: generateConnectionId(),
+        ...data,
+    };
+}
+//# sourceMappingURL=index.js.map