rwsdk 1.0.0-beta.5 → 1.0.0-beta.50

package/dist/runtime/client/navigationCache.test.js

@@ -0,0 +1,469 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createDefaultNavigationCacheStorage, evictOldGenerationCaches, getCachedNavigationResponse, onNavigationCommit, preloadFromLinkTags, preloadNavigationUrl, } from "./navigationCache";
+describe("navigationCache", () => {
+    let mockCacheStorage;
+    let mockCache;
+    let mockFetch;
+    let mockSessionStorage;
+    // Local type for requestIdleCallback to avoid depending on global declarations
+    let mockRequestIdleCallback;
+    beforeEach(() => {
+        // Reset module state between tests
+        vi.resetModules();
+        // Mock Cache
+        mockCache = {
+            put: vi.fn().mockResolvedValue(undefined),
+            match: vi.fn().mockResolvedValue(undefined),
+            delete: vi.fn().mockResolvedValue(true),
+            add: vi.fn(),
+            addAll: vi.fn(),
+            keys: vi.fn(),
+            matchAll: vi.fn(),
+        };
+        // Mock CacheStorage
+        mockCacheStorage = {
+            open: vi.fn().mockResolvedValue(mockCache),
+            delete: vi.fn().mockResolvedValue(true),
+            keys: vi.fn().mockResolvedValue([]),
+            has: vi.fn(),
+            match: vi.fn(),
+        };
+        // Mock fetch
+        mockFetch = vi.fn().mockResolvedValue(new Response("test response", {
+            status: 200,
+            headers: { "content-type": "text/html" },
+        }));
+        // Mock sessionStorage
+        mockSessionStorage = {
+            getItem: vi.fn().mockReturnValue(null),
+            setItem: vi.fn(),
+            removeItem: vi.fn(),
+            clear: vi.fn(),
+            key: vi.fn(),
+            length: 0,
+        };
+        // Mock requestIdleCallback to execute callback asynchronously for testing
+        let idleCallback = null;
+        mockRequestIdleCallback = vi.fn((callback) => {
+            idleCallback = callback;
+            // Execute after current I/O callbacks
+            setImmediate(() => {
+                if (idleCallback) {
+                    idleCallback();
+                    idleCallback = null;
+                }
+            });
+            return 1;
+        });
+        // Setup global mocks
+        globalThis.window = {
+            isSecureContext: true,
+            location: { origin: "https://example.com" },
+            caches: mockCacheStorage,
+            fetch: mockFetch,
+            sessionStorage: mockSessionStorage,
+            crypto: {
+                randomUUID: () => "test-uuid-123",
+            },
+        };
+        globalThis.requestIdleCallback = mockRequestIdleCallback;
+    });
+    describe("createDefaultNavigationCacheStorage", () => {
+        it("should create a cache storage wrapper", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const storage = createDefaultNavigationCacheStorage(env);
+            expect(storage).toBeDefined();
+            const cache = await storage.open("test-cache");
+            expect(mockCacheStorage.open).toHaveBeenCalledWith("test-cache");
+            expect(cache).toBeDefined();
+        });
+        it("should return undefined if no caches available", () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: undefined,
+                fetch: mockFetch,
+            };
+            const storage = createDefaultNavigationCacheStorage(env);
+            expect(storage).toBeUndefined();
+        });
+    });
+    describe("preloadNavigationUrl", () => {
+        it("should cache a successful response", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            await preloadNavigationUrl(url, env);
+            expect(mockFetch).toHaveBeenCalled();
+            expect(mockCacheStorage.open).toHaveBeenCalled();
+            expect(mockCache.put).toHaveBeenCalled();
+        });
+        it("should not cache error responses (status >= 400)", async () => {
+            const errorFetch = vi
+                .fn()
+                .mockResolvedValue(new Response("error", { status: 404 }));
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: errorFetch,
+            };
+            const url = new URL("https://example.com/test");
+            await preloadNavigationUrl(url, env);
+            expect(errorFetch).toHaveBeenCalled();
+            expect(mockCache.put).not.toHaveBeenCalled();
+        });
+        it("should skip cross-origin URLs", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://other-origin.com/test");
+            await preloadNavigationUrl(url, env);
+            expect(mockFetch).not.toHaveBeenCalled();
+            expect(mockCache.put).not.toHaveBeenCalled();
+        });
+        it("should add __rsc query parameter", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            await preloadNavigationUrl(url, env);
+            const fetchCall = mockFetch.mock.calls[0];
+            const request = fetchCall[0];
+            const requestUrl = new URL(request.url);
+            expect(requestUrl.searchParams.has("__rsc")).toBe(true);
+        });
+        it("should add x-prefetch header", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            await preloadNavigationUrl(url, env);
+            const fetchCall = mockFetch.mock.calls[0];
+            const request = fetchCall[0];
+            expect(request.headers.get("x-prefetch")).toBe("true");
+        });
+        it("should use custom cacheStorage when provided", async () => {
+            const customCache = {
+                put: vi.fn().mockResolvedValue(undefined),
+                match: vi.fn().mockResolvedValue(undefined),
+            };
+            const customStorage = {
+                open: vi.fn().mockResolvedValue(customCache),
+                delete: vi.fn().mockResolvedValue(true),
+                keys: vi.fn().mockResolvedValue([]),
+            };
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            await preloadNavigationUrl(url, env, customStorage);
+            expect(customStorage.open).toHaveBeenCalled();
+            expect(customCache.put).toHaveBeenCalled();
+            expect(mockCacheStorage.open).not.toHaveBeenCalled();
+        });
+        it("should handle errors gracefully", async () => {
+            const errorFetch = vi.fn().mockRejectedValue(new Error("Network error"));
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: errorFetch,
+            };
+            const url = new URL("https://example.com/test");
+            // Should not throw
+            await expect(preloadNavigationUrl(url, env)).resolves.toBeUndefined();
+        });
+    });
+    describe("getCachedNavigationResponse", () => {
+        it("should return cached response if found", async () => {
+            const cachedResponse = new Response("cached", { status: 200 });
+            mockCache.match.mockResolvedValue(cachedResponse);
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            const result = await getCachedNavigationResponse(url, env);
+            expect(result).toBe(cachedResponse);
+            expect(mockCache.match).toHaveBeenCalled();
+        });
+        it("should return undefined if not cached", async () => {
+            mockCache.match.mockResolvedValue(undefined);
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            const result = await getCachedNavigationResponse(url, env);
+            expect(result).toBeUndefined();
+        });
+        it("should check global cacheStorage if not provided", async () => {
+            const cachedResponse = new Response("cached", { status: 200 });
+            const customCache = {
+                put: vi.fn(),
+                match: vi.fn().mockResolvedValue(cachedResponse),
+            };
+            const customStorage = {
+                open: vi.fn().mockResolvedValue(customCache),
+                delete: vi.fn(),
+                keys: vi.fn().mockResolvedValue([]),
+            };
+            // Set global cache storage
+            globalThis.__rsc_cacheStorage = customStorage;
+            const url = new URL("https://example.com/test");
+            const result = await getCachedNavigationResponse(url);
+            expect(result).toBe(cachedResponse);
+            expect(customStorage.open).toHaveBeenCalled();
+            // Cleanup
+            delete globalThis.__rsc_cacheStorage;
+        });
+        it("should add __rsc query parameter", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            await getCachedNavigationResponse(url, env);
+            const matchCall = mockCache.match.mock.calls[0];
+            const request = matchCall[0];
+            const requestUrl = new URL(request.url);
+            expect(requestUrl.searchParams.has("__rsc")).toBe(true);
+        });
+        it("should skip cross-origin URLs", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://other-origin.com/test");
+            const result = await getCachedNavigationResponse(url, env);
+            expect(result).toBeUndefined();
+            expect(mockCache.match).not.toHaveBeenCalled();
+        });
+        it("should handle errors gracefully", async () => {
+            mockCache.match.mockRejectedValue(new Error("Cache error"));
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            // Should not throw
+            const result = await getCachedNavigationResponse(url, env);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe("evictOldGenerationCaches", () => {
+        it("should delete old generation caches", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            // Get the actual tabId that will be used
+            const url = new URL("https://example.com/test");
+            await preloadNavigationUrl(url, env);
+            const openCall = mockCacheStorage.open.mock.calls[0];
+            const cacheName = openCall[0];
+            const tabIdMatch = cacheName.match(/^rsc-x-prefetch:rwsdk:([^:]+):\d+$/);
+            const tabId = tabIdMatch ? tabIdMatch[1] : "test-uuid-123";
+            // Increment generation to 2 by calling onNavigationCommit twice
+            onNavigationCommit(env);
+            onNavigationCommit(env);
+            // Mock cache names matching the actual tabId
+            const allCacheNames = [
+                `rsc-x-prefetch:rwsdk:${tabId}:0`,
+                `rsc-x-prefetch:rwsdk:${tabId}:1`,
+                `rsc-x-prefetch:rwsdk:${tabId}:2`,
+                "rsc-x-prefetch:rwsdk:other-tab:0",
+            ];
+            mockCacheStorage.keys.mockResolvedValue(allCacheNames);
+            await evictOldGenerationCaches(env);
+            // Wait for the cleanup to execute
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            // Should delete generations 0 and 1, but not 2 (current) or other-tab
+            expect(mockCacheStorage.delete).toHaveBeenCalledWith(`rsc-x-prefetch:rwsdk:${tabId}:0`);
+            expect(mockCacheStorage.delete).toHaveBeenCalledWith(`rsc-x-prefetch:rwsdk:${tabId}:1`);
+            expect(mockCacheStorage.delete).not.toHaveBeenCalledWith(`rsc-x-prefetch:rwsdk:${tabId}:2`);
+            expect(mockCacheStorage.delete).not.toHaveBeenCalledWith("rsc-x-prefetch:rwsdk:other-tab:0");
+        });
+        it("should use custom cacheStorage when provided", async () => {
+            // Get the actual tabId that will be used
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            await preloadNavigationUrl(url, env);
+            const openCall = mockCacheStorage.open.mock.calls[0];
+            const cacheName = openCall[0];
+            const tabIdMatch = cacheName.match(/^rsc-x-prefetch:rwsdk:([^:]+):\d+$/);
+            const tabId = tabIdMatch ? tabIdMatch[1] : "test-uuid-123";
+            const customStorage = {
+                open: vi.fn(),
+                delete: vi.fn().mockResolvedValue(true),
+                keys: vi
+                    .fn()
+                    .mockResolvedValue([
+                    `rsc-x-prefetch:rwsdk:${tabId}:0`,
+                    `rsc-x-prefetch:rwsdk:${tabId}:1`,
+                ]),
+            };
+            // Increment generation so there are old caches to delete
+            onNavigationCommit();
+            await evictOldGenerationCaches(undefined, customStorage);
+            // Wait for the cleanup to execute
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            expect(customStorage.keys).toHaveBeenCalled();
+            expect(customStorage.delete).toHaveBeenCalled();
+        });
+        it("should handle errors gracefully", async () => {
+            mockCacheStorage.keys.mockRejectedValue(new Error("Cache error"));
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            // Should not throw
+            await expect(evictOldGenerationCaches(env)).resolves.toBeUndefined();
+            // Wait for requestIdleCallback to execute
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        });
+    });
+    describe("onNavigationCommit", () => {
+        it("should increment generation and evict old caches", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            mockCacheStorage.keys.mockResolvedValue([]);
+            onNavigationCommit(env);
+            // Wait for eviction to complete
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            expect(mockRequestIdleCallback).toHaveBeenCalled();
+        });
+    });
+    describe("preloadFromLinkTags", () => {
+        it("should preload URLs from x-prefetch link tags", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            // Create a mock document with x-prefetch links
+            const mockDoc = {
+                querySelectorAll: vi.fn().mockReturnValue([
+                    {
+                        getAttribute: () => "/page1",
+                    },
+                    {
+                        getAttribute: () => "/page2",
+                    },
+                ]),
+            };
+            await preloadFromLinkTags(mockDoc, env);
+            // Should have called preloadNavigationUrl for each link
+            expect(mockFetch).toHaveBeenCalled();
+        });
+        it("should skip non-route-like hrefs (not starting with /)", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const mockDoc = {
+                querySelectorAll: vi.fn().mockReturnValue([
+                    {
+                        getAttribute: () => "https://example.com/page1",
+                    },
+                    {
+                        getAttribute: () => "/page2",
+                    },
+                ]),
+            };
+            await preloadFromLinkTags(mockDoc, env);
+            // Should only preload /page2, not the absolute URL
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
+        it("should use custom cacheStorage when provided", async () => {
+            const customCache = {
+                put: vi.fn().mockResolvedValue(undefined),
+                match: vi.fn(),
+            };
+            const customStorage = {
+                open: vi.fn().mockResolvedValue(customCache),
+                delete: vi.fn(),
+                keys: vi.fn().mockResolvedValue([]),
+            };
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const mockDoc = {
+                querySelectorAll: vi.fn().mockReturnValue([
+                    {
+                        getAttribute: () => "/page1",
+                    },
+                ]),
+            };
+            await preloadFromLinkTags(mockDoc, env, customStorage);
+            expect(customStorage.open).toHaveBeenCalled();
+            expect(customCache.put).toHaveBeenCalled();
+        });
+    });
+    describe("cache name generation", () => {
+        it("should generate cache names with correct format", async () => {
+            const env = {
+                isSecureContext: true,
+                origin: "https://example.com",
+                caches: mockCacheStorage,
+                fetch: mockFetch,
+            };
+            const url = new URL("https://example.com/test");
+            await preloadNavigationUrl(url, env);
+            const openCall = mockCacheStorage.open.mock.calls[0];
+            const cacheName = openCall[0];
+            expect(cacheName).toMatch(/^rsc-x-prefetch:rwsdk:[^:]+:\d+$/);
+        });
+    });
+});

package/dist/runtime/client/types.d.ts

@@ -1,13 +1,34 @@
-import type { CallServerCallback } from "react-server-dom-webpack/client.browser";
 export type { HydrationOptions } from "react-dom/client";
-export type { CallServerCallback } from "react-server-dom-webpack/client.browser";
-export type ActionResponse<Result> = {
+export type CallServerCallback = <Result>(id: null | string, args: null | unknown[], source?: "action" | "navigation" | "query", method?: "GET" | "POST") => Promise<Result | undefined>;
+export type RscActionResponse<Result> = {
     node: React.ReactNode;
     actionResult: Result;
 };
+export type ActionResponseData = {
+    status: number;
+    headers: {
+        location: string | null;
+    };
+};
+export type ActionResponseMeta = {
+    __rw_action_response: ActionResponseData;
+};
+export declare function isActionResponse(value: unknown): value is ActionResponseMeta;
 export type TransportContext = {
-    setRscPayload: <Result>(v: Promise<ActionResponse<Result>>) => void;
+    setRscPayload: <Result>(v: Promise<RscActionResponse<Result>>) => void;
     handleResponse?: (response: Response) => boolean;
+    /**
+     * Optional callback invoked after a new RSC payload has been committed on the client.
+     * This is useful for features like client-side navigation that want to run logic
+     * after hydration/updates, e.g. warming navigation caches.
+     */
+    onHydrated?: () => void;
+    /**
+     * Optional callback invoked when an action returns a Response.
+     * Return true to signal that the response has been handled and
+     * default behaviour (e.g. redirects) should be skipped.
+     */
+    onActionResponse?: (actionResponse: ActionResponseData) => boolean | void;
 };
 export type Transport = (context: TransportContext) => CallServerCallback;
-export type CreateCallServer = (context: TransportContext) => <Result>(id: null | string, args: null | unknown[]) => Promise<Result>;
+export type CreateCallServer = (context: TransportContext) => <Result>(id: null | string, args: null | unknown[], source?: "action" | "navigation" | "query", method?: "GET" | "POST") => Promise<Result | undefined>;

package/dist/runtime/client/types.js

@@ -1 +1,8 @@
-export {};
+// import type { CallServerCallback } from "react-server-dom-webpack/client.browser";
+export function isActionResponse(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "__rw_action_response" in value &&
+        typeof value.__rw_action_response === "object" &&
+        value.__rw_action_response !== null);
+}

package/dist/runtime/entries/no-react-server-ssr-bridge.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("RedwoodSDK: SSR bridge was resolved with 'react-server' condition. This is a bug - the SSR bridge should be intercepted by the esbuild plugin before reaching package.json exports. Please report this issue at https://github.com/redwoodjs/sdk/issues.");

package/dist/runtime/entries/no-react-server.js

@@ -1,2 +1,4 @@
 "use strict";
-throw new Error("rwsdk: 'react-server' is not supported in this environment");
+throw new Error("RedwoodSDK: A client-only module was incorrectly resolved with the 'react-server' condition.\n\n" +
+    "This error occurs when modules like 'rwsdk/client', 'rwsdk/__ssr', or 'rwsdk/__ssr_bridge' are being imported in a React Server Components context.\n\n" +
+    "For detailed troubleshooting steps, see: https://docs.rwsdk.com/guides/troubleshooting#react-server-components-configuration-errors");

package/dist/runtime/entries/react-server-only.js

@@ -1,2 +1,2 @@
 "use strict";
-throw new Error("rwsdk: 'react-server' import condition needs to be used in this environment");
+throw new Error("RedwoodSDK: 'react-server' import condition needs to be used in this environment. This code should only run in React Server Components (RSC) context. Check that you're not importing server-only code in client components.");

package/dist/runtime/entries/router.d.ts

@@ -1,3 +1,4 @@
 import "./types/shared";
 export * from "../lib/links";
 export * from "../lib/router";
+export type { DocumentProps, LayoutProps } from "../lib/types";

package/dist/runtime/entries/routerClient.d.ts

@@ -0,0 +1 @@
+export { defineLinks, linkFor } from "../lib/links.js";

package/dist/runtime/entries/routerClient.js

@@ -0,0 +1 @@
+export { defineLinks, linkFor } from "../lib/links.js";

package/dist/runtime/entries/worker.d.ts

@@ -1,10 +1,14 @@
+import "server-only";
 import "./types/worker";
 export * from "../error";
+export * from "../lib/types";
 export * from "../lib/utils";
 export * from "../register/worker";
 export * from "../render/renderToStream";
 export * from "../render/renderToString";
 export * from "../requestInfo/types";
+export * from "../requestInfo/utils";
 export * from "../requestInfo/worker";
 export * from "../script";
+export * from "../server";
 export * from "../worker";

package/dist/runtime/entries/worker.js

@@ -1,10 +1,14 @@
+import "server-only";
 import "./types/worker";
 export * from "../error";
+export * from "../lib/types";
 export * from "../lib/utils";
 export * from "../register/worker";
 export * from "../render/renderToStream";
 export * from "../render/renderToString";
 export * from "../requestInfo/types";
+export * from "../requestInfo/utils";
 export * from "../requestInfo/worker";
 export * from "../script";
+export * from "../server";
 export * from "../worker";

package/dist/runtime/imports/__mocks__/use-client-lookup.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mock implementation of the virtual:use-client-lookup.js module for tests.
+ * This provides an empty lookup object since tests don't need to actually
+ * load client modules - they use dependency injection for React hooks.
+ */
+export declare const useClientLookup: Record<string, () => Promise<any>>;

package/dist/runtime/imports/__mocks__/use-client-lookup.js

@@ -0,0 +1,6 @@
+/**
+ * Mock implementation of the virtual:use-client-lookup.js module for tests.
+ * This provides an empty lookup object since tests don't need to actually
+ * load client modules - they use dependency injection for React hooks.
+ */
+export const useClientLookup = {};

package/dist/runtime/lib/db/SqliteDurableObject.d.ts

@@ -1,11 +1,11 @@
 import { DurableObject } from "cloudflare:workers";
-import { Kysely, QueryResult } from "kysely";
+import { Kysely, KyselyPlugin, QueryResult } from "kysely";
 export declare class SqliteDurableObject<T = any> extends DurableObject {
     migrations: Record<string, any>;
     kysely: Kysely<T>;
     private initialized;
     private migrationTableName;
-    constructor(ctx: DurableObjectState, env: any, migrations: Record<string, any>, migrationTableName?: string);
+    constructor(ctx: DurableObjectState, env: any, migrations: Record<string, any>, migrationTableName?: string, plugins?: KyselyPlugin[]);
     initialize(): Promise<void>;
     kyselyExecuteQuery<R>(compiledQuery: {
         sql: string;

package/dist/runtime/lib/db/SqliteDurableObject.js

@@ -6,14 +6,14 @@ import { createMigrator } from "./index.js";
 const log = debug("sdk:do-db");
 // Base class for Durable Objects that need Kysely database access
 export class SqliteDurableObject extends DurableObject {
-    constructor(ctx, env, migrations, migrationTableName = "__migrations") {
+    constructor(ctx, env, migrations, migrationTableName = "__migrations", plugins = [new ParseJSONResultsPlugin()]) {
         super(ctx, env);
         this.initialized = false;
         this.migrations = migrations;
         this.migrationTableName = migrationTableName;
         this.kysely = new Kysely({
             dialect: new DODialect({ ctx }),
-            plugins: [new ParseJSONResultsPlugin()],
+            plugins: plugins,
         });
     }
     async initialize() {

package/dist/runtime/lib/db/createDb.d.ts

@@ -1,3 +1,2 @@
 import { Kysely } from "kysely";
-import { type SqliteDurableObject } from "./index.js";
-export declare function createDb<T>(durableObjectBinding: DurableObjectNamespace<SqliteDurableObject>, name?: string): Kysely<T>;
+export declare function createDb<DatabaseType>(durableObjectBinding: DurableObjectNamespace<any>, name?: string): Kysely<DatabaseType>;

package/dist/runtime/lib/db/createDb.js

@@ -5,6 +5,10 @@ export function createDb(durableObjectBinding, name = "main") {
         dialect: new DOWorkerDialect({
             kyselyExecuteQuery: (...args) => {
                 const durableObjectId = durableObjectBinding.idFromName(name);
+                // context(justinvdm, 2 Oct 2025): First prize would be a type parameter
+                // for the durable object and then use it for `durableObjectBinding`'s
+                // type, rather than casting like this. However, that would prevent
+                // users from being able to do createDb<InferredDbType> then though.
                 const stub = durableObjectBinding.get(durableObjectId);
                 stub.initialize();
                 return stub.kyselyExecuteQuery(...args);