rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/runtime/lib/realtime/protocol.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect } from "vitest";
+import { packMessage, unpackMessage } from "./protocol";
+import { MESSAGE_TYPE } from "./shared";
+describe("Realtime Protocol pack/unpack", () => {
+    const textEncoder = new TextEncoder();
+    // Helper to generate a UUID string of the correct length
+    const generateId = () => "a".repeat(36);
+    const testMessages = [
+        {
+            type: MESSAGE_TYPE.ACTION_REQUEST,
+            id: "my-action",
+            args: { foo: "bar" },
+            requestId: generateId(),
+            clientUrl: "http://localhost:3000/",
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_START,
+            id: generateId(),
+            status: 200,
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_CHUNK,
+            id: generateId(),
+            payload: textEncoder.encode("chunk data"),
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_END,
+            id: generateId(),
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_ERROR,
+            id: generateId(),
+            error: "Something went wrong",
+        },
+        {
+            type: MESSAGE_TYPE.RSC_START,
+            id: generateId(),
+            status: 200,
+        },
+        {
+            type: MESSAGE_TYPE.RSC_CHUNK,
+            id: generateId(),
+            payload: textEncoder.encode("rsc chunk"),
+        },
+        {
+            type: MESSAGE_TYPE.RSC_END,
+            id: generateId(),
+        },
+    ];
+    testMessages.forEach((message) => {
+        it(`should correctly pack and unpack a ${Object.keys(MESSAGE_TYPE).find((key) => MESSAGE_TYPE[key] === message.type) || "UNKNOWN"} message`, () => {
+            const packed = packMessage(message);
+            const unpacked = unpackMessage(packed);
+            expect(unpacked).toEqual(message);
+        });
+    });
+    describe("Error Handling", () => {
+        it("should throw an error for an unknown message type on pack", () => {
+            const invalidMessage = { type: 999 };
+            expect(() => packMessage(invalidMessage)).toThrow("Unknown message type for packing");
+        });
+        it("should throw an error for an unknown message type on unpack", () => {
+            const invalidData = new Uint8Array([99, 1, 2, 3]);
+            expect(() => unpackMessage(invalidData)).toThrow("Unknown message type for unpacking: 99");
+        });
+        it("should throw an error for an empty message on unpack", () => {
+            const emptyData = new Uint8Array([]);
+            expect(() => unpackMessage(emptyData)).toThrow("Cannot unpack empty message");
+        });
+        const invalidLengthTests = [
+            { type: MESSAGE_TYPE.ACTION_START, name: "START" },
+            { type: MESSAGE_TYPE.RSC_START, name: "START" },
+            { type: MESSAGE_TYPE.ACTION_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.RSC_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.ACTION_END, name: "END" },
+            { type: MESSAGE_TYPE.RSC_END, name: "END" },
+            { type: MESSAGE_TYPE.ACTION_ERROR, name: "ERROR" },
+        ];
+        invalidLengthTests.forEach(({ type, name }) => {
+            it(`should throw for invalid ${name} message length on unpack`, () => {
+                const invalidData = new Uint8Array([type, 1, 2, 3]); // Too short
+                expect(() => unpackMessage(invalidData)).toThrow(`Invalid ${name} message length`);
+            });
+        });
+        const invalidIdTests = [
+            { type: MESSAGE_TYPE.ACTION_START, name: "START" },
+            { type: MESSAGE_TYPE.RSC_START, name: "START" },
+            { type: MESSAGE_TYPE.ACTION_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.RSC_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.ACTION_END, name: "END" },
+            { type: MESSAGE_TYPE.RSC_END, name: "END" },
+            { type: MESSAGE_TYPE.ACTION_ERROR, name: "ERROR" },
+        ];
+        invalidIdTests.forEach(({ type, name }) => {
+            it(`should throw for invalid ID length on ${name} message pack`, () => {
+                const message = {
+                    type,
+                    id: "short-id",
+                    status: 200, // For START types
+                    payload: new Uint8Array(), // For CHUNK types
+                    error: "", // For ERROR type
+                };
+                expect(() => packMessage(message)).toThrow(`Invalid message ID length for ${name} message`);
+            });
+        });
+    });
+});

package/dist/runtime/lib/realtime/shared.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/realtime/shared.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { MESSAGE_TYPE } from "./shared";
+describe("Realtime Shared Constants", () => {
+    it("MESSAGE_TYPE should match snapshot", () => {
+        expect(MESSAGE_TYPE).toMatchInlineSnapshot(`
+      {
+        "ACTION_CHUNK": 5,
+        "ACTION_END": 6,
+        "ACTION_ERROR": 7,
+        "ACTION_REQUEST": 3,
+        "ACTION_START": 4,
+        "RSC_CHUNK": 1,
+        "RSC_END": 2,
+        "RSC_START": 0,
+      }
+    `);
+    });
+});

package/dist/runtime/lib/realtime/validateUpgradeRequest.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/realtime/validateUpgradeRequest.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { validateUpgradeRequest } from "./validateUpgradeRequest";
+describe("validateUpgradeRequest", () => {
+    it("should return valid for a correct WebSocket upgrade request", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(true);
+    });
+    it("should return invalid if Upgrade header is not 'websocket'", async () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "not-websocket",
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(400);
+            await expect(result.response?.text()).resolves.toBe("Expected WebSocket");
+        }
+    });
+    it("should return invalid if Upgrade header is missing", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(400);
+        }
+    });
+    it("should return invalid if Origin header is missing", async () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(403);
+            await expect(result.response?.text()).resolves.toBe("Invalid origin");
+        }
+    });
+    it("should return invalid if Origin does not match request URL", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+                Origin: "http://another-domain.com",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(403);
+        }
+    });
+});

package/dist/runtime/lib/realtime/worker.d.ts

@@ -1,3 +1,3 @@
 import type { RealtimeDurableObject } from "./durableObject";
 export { renderRealtimeClients } from "./renderRealtimeClients";
-export declare const realtimeRoute: (getDurableObjectNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<RealtimeDurableObject>) => import("../router").RouteDefinition<import("../../requestInfo/types").RequestInfo<any, import("../../requestInfo/types").DefaultAppContext>>;
+export declare const realtimeRoute: (getDurableObjectNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<RealtimeDurableObject>) => import("../router").RouteDefinition<import("../../worker").RequestInfo<any, import("../../worker").DefaultAppContext>>;

package/dist/runtime/lib/router.js

@@ -97,30 +97,38 @@ export function defineRoutes(routes) {
                 return undefined;
             }
             // --- Main flow ---
-            const globalMiddlewares = flattenedRoutes.filter((route) => typeof route === "function");
-            const routeDefinitions = flattenedRoutes.filter((route) => typeof route !== "function");
-            // 1. Run global middlewares
-            for (const middleware of globalMiddlewares) {
-                const result = await middleware(getRequestInfo());
-                const handled = await handleMiddlewareResult(result);
-                if (handled) {
-                    return handled;
+            let firstRouteDefinitionEncountered = false;
+            let actionHandled = false;
+            const handleAction = async () => {
+                if (!actionHandled && url.searchParams.has("__rsc_action_id")) {
+                    getRequestInfo().rw.actionResult = await rscActionHandler(request);
+                    actionHandled = true;
+                }
+            };
+            for (const route of flattenedRoutes) {
+                if (typeof route === "function") {
+                    // This is a global middleware.
+                    const result = await route(getRequestInfo());
+                    const handled = await handleMiddlewareResult(result);
+                    if (handled) {
+                        return handled; // Short-circuit
+                    }
+                    continue;
+                }
+                // This is a RouteDefinition.
+                // The first time we see one, we handle any RSC actions.
+                if (!firstRouteDefinitionEncountered) {
+                    firstRouteDefinitionEncountered = true;
+                    await handleAction();
                 }
-            }
-            // 2. Handle RSC actions
-            if (url.searchParams.has("__rsc_action_id")) {
-                getRequestInfo().rw.actionResult = await rscActionHandler(request);
-            }
-            // 3. Match and handle routes
-            for (const route of routeDefinitions) {
                 const params = matchPath(route.path, path);
                 if (!params) {
-                    continue;
+                    continue; // Not a match, keep going.
                 }
-                // Found a match: run route-specific middlewares, then the final component
+                // Found a match: run route-specific middlewares, then the final component, then stop.
                 return await runWithRequestInfoOverrides({ params }, async () => {
                     const { routeMiddlewares, componentHandler } = parseHandlers(route.handler);
-                    // 3a. Route-specific middlewares
+                    // Route-specific middlewares
                     for (const mw of routeMiddlewares) {
                         const result = await mw(getRequestInfo());
                         const handled = await handleMiddlewareResult(result);
@@ -128,7 +136,7 @@ export function defineRoutes(routes) {
                             return handled;
                         }
                     }
-                    // 3b. Final component/handler
+                    // Final component/handler
                     if (isRouteComponent(componentHandler)) {
                         const requestInfo = getRequestInfo();
                         const WrappedComponent = wrapWithLayouts(wrapHandlerToThrowResponses(componentHandler), route.layouts || [], requestInfo);
@@ -148,7 +156,11 @@ export function defineRoutes(routes) {
                     });
                 });
             }
-            // No route matched
+            // If we've gotten this far, no route was matched.
+            // We still need to handle a possible action if the app has no route definitions at all.
+            if (!firstRouteDefinitionEncountered) {
+                await handleAction();
+            }
             return new Response("Not Found", { status: 404 });
         },
     };
@@ -168,8 +180,14 @@ export function index(handler) {
 export function prefix(prefixPath, routes) {
     return routes.map((r) => {
         if (typeof r === "function") {
-            // Pass through middleware as-is
-            return r;
+            const middleware = (requestInfo) => {
+                const url = new URL(requestInfo.request.url);
+                if (url.pathname.startsWith(prefixPath)) {
+                    return r(requestInfo);
+                }
+                return;
+            };
+            return middleware;
         }
         if (Array.isArray(r)) {
             // Recursively process nested route arrays