rwsdk 1.3.0 → 1.3.1

package/dist/use-synced-state/shim/__tests__/worker.test.d.mts

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

package/dist/use-synced-state/shim/__tests__/worker.test.mjs

@@ -0,0 +1,37 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+vi.mock("cloudflare:workers", () => {
+    class DurableObject {
+    }
+    return { DurableObject };
+});
+import { SyncedStateServer, } from "../worker.mjs";
+// This test verifies that the public rwsdk/use-synced-state/worker path, when
+// resolved through the hibernation shim, still accepts capnweb-style handler
+// signatures that read requestInfo.ctx.
+describe("use-synced-state shim", () => {
+    afterEach(() => {
+        SyncedStateServer.registerKeyHandler(null);
+        SyncedStateServer.registerSetStateHandler(null);
+        SyncedStateServer.registerGetStateHandler(null);
+        SyncedStateServer.registerSubscribeHandler(null);
+        SyncedStateServer.registerUnsubscribeHandler(null);
+        SyncedStateServer.registerIdentityExtractor(null);
+    });
+    it("wraps a legacy key handler so it can read requestInfo.ctx", async () => {
+        const keyHandler = vi.fn(async (key, _stub) => {
+            return `${key}:legacy`;
+        });
+        SyncedStateServer.registerKeyHandler(keyHandler);
+        expect(SyncedStateServer.getIdentityExtractor()).not.toBeNull();
+        const extractor = SyncedStateServer.getIdentityExtractor();
+        const identity = await extractor({
+            ctx: { userId: "42" },
+        });
+        expect(identity).toEqual({ userId: "42" });
+    });
+    it("passes through new-style handlers without identity wrapping", () => {
+        const newHandler = vi.fn(async (_key, _identity, _stub) => "ok");
+        SyncedStateServer.registerKeyHandler(newHandler);
+        expect(SyncedStateServer.getIdentityExtractor()).toBeNull();
+    });
+});

package/dist/use-synced-state/shim/client.d.ts

@@ -0,0 +1,2 @@
+export { getSyncedStateClient, onStatusChange, setSyncedStateClientForTesting, type SyncedStateClient, type SyncedStateStatus, type StatusChangeCallback, } from "../hibernation/client-core.js";
+export { useSyncedState } from "../hibernation/useSyncedState.js";

package/dist/use-synced-state/shim/client.js

@@ -0,0 +1,2 @@
+export { getSyncedStateClient, onStatusChange, setSyncedStateClientForTesting, } from "../hibernation/client-core.js";
+export { useSyncedState } from "../hibernation/useSyncedState.js";

package/dist/use-synced-state/shim/worker.d.mts

@@ -0,0 +1,2 @@
+export { SyncedStateServer } from "../hibernation/worker.mjs";
+export { syncedStateRoutes } from "../hibernation/worker.mjs";

package/dist/use-synced-state/shim/worker.mjs

@@ -0,0 +1,139 @@
+import { runWithRequestInfo } from "../../runtime/requestInfo/worker";
+import { SyncedStateServer as HibernationSyncedStateServer, } from "../hibernation/worker.mjs";
+export { SyncedStateServer } from "../hibernation/worker.mjs";
+export { syncedStateRoutes } from "../hibernation/worker.mjs";
+// Backwards-compatible wrapper that preserves the capnweb-style handler API.
+//
+// The hibernation transport captures requestInfo.ctx at WebSocket upgrade time
+// and stores it on the socket attachment. When a legacy handler is invoked,
+// we reconstruct a RequestInfo with that captured ctx and run the handler
+// inside runWithRequestInfo so existing code can keep reading requestInfo.ctx.
+const originalRegisterKeyHandler = HibernationSyncedStateServer.registerKeyHandler.bind(HibernationSyncedStateServer);
+const originalRegisterSetStateHandler = HibernationSyncedStateServer.registerSetStateHandler.bind(HibernationSyncedStateServer);
+const originalRegisterGetStateHandler = HibernationSyncedStateServer.registerGetStateHandler.bind(HibernationSyncedStateServer);
+const originalRegisterSubscribeHandler = HibernationSyncedStateServer.registerSubscribeHandler.bind(HibernationSyncedStateServer);
+const originalRegisterUnsubscribeHandler = HibernationSyncedStateServer.registerUnsubscribeHandler.bind(HibernationSyncedStateServer);
+function makeLegacyRequestInfo(identity) {
+    return {
+        request: new Request("http://internal/use-synced-state"),
+        path: "/use-synced-state",
+        params: {},
+        ctx: identity,
+        url: new URL("http://internal/use-synced-state"),
+        rw: {
+            nonce: "",
+            Document: () => null,
+            rscPayload: false,
+            ssr: false,
+            databases: new Map(),
+            scriptsToBeLoaded: new Set(),
+            entryScripts: new Set(),
+            inlineScripts: new Set(),
+            pageRouteResolved: Promise.withResolvers(),
+        },
+        cf: {
+            waitUntil: () => { },
+            passThroughOnException: () => { },
+        },
+        response: { headers: new Headers() },
+        isAction: false,
+    };
+}
+function callWithLegacyContext(identity, fn) {
+    const requestInfo = makeLegacyRequestInfo(identity);
+    return runWithRequestInfo(requestInfo, fn);
+}
+function isLegacyKeyHandler(handler) {
+    return handler.length === 2;
+}
+function isLegacySetGetHandler(handler) {
+    return handler.length === 3;
+}
+function isLegacySubscribeUnsubscribeHandler(handler) {
+    return handler.length === 2;
+}
+HibernationSyncedStateServer.registerKeyHandler = (handler) => {
+    if (!handler) {
+        originalRegisterKeyHandler(null);
+        return;
+    }
+    if (isLegacyKeyHandler(handler)) {
+        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
+            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
+        }
+        originalRegisterKeyHandler(async (key, identity, stub) => {
+            return await callWithLegacyContext(identity, () => handler(key, stub));
+        });
+    }
+    else {
+        originalRegisterKeyHandler(handler);
+    }
+};
+HibernationSyncedStateServer.registerSetStateHandler = (handler) => {
+    if (!handler) {
+        originalRegisterSetStateHandler(null);
+        return;
+    }
+    if (isLegacySetGetHandler(handler)) {
+        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
+            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
+        }
+        originalRegisterSetStateHandler((key, value, identity, stub) => {
+            callWithLegacyContext(identity, () => handler(key, value, stub));
+        });
+    }
+    else {
+        originalRegisterSetStateHandler(handler);
+    }
+};
+HibernationSyncedStateServer.registerGetStateHandler = (handler) => {
+    if (!handler) {
+        originalRegisterGetStateHandler(null);
+        return;
+    }
+    if (isLegacySetGetHandler(handler)) {
+        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
+            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
+        }
+        originalRegisterGetStateHandler((key, value, identity, stub) => {
+            callWithLegacyContext(identity, () => handler(key, value, stub));
+        });
+    }
+    else {
+        originalRegisterGetStateHandler(handler);
+    }
+};
+HibernationSyncedStateServer.registerSubscribeHandler = (handler) => {
+    if (!handler) {
+        originalRegisterSubscribeHandler(null);
+        return;
+    }
+    if (isLegacySubscribeUnsubscribeHandler(handler)) {
+        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
+            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
+        }
+        originalRegisterSubscribeHandler((key, identity, stub) => {
+            callWithLegacyContext(identity, () => handler(key, stub));
+        });
+    }
+    else {
+        originalRegisterSubscribeHandler(handler);
+    }
+};
+HibernationSyncedStateServer.registerUnsubscribeHandler = (handler) => {
+    if (!handler) {
+        originalRegisterUnsubscribeHandler(null);
+        return;
+    }
+    if (isLegacySubscribeUnsubscribeHandler(handler)) {
+        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
+            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
+        }
+        originalRegisterUnsubscribeHandler((key, identity, stub) => {
+            callWithLegacyContext(identity, () => handler(key, stub));
+        });
+    }
+    else {
+        originalRegisterUnsubscribeHandler(handler);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -113,6 +113,10 @@
       "default": "./dist/runtime/lib/realtime/durableObject.js"
     },
     "./use-synced-state/client": {
+      "rwsdk-use-synced-state-hibernation": {
+        "types": "./dist/use-synced-state/shim/client.d.ts",
+        "default": "./dist/use-synced-state/shim/client.js"
+      },
       "types": "./dist/use-synced-state/client.d.ts",
       "default": "./dist/use-synced-state/client.js"
     },
@@ -121,6 +125,10 @@
       "default": "./dist/use-synced-state/hibernation/client.js"
     },
     "./use-synced-state/worker": {
+      "rwsdk-use-synced-state-hibernation": {
+        "types": "./dist/use-synced-state/shim/worker.d.mts",
+        "workerd": "./dist/use-synced-state/shim/worker.mjs"
+      },
       "types": "./dist/use-synced-state/worker.d.mts",
       "workerd": "./dist/use-synced-state/worker.mjs"
     },