rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/runtime/client.js

@@ -0,0 +1,74 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { clientWebpackRequire } from "./imports/client";
+// NOTE: `react-server-dom-webpack` uses this global to load modules,
+// so we need to define it here before importing "react-server-dom-webpack."
+globalThis.__webpack_require__ = clientWebpackRequire;
+export const fetchTransport = (transportContext) => {
+    const fetchCallServer = async (id, args) => {
+        const { createFromFetch, encodeReply } = await import("react-server-dom-webpack/client.browser");
+        const url = new URL(window.location.href);
+        url.searchParams.set("__rsc", "");
+        if (id != null) {
+            url.searchParams.set("__rsc_action_id", id);
+        }
+        const streamData = createFromFetch(fetch(url, {
+            method: "POST",
+            body: args != null ? await encodeReply(args) : null,
+        }), { callServer: fetchCallServer });
+        transportContext.setRscPayload(streamData);
+        const result = await streamData;
+        return result.actionResult;
+    };
+    return fetchCallServer;
+};
+export const initClient = async ({ transport = fetchTransport, hydrateRootOptions, } = {}) => {
+    const React = await import("react");
+    const { hydrateRoot } = await import("react-dom/client");
+    const transportContext = {
+        setRscPayload: () => { },
+    };
+    let transportCallServer = transport(transportContext);
+    const callServer = (id, args) => transportCallServer(id, args);
+    const upgradeToRealtime = async ({ key } = {}) => {
+        const { realtimeTransport } = await import("./lib/realtime/client");
+        const createRealtimeTransport = realtimeTransport({ key });
+        transportCallServer = createRealtimeTransport(transportContext);
+    };
+    globalThis.__rsc_callServer = callServer;
+    globalThis.__rw = {
+        callServer,
+        upgradeToRealtime,
+    };
+    const rootEl = document.getElementById("hydrate-root");
+    if (!rootEl) {
+        throw new Error('no element with id "hydrate-root"');
+    }
+    let rscPayload;
+    // context(justinvdm, 18 Jun 2025): We inject the RSC payload
+    // unless render(Document, [...], { rscPayload: false }) was used.
+    if (globalThis.__FLIGHT_DATA) {
+        const { createFromReadableStream } = await import("react-server-dom-webpack/client.browser");
+        const { rscStream } = await import("rsc-html-stream/client");
+        rscPayload = createFromReadableStream(rscStream, {
+            callServer,
+        });
+    }
+    function Content() {
+        const [streamData, setStreamData] = React.useState(rscPayload);
+        const [_isPending, startTransition] = React.useTransition();
+        transportContext.setRscPayload = (v) => startTransition(() => setStreamData(v));
+        return _jsx(_Fragment, { children: React.use(streamData).node });
+    }
+    hydrateRoot(rootEl, _jsx(Content, {}), {
+        onUncaughtError: (error, { componentStack }) => {
+            console.error("Uncaught error: %O\n\nComponent stack:%s", error, componentStack);
+        },
+        ...hydrateRootOptions,
+    });
+    if (import.meta.hot) {
+        import.meta.hot.on("rsc:update", (e) => {
+            console.log("[rwsdk] hot update", e.file);
+            callServer("__rsc_hot_update", [e.file]);
+        });
+    }
+};

package/dist/runtime/clientNavigation.d.ts

@@ -0,0 +1,4 @@
+export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
+export declare function initClientNavigation(opts?: {
+    onNavigate: () => void;
+}): void;

package/dist/runtime/clientNavigation.js

@@ -0,0 +1,53 @@
+export function validateClickEvent(event, target) {
+    // should this only work for left click?
+    if (event.button !== 0) {
+        return false;
+    }
+    if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
+        return false;
+    }
+    const link = target.closest("a");
+    if (!link) {
+        return false;
+    }
+    const href = link.getAttribute("href");
+    if (!href) {
+        return false;
+    }
+    // Skip if target="_blank" or similar
+    if (link.target && link.target !== "_self") {
+        return false;
+    }
+    if (href.startsWith("http")) {
+        return false;
+    }
+    // Skip if download attribute
+    if (link.hasAttribute("download")) {
+        return false;
+    }
+    return true;
+}
+export function initClientNavigation(opts = {
+    onNavigate: async function onNavigate() {
+        // @ts-expect-error
+        await globalThis.__rsc_callServer();
+    },
+}) {
+    // Intercept all anchor tag clicks
+    document.addEventListener("click", async function handleClickEvent(event) {
+        // Prevent default navigation
+        if (!validateClickEvent(event, event.target)) {
+            return;
+        }
+        event.preventDefault();
+        const el = event.target;
+        const a = el.closest("a");
+        const href = a?.getAttribute("href");
+        window.history.pushState({ path: href }, "", window.location.origin + href);
+        await opts.onNavigate();
+    }, true);
+    // Handle browser back/forward buttons
+    window.addEventListener("popstate", async function handlePopState() {
+        await opts.onNavigate();
+    });
+}

package/dist/runtime/clientNavigation.test.d.ts

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

package/dist/runtime/clientNavigation.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "vitest";
+import { validateClickEvent } from "./clientNavigation";
+describe("clientNavigation", () => {
+    let mockEvent = {
+        button: 0, // right click
+        metaKey: false,
+        altKey: false,
+        shiftKey: false,
+        ctrlKey: false,
+    };
+    let mockTarget = {
+        closest: () => {
+            return {
+                getAttribute: () => "/test",
+                hasAttribute: () => false,
+            };
+        },
+    };
+    it("should return true", () => {
+        expect(validateClickEvent(mockEvent, mockTarget)).toBe(true);
+    });
+    it("should return false if the event is not a left click", () => {
+        expect(validateClickEvent({ ...mockEvent, button: 1 }, mockTarget)).toBe(false);
+    });
+    it("none of the modifier keys are pressed", () => {
+        expect(validateClickEvent({ ...mockEvent, metaKey: true }, mockTarget)).toBe(false);
+    });
+    it("the target is not an anchor tag", () => {
+        expect(validateClickEvent(mockEvent, {
+            closest: () => undefined,
+        })).toBe(false);
+    });
+    it("should have an href attribute", () => {
+        expect(validateClickEvent(mockEvent, {
+            closest: () => ({ getAttribute: () => undefined }),
+        })).toBe(false);
+    });
+    it("should not have a target attribute", () => {
+        expect(validateClickEvent(mockEvent, {
+            closest: () => ({
+                target: "_blank",
+                getAttribute: () => "/test",
+                hasAttribute: () => false,
+            }),
+        })).toBe(false);
+    });
+    it("should be a relative link", () => {
+        expect(validateClickEvent(mockEvent, {
+            closest: () => ({
+                getAttribute: () => "/test",
+                hasAttribute: () => false,
+            }),
+        })).toBe(true);
+    });
+});

package/dist/runtime/constants.d.ts

@@ -0,0 +1 @@
+export declare const IS_DEV: boolean;

package/dist/runtime/constants.js

@@ -0,0 +1 @@
+export const IS_DEV = typeof import.meta.env !== "undefined" && import.meta.env.DEV;

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

@@ -0,0 +1 @@
+export * from "../lib/auth";

package/dist/runtime/entries/auth.js

@@ -0,0 +1 @@
+export * from "../lib/auth";

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

@@ -0,0 +1,4 @@
+export * from "../client";
+export * from "../register/client";
+export * from "../lib/streams/consumeEventStream";
+export * from "../clientNavigation";

package/dist/runtime/entries/client.js

@@ -0,0 +1,4 @@
+export * from "../client";
+export * from "../register/client";
+export * from "../lib/streams/consumeEventStream";
+export * from "../clientNavigation";

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

@@ -0,0 +1 @@
+export * from "../lib/streams/consumeEventStream";

package/dist/runtime/entries/clientSSR.js

@@ -0,0 +1 @@
+export * from "../lib/streams/consumeEventStream";

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

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("rwsdk: 'react-server' is not supported in this environment");

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

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("rwsdk: 'react-server' import condition needs to be used in this environment");

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

@@ -0,0 +1,2 @@
+export * from "../lib/router";
+export * from "../lib/links";

package/dist/runtime/entries/router.js

@@ -0,0 +1,2 @@
+export * from "../lib/router";
+export * from "../lib/links";

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

@@ -0,0 +1 @@
+export * from "../register/ssr";

package/dist/runtime/entries/ssr.js

@@ -0,0 +1 @@
+export * from "../register/ssr";

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

@@ -0,0 +1,9 @@
+export * from "../register/worker";
+export * from "../worker";
+export * from "../error";
+export * from "../script";
+export * from "../lib/utils";
+export * from "../requestInfo/types";
+export * from "../requestInfo/worker";
+export * from "../render/renderToString";
+export * from "../render/renderToStream";

package/dist/runtime/entries/worker.js

@@ -0,0 +1,9 @@
+export * from "../register/worker";
+export * from "../worker";
+export * from "../error";
+export * from "../script";
+export * from "../lib/utils";
+export * from "../requestInfo/types";
+export * from "../requestInfo/worker";
+export * from "../render/renderToString";
+export * from "../render/renderToStream";

package/dist/runtime/error.d.ts

@@ -0,0 +1,6 @@
+export declare class ErrorResponse extends Error {
+    code: number;
+    message: string;
+    name: string;
+    constructor(code: number, message: string);
+}

package/dist/runtime/error.js

@@ -0,0 +1,8 @@
+export class ErrorResponse extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.message = message;
+        this.name = "ErrorResponse";
+    }
+}

package/dist/runtime/imports/ClientOnly.d.ts

@@ -0,0 +1,3 @@
+export declare const ClientOnly: ({ children }: {
+    children: React.ReactNode;
+}) => import("react").ReactNode;

package/dist/runtime/imports/ClientOnly.js

@@ -0,0 +1,8 @@
+import { useEffect, useState } from "react";
+export const ClientOnly = ({ children }) => {
+    const [didUpdate, setDidUpdate] = useState(false);
+    useEffect(() => {
+        setDidUpdate(true);
+    }, []);
+    return didUpdate ? children : null;
+};

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

@@ -0,0 +1,4 @@
+export declare const loadModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const clientWebpackRequire: ((id: string) => Promise<{
+    [x: string]: any;
+}>) & import("lodash").MemoizedFunction;

package/dist/runtime/imports/client.js

@@ -0,0 +1,33 @@
+import React from "react";
+import memoize from "lodash/memoize";
+export const loadModule = memoize(async (id) => {
+    if (import.meta.env.DEV && !process.env.PREVIEW) {
+        return await import(/* @vite-ignore */ id);
+    }
+    else {
+        const { useClientLookup } = await import("virtual:use-client-lookup.js");
+        const moduleFn = useClientLookup[id];
+        if (!moduleFn) {
+            throw new Error(`(client) No module found for '${id}' in module lookup for "use client" directive`);
+        }
+        return await moduleFn();
+    }
+});
+// context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
+export const clientWebpackRequire = memoize(async (id) => {
+    const [file, name] = id.split("#");
+    const promisedModule = loadModule(file);
+    const promisedComponent = promisedModule.then((module) => module[name]);
+    const didSSR = globalThis.__RWSDK_CONTEXT?.rw?.ssr;
+    if (didSSR) {
+        const awaitedComponent = await promisedComponent;
+        return { [id]: awaitedComponent };
+    }
+    const { ClientOnly } = await import("./ClientOnly");
+    const promisedDefault = promisedComponent.then((Component) => ({
+        default: Component,
+    }));
+    const Lazy = React.lazy(() => promisedDefault);
+    const Wrapped = () => React.createElement(ClientOnly, null, React.createElement(Lazy));
+    return { [id]: Wrapped };
+});

package/dist/runtime/imports/ssr.d.ts

@@ -0,0 +1,5 @@
+export declare const ssrLoadModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const ssrGetModuleExport: (id: string) => Promise<any>;
+export declare const ssrWebpackRequire: ((id: string) => Promise<{
+    [x: string]: any;
+}>) & import("lodash").MemoizedFunction;

package/dist/runtime/imports/ssr.js

@@ -0,0 +1,20 @@
+import memoize from "lodash/memoize";
+export const ssrLoadModule = memoize(async (id) => {
+    const { useClientLookup } = await import("virtual:use-client-lookup.js");
+    const moduleFn = useClientLookup[id];
+    if (!moduleFn) {
+        throw new Error(`(ssr) No module found for '${id}' in module lookup for "use client" directive`);
+    }
+    return await moduleFn();
+});
+export const ssrGetModuleExport = async (id) => {
+    const [file, name] = id.split("#");
+    const module = await ssrLoadModule(file);
+    return module[name];
+};
+// context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
+export const ssrWebpackRequire = memoize(async (id) => {
+    const [file, name] = id.split("#");
+    const module = await ssrLoadModule(file);
+    return { [id]: module[name] };
+});

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

@@ -0,0 +1,5 @@
+export declare const loadServerModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const getServerModuleExport: (id: string) => Promise<any>;
+export declare const ssrWebpackRequire: ((id: string) => Promise<{
+    [x: string]: any;
+}>) & import("lodash").MemoizedFunction;

package/dist/runtime/imports/worker.js

@@ -0,0 +1,22 @@
+import memoize from "lodash/memoize";
+import { requestInfo } from "../requestInfo/worker";
+import { ssrWebpackRequire as baseSsrWebpackRequire } from "rwsdk/__ssr_bridge";
+export const loadServerModule = memoize(async (id) => {
+    const { useServerLookup } = await import("virtual:use-server-lookup.js");
+    const moduleFn = useServerLookup[id];
+    if (!moduleFn) {
+        throw new Error(`(worker) No module found for '${id}' in module lookup for "use server" directive`);
+    }
+    return await moduleFn();
+});
+export const getServerModuleExport = async (id) => {
+    const [file, name] = id.split("#");
+    const module = await loadServerModule(file);
+    return module[name];
+};
+export const ssrWebpackRequire = memoize(async (id) => {
+    if (!requestInfo.rw.ssr) {
+        return { [id]: () => null };
+    }
+    return baseSsrWebpackRequire(id);
+});

package/dist/runtime/lib/auth/index.d.ts

@@ -0,0 +1 @@
+export * from "./session";

package/dist/runtime/lib/auth/index.js

@@ -0,0 +1 @@
+export * from "./session";

package/dist/runtime/lib/auth/session.d.ts

@@ -0,0 +1,50 @@
+export declare const MAX_SESSION_DURATION: number;
+type GetSessionResult<Session> = {
+    value: Session;
+} | {
+    error: string;
+};
+export interface DurableObjectMethods<Session, SessionInputData> extends Rpc.DurableObjectBranded {
+    getSession(): Promise<GetSessionResult<Session>>;
+    saveSession(data: SessionInputData): Promise<Session>;
+    revokeSession(): void;
+}
+export type SessionStore<Session, SessionInputData = Session> = ReturnType<typeof defineSessionStore<Session, SessionInputData>>;
+export declare const createSessionCookie: ({ name, sessionId, maxAge, }: {
+    name: string;
+    sessionId: string;
+    maxAge?: number | true;
+}) => string;
+export declare const signSessionId: ({ unsignedSessionId, secretKey, }: {
+    unsignedSessionId: string;
+    secretKey: string;
+}) => Promise<string>;
+export declare const generateSessionId: ({ secretKey, }: {
+    secretKey: string;
+}) => Promise<string>;
+export declare const isValidSessionId: ({ sessionId, secretKey, }: {
+    sessionId: string;
+    secretKey: string;
+}) => Promise<boolean>;
+export declare const defineSessionStore: <Session, SessionInputData>({ cookieName, createCookie, secretKey, get, set, unset, }: {
+    cookieName?: string;
+    createCookie?: typeof createSessionCookie;
+    secretKey?: string;
+    get: (sessionId: string) => Promise<Session>;
+    set: (sessionId: string, sessionInputData: SessionInputData) => Promise<void>;
+    unset: (sessionId: string) => Promise<void>;
+}) => {
+    load: (request: Request) => Promise<Session | null>;
+    save: (headers: Headers, sessionInputData: SessionInputData, { maxAge }?: {
+        maxAge?: number | true;
+    }) => Promise<void>;
+    remove: (request: Request, headers: Headers) => Promise<void>;
+};
+type SessionStoreFromDurableObject<SessionDurableObject> = SessionDurableObject extends DurableObjectMethods<infer Session, infer SessionInputData> ? SessionStore<Session, SessionInputData> : never;
+export declare const defineDurableSession: <SessionDurableObject extends DurableObjectMethods<any, any>>({ cookieName, createCookie, secretKey, sessionDurableObject, }: {
+    cookieName?: string;
+    createCookie?: typeof createSessionCookie;
+    secretKey?: string;
+    sessionDurableObject: DurableObjectNamespace<SessionDurableObject>;
+}) => SessionStoreFromDurableObject<SessionDurableObject>;
+export {};

package/dist/runtime/lib/auth/session.js

@@ -0,0 +1,148 @@
+import { ErrorResponse } from "../../error";
+import { IS_DEV } from "../../constants";
+import { env } from "cloudflare:workers";
+const AUTH_SECRET_KEY = env.AUTH_SECRET_KEY ??
+    (IS_DEV ? "development-secret-key-do-not-use-in-production" : undefined);
+if (AUTH_SECRET_KEY === "") {
+    console.warn("AUTH_SECRET_KEY is set but empty. Please provide a non-empty secret key for session store security.");
+}
+if (!AUTH_SECRET_KEY) {
+    console.warn("AUTH_SECRET_KEY not set. Please set this environment variable to a secure random key for session store security.");
+}
+export const MAX_SESSION_DURATION = 14 * 24 * 60 * 60 * 1000; // 14 days
+const packSessionId = (parts) => {
+    return btoa([parts.unsignedSessionId, parts.signature].join(":"));
+};
+const unpackSessionId = (packed) => {
+    const [unsignedSessionId, signature] = atob(packed).split(":");
+    return { unsignedSessionId, signature };
+};
+const arrayBufferToHex = (buffer) => {
+    const array = new Uint8Array(buffer);
+    return Array.from(array)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+};
+export const createSessionCookie = ({ name, sessionId, maxAge, }) => {
+    const isViteDev = typeof import.meta.env !== "undefined" && import.meta.env.DEV;
+    return `${name}=${sessionId}; Path=/; HttpOnly; ${isViteDev ? "" : "Secure; "}SameSite=Lax${maxAge != null
+        ? `; Max-Age=${maxAge === true ? MAX_SESSION_DURATION / 1000 : maxAge}`
+        : ""}`;
+};
+export const signSessionId = async ({ unsignedSessionId, secretKey, }) => {
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey("raw", encoder.encode(secretKey), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const signatureArrayBuffer = await crypto.subtle.sign("HMAC", key, encoder.encode(unsignedSessionId));
+    return arrayBufferToHex(signatureArrayBuffer);
+};
+export const generateSessionId = async ({ secretKey, }) => {
+    const unsignedSessionId = crypto.randomUUID();
+    const signature = await signSessionId({ unsignedSessionId, secretKey });
+    return packSessionId({ unsignedSessionId, signature });
+};
+export const isValidSessionId = async ({ sessionId, secretKey, }) => {
+    try {
+        const { unsignedSessionId, signature } = unpackSessionId(sessionId);
+        const computedSignature = await signSessionId({
+            unsignedSessionId,
+            secretKey,
+        });
+        return computedSignature === signature;
+    }
+    catch {
+        return false;
+    }
+};
+export const defineSessionStore = ({ cookieName = "session_id", createCookie = createSessionCookie, secretKey = AUTH_SECRET_KEY, get, set, unset, }) => {
+    if (!secretKey) {
+        throw new Error("No secret key provided for session store");
+    }
+    const getSessionIdFromCookie = (request) => {
+        const cookieHeader = request.headers.get("Cookie");
+        if (!cookieHeader)
+            return undefined;
+        for (const cookie of cookieHeader.split(";")) {
+            const trimmedCookie = cookie.trim();
+            const separatorIndex = trimmedCookie.indexOf("=");
+            if (separatorIndex === -1)
+                continue;
+            const key = trimmedCookie.slice(0, separatorIndex);
+            const value = trimmedCookie.slice(separatorIndex + 1);
+            if (key === cookieName) {
+                return value;
+            }
+        }
+    };
+    const load = async (request) => {
+        const sessionId = getSessionIdFromCookie(request);
+        if (!sessionId) {
+            return null;
+        }
+        if (!(await isValidSessionId({ sessionId, secretKey }))) {
+            throw new ErrorResponse(401, "Invalid session id");
+        }
+        try {
+            return await get(sessionId);
+        }
+        catch (error) {
+            throw new ErrorResponse(401, "Invalid session id");
+        }
+    };
+    const save = async (headers, sessionInputData, { maxAge } = {}) => {
+        const sessionId = await generateSessionId({ secretKey });
+        await set(sessionId, sessionInputData);
+        headers.set("Set-Cookie", createCookie({ name: cookieName, sessionId, maxAge }));
+    };
+    const remove = async (request, headers) => {
+        const sessionId = getSessionIdFromCookie(request);
+        if (sessionId) {
+            await unset(sessionId);
+        }
+        headers.set("Set-Cookie", createCookie({ name: cookieName, sessionId: "", maxAge: 0 }));
+    };
+    return {
+        load,
+        save,
+        remove,
+    };
+};
+export const defineDurableSession = ({ cookieName, createCookie, secretKey = AUTH_SECRET_KEY, sessionDurableObject, }) => {
+    const get = async (sessionId) => {
+        const { unsignedSessionId } = unpackSessionId(sessionId);
+        const doId = sessionDurableObject.idFromName(unsignedSessionId);
+        const sessionStub = sessionDurableObject.get(doId);
+        const result = (await sessionStub.getSession());
+        if ("error" in result) {
+            throw new Error(result.error);
+        }
+        return result.value;
+    };
+    const set = async (sessionId, sessionInputData) => {
+        const { unsignedSessionId } = unpackSessionId(sessionId);
+        const doId = sessionDurableObject.idFromName(unsignedSessionId);
+        const sessionStub = sessionDurableObject.get(doId);
+        // todo(justinvdm, 2025-02-20): Fix this
+        // @ts-ignore
+        await sessionStub.saveSession(sessionInputData);
+    };
+    const unset = async (sessionId) => {
+        let unsignedSessionId;
+        try {
+            unsignedSessionId = unpackSessionId(sessionId).unsignedSessionId;
+        }
+        catch {
+            return;
+        }
+        const doId = sessionDurableObject.idFromName(unsignedSessionId);
+        const sessionStub = sessionDurableObject.get(doId);
+        await sessionStub.revokeSession();
+    };
+    return defineSessionStore({
+        cookieName,
+        createCookie,
+        secretKey,
+        get,
+        set,
+        unset,
+    });
+};

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

@@ -0,0 +1,29 @@
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, Driver, DatabaseConnection } from "kysely";
+export declare class DOWorkerDialect {
+    config: {
+        stub: any;
+    };
+    constructor(config: {
+        stub: any;
+    });
+    createAdapter(): SqliteAdapter;
+    createDriver(): DOWorkerDriver;
+    createQueryCompiler(): SqliteQueryCompiler;
+    createIntrospector(db: any): SqliteIntrospector;
+}
+declare class DOWorkerDriver implements Driver {
+    config: {
+        stub: any;
+    };
+    constructor(config: {
+        stub: any;
+    });
+    init(): Promise<void>;
+    acquireConnection(): Promise<DatabaseConnection>;
+    beginTransaction(conn: any): Promise<any>;
+    commitTransaction(conn: any): Promise<any>;
+    rollbackTransaction(conn: any): Promise<any>;
+    releaseConnection(_conn: any): Promise<void>;
+    destroy(): Promise<void>;
+}
+export {};