@velajs/vela 1.19.0 → 1.19.1

package/dist/websocket-node/node-ws-client.d.ts

@@ -1,24 +0,0 @@
-import type { WSContext } from 'hono/ws';
-import type { RoomRegistry, WsClient } from '../websocket/index';
-/**
- * Core `WsClient` over Hono's `WSContext` (node/bun/deno — no hibernation).
- * Room membership is mirrored into the shared `RoomRegistry` so broadcasts from
- * the `WsServer` reach this connection.
- */
-export declare class NodeWsClient<TData extends Record<string, unknown> = Record<string, unknown>> implements WsClient<TData> {
-    private readonly ws;
-    private readonly registry;
-    readonly path: string;
-    readonly id: string;
-    data: TData;
-    private readonly _rooms;
-    constructor(ws: WSContext, registry: RoomRegistry, path: string);
-    get rooms(): ReadonlySet<string>;
-    get raw(): unknown;
-    send(event: string, data?: unknown, id?: string): void;
-    sendRaw(payload: string): void;
-    join(room: string): void | Promise<void>;
-    leave(room: string): void | Promise<void>;
-    commit(): void;
-    close(code?: number, reason?: string): void;
-}

package/dist/websocket-node/node-ws-client.js

@@ -1,49 +0,0 @@
-/**
- * Core `WsClient` over Hono's `WSContext` (node/bun/deno — no hibernation).
- * Room membership is mirrored into the shared `RoomRegistry` so broadcasts from
- * the `WsServer` reach this connection.
- */ export class NodeWsClient {
-    ws;
-    registry;
-    path;
-    id = crypto.randomUUID();
-    data = {};
-    _rooms = new Set();
-    constructor(ws, registry, path){
-        this.ws = ws;
-        this.registry = registry;
-        this.path = path;
-    }
-    get rooms() {
-        return this._rooms;
-    }
-    get raw() {
-        return this.ws;
-    }
-    send(event, data, id) {
-        this.ws.send(JSON.stringify(id !== undefined ? {
-            id,
-            event,
-            data
-        } : {
-            event,
-            data
-        }));
-    }
-    sendRaw(payload) {
-        this.ws.send(payload);
-    }
-    join(room) {
-        this._rooms.add(room);
-        return this.registry.join(this, room);
-    }
-    leave(room) {
-        this._rooms.delete(room);
-        return this.registry.leave(this, room);
-    }
-    // In-memory registry mutates eagerly; nothing deferred to persist.
-    commit() {}
-    close(code, reason) {
-        this.ws.close(code, reason);
-    }
-}

package/dist/websocket-node/redis-live.d.ts

@@ -1,24 +0,0 @@
-import type { LiveDriver } from '../live/index';
-import type { RedisPubSubClient } from './redis-sync';
-export interface RedisLiveOptions {
-    /** Connection used to publish invalidations. */
-    pub: RedisPubSubClient;
-    /** Separate connection kept in subscriber mode. */
-    sub: RedisPubSubClient;
-    /** Channel prefix. Default `vela:live`. */
-    prefix?: string;
-}
-/**
- * Cross-instance live-invalidation driver for node/bun via Redis pub/sub —
- * the live sibling of the WebSocket `redis()` sync driver, carrying TAGS
- * instead of frames. Local-first: `dispatch` applies to this instance's
- * engine immediately (its log stamps the returned commit cursor), then fans
- * the command out so every peer re-runs ITS local subscriptions.
- *
- * Guarantees (same honesty as `redis()`): at-most-once, no cross-publisher
- * ordering, no replay. Each instance keeps its own per-process epoch, so a
- * client reconnecting onto a different instance always receives a full
- * snapshot — exactly the protocol's multi-instance-node rule. Real cursor
- * resume needs a shared ordered log (the Cloudflare DO transport).
- */
-export declare function redisLive(options: RedisLiveOptions): LiveDriver;

package/dist/websocket-node/redis-live.js

@@ -1,57 +0,0 @@
-const swallow = (op)=>{
-    void Promise.resolve(op).catch(()=>{});
-};
-/**
- * Cross-instance live-invalidation driver for node/bun via Redis pub/sub —
- * the live sibling of the WebSocket `redis()` sync driver, carrying TAGS
- * instead of frames. Local-first: `dispatch` applies to this instance's
- * engine immediately (its log stamps the returned commit cursor), then fans
- * the command out so every peer re-runs ITS local subscriptions.
- *
- * Guarantees (same honesty as `redis()`): at-most-once, no cross-publisher
- * ordering, no replay. Each instance keeps its own per-process epoch, so a
- * client reconnecting onto a different instance always receives a full
- * snapshot — exactly the protocol's multi-instance-node rule. Real cursor
- * resume needs a shared ordered log (the Cloudflare DO transport).
- */ export function redisLive(options) {
-    const prefix = options.prefix ?? 'vela:live';
-    const channel = `${prefix}:invalidate`;
-    const origin = crypto.randomUUID();
-    let sink;
-    let bound = false;
-    const onMessage = (ch, message)=>{
-        if (ch !== channel) return;
-        let cmd;
-        try {
-            cmd = JSON.parse(message);
-        } catch  {
-            return;
-        }
-        if (cmd.origin === origin) return; // our own publish — already applied locally
-        if (sink) swallow(sink.applyInvalidation(cmd));
-    };
-    return {
-        kind: 'redis',
-        bind (boundSink) {
-            sink = boundSink;
-            if (bound) return; // idempotent — never stack duplicate 'message' listeners
-            bound = true;
-            swallow(options.sub.subscribe(channel));
-            options.sub.on('message', onMessage);
-        },
-        async dispatch (cmd) {
-            swallow(options.pub.publish(channel, JSON.stringify({
-                ...cmd,
-                origin
-            })));
-            return sink?.applyInvalidation(cmd);
-        },
-        stop () {
-            if (!bound) return;
-            bound = false;
-            options.sub.off?.('message', onMessage);
-            options.sub.removeListener?.('message', onMessage);
-            swallow(options.sub.unsubscribe?.(channel));
-        }
-    };
-}

package/dist/websocket-node/redis-sync.d.ts

@@ -1,33 +0,0 @@
-import type { SyncDriver } from '../websocket/index';
-/**
- * Minimal Redis pub/sub surface (satisfied by `ioredis` / `node-redis`). Pub and
- * sub MUST be separate connections — a subscribed Redis connection cannot publish.
- * `off`/`removeListener`/`unsubscribe` are optional and used only by `stop()`.
- */
-export interface RedisPubSubClient {
-    publish(channel: string, message: string): unknown;
-    subscribe(channel: string): unknown;
-    on(event: 'message', listener: (channel: string, message: string) => void): unknown;
-    off?(event: 'message', listener: (channel: string, message: string) => void): unknown;
-    removeListener?(event: 'message', listener: (channel: string, message: string) => void): unknown;
-    unsubscribe?(channel: string): unknown;
-}
-export interface RedisSyncOptions {
-    /** Connection used to publish broadcast commands. */
-    pub: RedisPubSubClient;
-    /** Separate connection used to subscribe (kept in subscriber mode). */
-    sub: RedisPubSubClient;
-    /** Channel prefix. Default `vela:ws`. */
-    prefix?: string;
-}
-/**
- * Cross-instance sync driver for node/bun via Redis pub/sub. Local-first: every
- * `dispatch` delivers to this instance's sockets immediately, then fans the
- * command out to peers on a single broadcast channel; each peer's registry
- * filters delivery to its own local room members. The publishing instance drops
- * its own echo via an `origin` stamp.
- *
- * Guarantees: at-most-once, no ordering across publishers, no replay — a fan-out
- * bus, not a log. Pass it to `WebSocketModule.forRoot({ sync: redis({ pub, sub }) })`.
- */
-export declare function redis(options: RedisSyncOptions): SyncDriver;

package/dist/websocket-node/redis-sync.js

@@ -1,56 +0,0 @@
-const swallow = (op)=>{
-    // Redis client calls return promises that reject on transport failure; a
-    // fan-out miss must never become an unhandled rejection that crashes the app.
-    void Promise.resolve(op).catch(()=>{});
-};
-/**
- * Cross-instance sync driver for node/bun via Redis pub/sub. Local-first: every
- * `dispatch` delivers to this instance's sockets immediately, then fans the
- * command out to peers on a single broadcast channel; each peer's registry
- * filters delivery to its own local room members. The publishing instance drops
- * its own echo via an `origin` stamp.
- *
- * Guarantees: at-most-once, no ordering across publishers, no replay — a fan-out
- * bus, not a log. Pass it to `WebSocketModule.forRoot({ sync: redis({ pub, sub }) })`.
- */ export function redis(options) {
-    const prefix = options.prefix ?? 'vela:ws';
-    const channel = `${prefix}:broadcast`;
-    const origin = crypto.randomUUID();
-    let registry;
-    let bound = false;
-    const onMessage = (ch, message)=>{
-        if (ch !== channel) return;
-        let cmd;
-        try {
-            cmd = JSON.parse(message);
-        } catch  {
-            return;
-        }
-        if (cmd.origin === origin) return; // our own publish — already delivered locally
-        swallow(registry?.deliverLocal(cmd));
-    };
-    return {
-        kind: 'redis',
-        bind (reg) {
-            registry = reg;
-            if (bound) return; // idempotent — never stack duplicate 'message' listeners on re-bind
-            bound = true;
-            swallow(options.sub.subscribe(channel));
-            options.sub.on('message', onMessage);
-        },
-        dispatch (cmd) {
-            swallow(registry?.deliverLocal(cmd));
-            swallow(options.pub.publish(channel, JSON.stringify({
-                ...cmd,
-                origin
-            })));
-        },
-        stop () {
-            if (!bound) return;
-            bound = false;
-            options.sub.off?.('message', onMessage);
-            options.sub.removeListener?.('message', onMessage);
-            swallow(options.sub.unsubscribe?.(channel));
-        }
-    };
-}

package/dist/websocket-node/register-gateways.d.ts

@@ -1,20 +0,0 @@
-import type { UpgradeWebSocket } from 'hono/ws';
-import type { VelaApplication } from '../application';
-/**
- * Registers every `@WebSocketGateway` on the app's Hono instance using the
- * runtime's Hono `upgradeWebSocket` factory — the same call works on node
- * (`@hono/node-ws` / `@hono/node-server` v2), Bun (`hono/bun`), and Deno
- * (`hono/deno`). Each connection auto-joins the room from a `:id` route param
- * (or the route path), mirroring the Cloudflare DO-per-room model.
- *
- * @example
- * ```ts
- * // Node
- * const app = await VelaFactory.create(AppModule);
- * const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: app.getHonoApp() });
- * registerWebSocketGateways(app, upgradeWebSocket);
- * const server = serve({ fetch: app.fetch, port: 3000 });
- * injectWebSocket(server);
- * ```
- */
-export declare function registerWebSocketGateways(app: VelaApplication, upgradeWebSocket: UpgradeWebSocket): void;

package/dist/websocket-node/register-gateways.js

@@ -1,61 +0,0 @@
-import { WS_ROOM_REGISTRY } from "../websocket/index.js";
-import { NodeWsClient } from "./node-ws-client.js";
-function toText(data) {
-    if (typeof data === 'string') return data;
-    if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
-    // Blob / SharedArrayBuffer — binary is out of scope for the JSON envelope protocol.
-    return undefined;
-}
-/**
- * Registers every `@WebSocketGateway` on the app's Hono instance using the
- * runtime's Hono `upgradeWebSocket` factory — the same call works on node
- * (`@hono/node-ws` / `@hono/node-server` v2), Bun (`hono/bun`), and Deno
- * (`hono/deno`). Each connection auto-joins the room from a `:id` route param
- * (or the route path), mirroring the Cloudflare DO-per-room model.
- *
- * @example
- * ```ts
- * // Node
- * const app = await VelaFactory.create(AppModule);
- * const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: app.getHonoApp() });
- * registerWebSocketGateways(app, upgradeWebSocket);
- * const server = serve({ fetch: app.fetch, port: 3000 });
- * injectWebSocket(server);
- * ```
- */ export function registerWebSocketGateways(app, upgradeWebSocket) {
-    const hono = app.getHonoApp();
-    const registry = app.get(WS_ROOM_REGISTRY);
-    for (const { meta } of app.entrypoints.ofKind('websocket')){
-        const { path, dispatcher } = meta;
-        hono.get(path, upgradeWebSocket((c)=>{
-            const roomId = c.req.param('id') ?? path;
-            let client;
-            // Connection-setup barrier: messages queue behind join + handleConnection
-            // so an auth check in handleConnection runs before any message dispatches.
-            let ready = Promise.resolve();
-            const onSetupError = (err)=>{
-                void dispatcher.handleError(path, client, err);
-            };
-            return {
-                onOpen: (_evt, ws)=>{
-                    client = new NodeWsClient(ws, registry, path);
-                    registry.register(client);
-                    ready = Promise.resolve(client.join(roomId)).then(()=>dispatcher.handleOpen(path, client)).catch(onSetupError);
-                },
-                onMessage: (evt)=>{
-                    const text = toText(evt.data);
-                    if (text === undefined) return;
-                    void ready.then(()=>dispatcher.dispatchMessage(path, client, text)).catch(onSetupError);
-                },
-                onClose: (evt)=>{
-                    const code = evt.code || 1000;
-                    const reason = evt.reason || '';
-                    void Promise.resolve(dispatcher.handleClose(path, client, code, reason)).catch(onSetupError).finally(()=>registry.leaveAll(client));
-                },
-                onError: (evt)=>{
-                    void dispatcher.handleError(path, client, evt);
-                }
-            };
-        }));
-    }
-}