@velajs/cloudflare 1.9.0 → 1.10.1

package/dist/websocket/websocket-routing.js

@@ -1,45 +0,0 @@
-import { getMetadata } from "@velajs/vela";
-import { WS_GATEWAY_METADATA } from "@velajs/vela/websocket";
-import { roomToDurableId } from "./room-id.js";
-/** Read `@WebSocketGateway({ path, binding })` off a resolved instance (CF-hosted gateways only). */ export function collectWsGatewayRoutes(instance) {
-    const options = getMetadata(WS_GATEWAY_METADATA, instance.constructor);
-    if (!options?.path || !options?.binding) return [];
-    return [
-        {
-            path: options.path,
-            binding: options.binding
-        }
-    ];
-}
-/**
- * Registers the upgrade routes on the Worker's Hono app. Each route validates
- * the `Upgrade` header, resolves the room's Durable Object, and forwards the raw
- * request — injecting spoof-safe `x-vela-*` headers the DO reads. The DO returns
- * the `101` with the client socket.
- */ export function registerWebSocketRoutes(hono, routes) {
-    for (const route of routes){
-        hono.get(route.path, async (c)=>{
-            if (c.req.header('upgrade')?.toLowerCase() !== 'websocket') {
-                return c.text('Expected WebSocket upgrade', 426);
-            }
-            const ns = c.env[route.binding];
-            if (!ns) {
-                return c.text(`Durable Object binding '${route.binding}' is not configured`, 500);
-            }
-            const roomId = c.req.param('id') ?? route.path;
-            const stub = ns.get(roomToDurableId(ns, roomId));
-            // Strip any client-supplied x-vela-* (anti-spoof), then set server values.
-            const headers = new Headers(c.req.raw.headers);
-            headers.delete('x-vela-room');
-            headers.delete('x-vela-path');
-            headers.delete('x-vela-user');
-            headers.set('x-vela-room', roomId);
-            headers.set('x-vela-path', route.path);
-            const userId = c.get('userId');
-            if (userId) headers.set('x-vela-user', String(userId));
-            return stub.fetch(new Request(c.req.raw, {
-                headers
-            }));
-        });
-    }
-}

package/dist/websocket/websocket.durable-object.d.ts

@@ -1,15 +0,0 @@
-import { DurableObject } from 'cloudflare:workers';
-import type { Type } from '@velajs/vela';
-/**
- * Base class for the WebSocket Durable Object. The user exports a named subclass
- * (matching their `wrangler.toml` `class_name`) built from their `AppModule`:
- *
- * ```ts
- * export class ChatRoom extends VelaWebSocketDurableObject(AppModule) {}
- * ```
- *
- * It owns the raw hibernation socket lifecycle (Hono's `upgradeWebSocket` cannot
- * bridge DO hibernation) and forwards every event into the runtime-agnostic
- * `WsDispatcher` via {@link DoWebSocketHost}.
- */
-export declare function VelaWebSocketDurableObject(rootModule: Type): new (ctx: DurableObjectState, env: Record<string, unknown>) => DurableObject<Record<string, unknown>>;

package/dist/websocket/websocket.durable-object.js

@@ -1,72 +0,0 @@
-import { DurableObject } from "cloudflare:workers";
-import { buildDoRuntime } from "./do-bootstrap.js";
-import { DoWebSocketHost } from "./do-websocket-host.js";
-const PING = '{"event":"ping"}';
-const PONG = '{"event":"pong"}';
-/**
- * Base class for the WebSocket Durable Object. The user exports a named subclass
- * (matching their `wrangler.toml` `class_name`) built from their `AppModule`:
- *
- * ```ts
- * export class ChatRoom extends VelaWebSocketDurableObject(AppModule) {}
- * ```
- *
- * It owns the raw hibernation socket lifecycle (Hono's `upgradeWebSocket` cannot
- * bridge DO hibernation) and forwards every event into the runtime-agnostic
- * `WsDispatcher` via {@link DoWebSocketHost}.
- */ export function VelaWebSocketDurableObject(rootModule) {
-    return class VelaWsDurableObject extends DurableObject {
-        host;
-        ready;
-        constructor(ctx, env){
-            super(ctx, env);
-            // Application-level ping/pong answered WITHOUT waking a hibernated DO.
-            try {
-                ctx.setWebSocketAutoResponse(new WebSocketRequestResponsePair(PING, PONG));
-            } catch  {
-            // Older runtimes without auto-response — fine, protocol pings still work.
-            }
-            this.ready = ctx.blockConcurrencyWhile(async ()=>{
-                const runtime = await buildDoRuntime(rootModule, ctx, env);
-                this.host = new DoWebSocketHost(ctx, runtime.dispatcher, runtime.registry, runtime.gatewayPaths);
-            });
-        }
-        async fetch(request) {
-            await this.ready;
-            if (request.headers.get('upgrade')?.toLowerCase() !== 'websocket') {
-                return new Response('Expected WebSocket upgrade', {
-                    status: 426
-                });
-            }
-            const { 0: client, 1: server } = new WebSocketPair();
-            const url = new URL(request.url);
-            // Headers are primary (carry auth + multi-gateway routing); fall back to the
-            // DO's own name (set via idFromName(room)) and the single gateway path so a
-            // plain `stub.fetch(request)` forward still works.
-            const roomId = request.headers.get('x-vela-room') ?? this.ctx.id.name ?? url.pathname;
-            const path = request.headers.get('x-vela-path') ?? this.host.defaultPath() ?? url.pathname;
-            const userId = request.headers.get('x-vela-user') || undefined;
-            this.host.accept(server, path, roomId, userId);
-            return new Response(null, {
-                status: 101,
-                webSocket: client
-            });
-        }
-        async webSocketMessage(ws, message) {
-            await this.ready;
-            await this.host.onMessage(ws, message);
-        }
-        async webSocketClose(ws, code, reason) {
-            await this.ready;
-            await this.host.onClose(ws, code, reason);
-        }
-        async webSocketError(ws, error) {
-            await this.ready;
-            await this.host.onError(ws, error);
-        }
-        /** DO RPC — server-initiated broadcast forwarded from a Worker (see `broadcastToRoom`). */ async broadcast(cmd) {
-            await this.ready;
-            this.host.broadcast(cmd);
-        }
-    };
-}

package/dist/websocket/ws-server-holder.d.ts

@@ -1,16 +0,0 @@
-import type { BroadcastOperator, WsServer } from '@velajs/vela/websocket';
-/**
- * Late-bound `WsServer`. Provided as `WS_SERVER` (one per DI container, i.e. per
- * Durable Object instance), then pointed at the ctx-backed server once the DO
- * builds. Gateways inject it via `@WebSocketServer()`; it throws if used before
- * a runtime binds it (e.g. from the stateless Worker isolate).
- */
-export declare class WsServerHolder implements WsServer {
-    private target?;
-    setTarget(server: WsServer): void;
-    private get resolved();
-    emit(event: string, data?: unknown): void | Promise<void>;
-    to(room: string): BroadcastOperator;
-    in(room: string): BroadcastOperator;
-    except(room: string): BroadcastOperator;
-}

package/dist/websocket/ws-server-holder.js

@@ -1,34 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { Injectable } from "@velajs/vela";
-export class WsServerHolder {
-    target;
-    setTarget(server) {
-        this.target = server;
-    }
-    get resolved() {
-        if (!this.target) {
-            throw new Error('WebSocket server is only available inside a WebSocket Durable Object. To ' + 'push from a Worker HTTP handler, use broadcastToRoom(namespace, room, ...).');
-        }
-        return this.target;
-    }
-    emit(event, data) {
-        return this.resolved.emit(event, data);
-    }
-    to(room) {
-        return this.resolved.to(room);
-    }
-    in(room) {
-        return this.resolved.in(room);
-    }
-    except(room) {
-        return this.resolved.except(room);
-    }
-}
-WsServerHolder = _ts_decorate([
-    Injectable()
-], WsServerHolder);