npm - rwsdk - Versions diffs - 1.3.0-canary.6 → 1.3.0 - Mend

rwsdk 1.3.0-canary.6 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (84) hide show

package/dist/runtime/client/recovery.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+export type RecoveryState = "idle" | "waiting" | "checking" | "reload";
+export type RecoveryController = {
+    readonly state: RecoveryState;
+    readonly attempts: number;
+    readonly elapsedMs: number;
+    retry(): void;
+    reload(): void;
+};
+export type RecoveryCallback = (controller: RecoveryController) => void | Promise<void>;
+export type RecoveryHandler = "reloadWhenReady" | RecoveryCallback;
+export type RecoveryOptions = {
+    onModuleNotFound?: RecoveryHandler;
+};
+export declare function configureRecovery(options: RecoveryOptions): void;
+export declare function isRecoveryConfigured(): boolean;
+export declare function startRecovery(reason: "module-not-found"): void;
+export declare function isDynamicImportFailure(error: unknown): boolean;

package/dist/runtime/client/recovery.js ADDED Viewed

@@ -0,0 +1,191 @@
+const DEFAULT_BACKOFF_MS = 1000;
+const MAX_BACKOFF_MS = 30000;
+const FALLBACK_TIMEOUT_MS = 30000;
+const FALLBACK_TIMEOUT_JITTER_MS = 10000;
+const STARTUP_JITTER_MS = 1000;
+let configuredOptions = {};
+let activeController = null;
+function debugLog(...args) {
+    if (typeof window !== "undefined" &&
+        (window.__RWSDK_DEBUG__ ||
+            window.__RWSDK_DEBUG_RECOVERY__)) {
+        console.log("[rwsdk:recovery]", ...args);
+    }
+}
+function getBackoffMs(attempt) {
+    const base = Math.min(DEFAULT_BACKOFF_MS * 2 ** attempt, MAX_BACKOFF_MS);
+    const jittered = base * (0.75 + Math.random() * 0.5);
+    return Math.round(Math.min(jittered, MAX_BACKOFF_MS));
+}
+function getJitteredFallbackTimeoutMs() {
+    return (FALLBACK_TIMEOUT_MS + Math.round(Math.random() * FALLBACK_TIMEOUT_JITTER_MS));
+}
+function normalizeRecoveryUrl(url) {
+    const parsed = new URL(url);
+    // A trailing dot on the hostname (e.g. example.com.) is a DNS root
+    // indicator that some Cloudflare Workers routes treat differently. Strip
+    // it so the health check hits the same origin the app uses normally.
+    parsed.hostname = parsed.hostname.replace(/\.$/, "");
+    // Drop query string and hash: we only care whether the document route
+    // itself is ready.
+    return `${parsed.origin}${parsed.pathname}`;
+}
+function getCurrentHydrateRootId() {
+    if (typeof document === "undefined") {
+        return null;
+    }
+    const root = document.getElementById("hydrate-root");
+    return root?.tagName.toLowerCase() ?? null;
+}
+async function checkUrl(url, signal) {
+    try {
+        const response = await fetch(url, {
+            method: "GET",
+            cache: "no-store",
+            headers: { Accept: "text/html" },
+            signal,
+        });
+        if (response.status !== 200) {
+            debugLog("checked", url, "status", response.status, "ok", false);
+            return false;
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (!contentType.includes("text/html")) {
+            debugLog("checked", url, "content-type", contentType, "ok", false);
+            return false;
+        }
+        const text = await response.text();
+        const isHtml = /<!doctype html|<html/i.test(text);
+        if (!isHtml) {
+            debugLog("checked", url, "not html", "ok", false);
+            return false;
+        }
+        const currentRootId = getCurrentHydrateRootId();
+        if (currentRootId) {
+            // Match the current hydrate root element. We look for id="hydrate-root"
+            // or id='hydrate-root' followed by the same tag name.
+            const rootPattern = new RegExp(`id=["']hydrate-root["'][^>]*>\\s*<${currentRootId}\\b`, "i");
+            const rootMatches = rootPattern.test(text);
+            debugLog("checked", url, "status", 200, "rootId", currentRootId, "rootMatches", rootMatches, "ok", rootMatches);
+            return rootMatches;
+        }
+        debugLog("checked", url, "status", 200, "html", true, "ok", true);
+        return true;
+    }
+    catch (error) {
+        debugLog("check failed", url, error);
+        return false;
+    }
+}
+function createController() {
+    let state = "idle";
+    let attempts = 0;
+    const startedAt = Date.now();
+    let wakeResolver = null;
+    let abortController = new AbortController();
+    const controller = {
+        get state() {
+            return state;
+        },
+        get attempts() {
+            return attempts;
+        },
+        get elapsedMs() {
+            return Date.now() - startedAt;
+        },
+        _setState(next) {
+            state = next;
+        },
+        _incAttempts() {
+            attempts++;
+        },
+        retry() {
+            wakeResolver?.();
+        },
+        reload() {
+            abortController.abort();
+            state = "reload";
+            wakeResolver?.();
+            if (typeof window !== "undefined") {
+                window.location.reload();
+            }
+        },
+        _wait(ms) {
+            return new Promise((resolve) => {
+                const timeout = setTimeout(resolve, ms);
+                wakeResolver = () => {
+                    clearTimeout(timeout);
+                    resolve();
+                };
+            });
+        },
+    };
+    return controller;
+}
+export function configureRecovery(options) {
+    configuredOptions = options;
+}
+export function isRecoveryConfigured() {
+    return configuredOptions.onModuleNotFound != null;
+}
+export function startRecovery(reason) {
+    if (typeof window === "undefined") {
+        return;
+    }
+    debugLog("start", reason);
+    if (activeController) {
+        debugLog("already recovering, ignoring duplicate");
+        return;
+    }
+    const handler = configuredOptions.onModuleNotFound;
+    const controller = createController();
+    activeController = controller;
+    const run = async () => {
+        controller._setState("waiting");
+        debugLog("waiting, handler", typeof handler === "function" ? "custom" : handler);
+        if (typeof handler === "function") {
+            try {
+                await handler(controller);
+            }
+            catch (error) {
+                console.error("[rwsdk] recovery callback threw", error);
+            }
+        }
+        const currentUrl = normalizeRecoveryUrl(window.location.href);
+        const fallbackTimeoutMs = getJitteredFallbackTimeoutMs();
+        const startupJitter = Math.round(Math.random() * STARTUP_JITTER_MS);
+        debugLog("startup jitter", startupJitter, "ms");
+        await controller._wait(startupJitter);
+        while (activeController === controller) {
+            controller._setState("checking");
+            controller._incAttempts();
+            debugLog("checking", currentUrl, "attempt", controller.attempts, "elapsed", controller.elapsedMs);
+            const ok = await checkUrl(currentUrl, new AbortController().signal);
+            if (ok) {
+                debugLog("current route ready, reloading");
+                controller.reload();
+                return;
+            }
+            if (controller.elapsedMs >= fallbackTimeoutMs) {
+                debugLog("fallback timeout reached, checking /");
+                const indexUrl = `${new URL(window.location.href).origin}/`;
+                const indexOk = await checkUrl(indexUrl, new AbortController().signal);
+                if (indexOk) {
+                    debugLog("/ ready, navigating to /");
+                    window.location.href = "/";
+                    return;
+                }
+            }
+            const backoff = getBackoffMs(controller.attempts);
+            debugLog("not ready, backing off", backoff, "ms");
+            controller._setState("waiting");
+            await controller._wait(backoff);
+        }
+    };
+    void run();
+}
+export function isDynamicImportFailure(error) {
+    return (error instanceof TypeError &&
+        typeof error.message === "string" &&
+        error.message.includes("dynamically imported module"));
+}

package/dist/runtime/client/scrollRestoration.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+export declare const HISTORY_STATE_SCROLL_KEY = "__rwsdk_scroll_key";
+export type ScrollPosition = {
+    x: number;
+    y: number;
+};
+export type PendingScroll = ScrollPosition & {
+    behavior: ScrollBehavior;
+};
+export interface NavigationHistoryState extends Record<string, unknown> {
+    path?: string;
+    scrollX?: number;
+    scrollY?: number;
+    [HISTORY_STATE_SCROLL_KEY]?: string;
+}
+export interface ScrollRestorationController {
+    initialize(): void;
+    recordCurrentPosition(x: number, y: number): void;
+    flushCurrentPositionToHistoryState(x?: number, y?: number): void;
+    pushEntry(href: string, url: URL, initialPosition: ScrollPosition): void;
+    replaceEntry(href: string, url: URL, initialPosition: ScrollPosition): void;
+    restorePopStateScroll(): void;
+    setPendingScroll(pendingScroll: PendingScroll): void;
+    applyPendingScroll(): void;
+}
+export declare function createScrollRestoration(): ScrollRestorationController;

package/dist/runtime/client/scrollRestoration.js ADDED Viewed

@@ -0,0 +1,157 @@
+export const HISTORY_STATE_SCROLL_KEY = "__rwsdk_scroll_key";
+export function createScrollRestoration() {
+    const historyEntryKeyPrefix = Math.random().toString(36).slice(2);
+    const scrollPositions = new Map();
+    let currentHistoryEntryKey = null;
+    let nextHistoryEntryKey = 0;
+    let pendingScroll = null;
+    function createHistoryEntryKey() {
+        nextHistoryEntryKey += 1;
+        return `${historyEntryKeyPrefix}:${nextHistoryEntryKey}`;
+    }
+    function readHistoryState() {
+        const state = window.history.state;
+        return state && typeof state === "object"
+            ? { ...state }
+            : {};
+    }
+    function getHistoryEntryKey(state) {
+        const key = state[HISTORY_STATE_SCROLL_KEY];
+        return typeof key === "string" ? key : null;
+    }
+    function getScrollPositionFromState(state) {
+        if (typeof state.scrollX === "number" ||
+            typeof state.scrollY === "number") {
+            return {
+                x: typeof state.scrollX === "number" ? state.scrollX : 0,
+                y: typeof state.scrollY === "number" ? state.scrollY : 0,
+            };
+        }
+        return null;
+    }
+    function ensureCurrentHistoryEntryKey(state = readHistoryState()) {
+        const existingKey = getHistoryEntryKey(state);
+        if (existingKey) {
+            currentHistoryEntryKey = existingKey;
+            return existingKey;
+        }
+        const historyEntryKey = createHistoryEntryKey();
+        currentHistoryEntryKey = historyEntryKey;
+        window.history.replaceState({ ...state, [HISTORY_STATE_SCROLL_KEY]: historyEntryKey }, "", window.location.href);
+        return historyEntryKey;
+    }
+    function getCurrentHistoryEntryKeyForReplace(state) {
+        const existingKey = getHistoryEntryKey(state) ?? currentHistoryEntryKey;
+        if (existingKey) {
+            currentHistoryEntryKey = existingKey;
+            return existingKey;
+        }
+        const historyEntryKey = createHistoryEntryKey();
+        currentHistoryEntryKey = historyEntryKey;
+        return historyEntryKey;
+    }
+    function getSavedScrollPosition(state) {
+        const historyEntryKey = getHistoryEntryKey(state) ?? currentHistoryEntryKey;
+        const savedPosition = historyEntryKey
+            ? scrollPositions.get(historyEntryKey)
+            : undefined;
+        return savedPosition ?? getScrollPositionFromState(state);
+    }
+    function writeHistoryState(state, historyEntryKey, position) {
+        window.history.replaceState({
+            ...state,
+            [HISTORY_STATE_SCROLL_KEY]: historyEntryKey,
+            scrollX: position.x,
+            scrollY: position.y,
+        }, "", window.location.href);
+    }
+    return {
+        initialize() {
+            // Take manual control of scroll restoration. With "auto", the browser
+            // restores scroll immediately on popstate — before the RSC payload has
+            // committed — which causes the old DOM to flash at the new scroll offset.
+            if ("scrollRestoration" in window.history) {
+                window.history.scrollRestoration = "manual";
+            }
+            // Boot can happen after a reload, or after an older runtime wrote only
+            // scrollX/scrollY. Seed the in-memory store from history.state so the
+            // first commit can restore the saved position without per-scroll writes.
+            const bootState = readHistoryState();
+            const bootHistoryEntryKey = ensureCurrentHistoryEntryKey(bootState);
+            const bootScrollPosition = getSavedScrollPosition(bootState);
+            if (bootScrollPosition) {
+                scrollPositions.set(bootHistoryEntryKey, bootScrollPosition);
+                pendingScroll = {
+                    x: bootScrollPosition.x,
+                    y: bootScrollPosition.y,
+                    behavior: "instant",
+                };
+            }
+        },
+        recordCurrentPosition(x, y) {
+            if (!currentHistoryEntryKey) {
+                return;
+            }
+            scrollPositions.set(currentHistoryEntryKey, { x, y });
+        },
+        flushCurrentPositionToHistoryState(x = window.scrollX, y = window.scrollY) {
+            const state = readHistoryState();
+            const historyEntryKey = ensureCurrentHistoryEntryKey(state);
+            const position = { x, y };
+            scrollPositions.set(historyEntryKey, position);
+            writeHistoryState(state, historyEntryKey, position);
+        },
+        pushEntry(href, url, initialPosition) {
+            this.flushCurrentPositionToHistoryState();
+            const historyEntryKey = createHistoryEntryKey();
+            currentHistoryEntryKey = historyEntryKey;
+            scrollPositions.set(historyEntryKey, initialPosition);
+            window.history.pushState({
+                path: href,
+                [HISTORY_STATE_SCROLL_KEY]: historyEntryKey,
+                scrollX: initialPosition.x,
+                scrollY: initialPosition.y,
+            }, "", url);
+        },
+        replaceEntry(href, url, initialPosition) {
+            const state = readHistoryState();
+            const historyEntryKey = getCurrentHistoryEntryKeyForReplace(state);
+            scrollPositions.set(historyEntryKey, initialPosition);
+            window.history.replaceState({
+                ...state,
+                path: href,
+                [HISTORY_STATE_SCROLL_KEY]: historyEntryKey,
+                scrollX: initialPosition.x,
+                scrollY: initialPosition.y,
+            }, "", url);
+        },
+        restorePopStateScroll() {
+            const state = readHistoryState();
+            const historyEntryKey = ensureCurrentHistoryEntryKey(state);
+            const savedScrollPosition = getSavedScrollPosition(state) ?? {
+                x: 0,
+                y: 0,
+            };
+            if (!scrollPositions.has(historyEntryKey)) {
+                scrollPositions.set(historyEntryKey, savedScrollPosition);
+            }
+            pendingScroll = {
+                x: savedScrollPosition.x,
+                y: savedScrollPosition.y,
+                behavior: "instant",
+            };
+        },
+        setPendingScroll(nextPendingScroll) {
+            pendingScroll = nextPendingScroll;
+            this.recordCurrentPosition(nextPendingScroll.x, nextPendingScroll.y);
+        },
+        applyPendingScroll() {
+            if (!pendingScroll)
+                return;
+            const { x, y, behavior } = pendingScroll;
+            pendingScroll = null;
+            window.scrollTo({ top: y, left: x, behavior });
+            this.recordCurrentPosition(x, y);
+        },
+    };
+}

package/dist/runtime/client/scrollRestoration.test.d.ts ADDED Viewed

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

package/dist/runtime/client/scrollRestoration.test.js ADDED Viewed

@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createScrollRestoration, HISTORY_STATE_SCROLL_KEY, } from "./scrollRestoration";
+describe("scrollRestoration", () => {
+    let historyState;
+    beforeEach(() => {
+        historyState = {};
+        vi.stubGlobal("window", {
+            location: { href: "http://localhost/" },
+            scrollX: 0,
+            scrollY: 0,
+            scrollTo: vi.fn(),
+            history: {
+                scrollRestoration: "auto",
+                get state() {
+                    return historyState;
+                },
+                pushState: vi.fn((state) => {
+                    historyState = state;
+                }),
+                replaceState: vi.fn((state) => {
+                    historyState = state;
+                }),
+            },
+        });
+    });
+    it("restores scroll from history state after a reload", () => {
+        historyState = {
+            [HISTORY_STATE_SCROLL_KEY]: "entry:1",
+            scrollX: 12,
+            scrollY: 345,
+        };
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        scrollRestoration.applyPendingScroll();
+        expect(window.scrollTo).toHaveBeenCalledWith({
+            left: 12,
+            top: 345,
+            behavior: "instant",
+        });
+    });
+    it("migrates legacy scrollX/scrollY history state on boot", () => {
+        historyState = { scrollX: 7, scrollY: 222 };
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        scrollRestoration.applyPendingScroll();
+        expect(window.history.replaceState).toHaveBeenCalledWith(expect.objectContaining({
+            [HISTORY_STATE_SCROLL_KEY]: expect.any(String),
+            scrollX: 7,
+            scrollY: 222,
+        }), "", "http://localhost/");
+        expect(window.scrollTo).toHaveBeenCalledWith({
+            left: 7,
+            top: 222,
+            behavior: "instant",
+        });
+    });
+    it("restores back/forward positions from the in-memory key map", () => {
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        const firstEntryState = historyState;
+        window.scrollY = 500;
+        scrollRestoration.recordCurrentPosition(0, 500);
+        scrollRestoration.pushEntry("/next", new URL("/next", "http://localhost/"), { x: 0, y: 0 });
+        historyState = firstEntryState;
+        scrollRestoration.restorePopStateScroll();
+        scrollRestoration.applyPendingScroll();
+        expect(window.scrollTo).toHaveBeenCalledWith({
+            left: 0,
+            top: 500,
+            behavior: "instant",
+        });
+    });
+    it("does not write to history state while recording scroll", () => {
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        vi.mocked(window.history.replaceState).mockClear();
+        scrollRestoration.recordCurrentPosition(0, 100);
+        scrollRestoration.recordCurrentPosition(0, 200);
+        expect(window.history.replaceState).not.toHaveBeenCalled();
+    });
+    it("flushes the latest scroll position to history state on lifecycle boundaries", () => {
+        const scrollRestoration = createScrollRestoration();
+        scrollRestoration.initialize();
+        vi.mocked(window.history.replaceState).mockClear();
+        scrollRestoration.recordCurrentPosition(4, 400);
+        scrollRestoration.flushCurrentPositionToHistoryState(4, 400);
+        expect(window.history.replaceState).toHaveBeenCalledWith(expect.objectContaining({
+            [HISTORY_STATE_SCROLL_KEY]: expect.any(String),
+            scrollX: 4,
+            scrollY: 400,
+        }), "", "http://localhost/");
+    });
+});

package/dist/runtime/imports/client.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import React from "react";
 import { ClientOnly } from "../client/client";
+import { isDynamicImportFailure, isRecoveryConfigured, startRecovery, } from "../client/recovery.js";
 import { memoizeOnId } from "../lib/memoizeOnId";
 // @ts-ignore
 import { useClientLookup } from "virtual:use-client-lookup.js";
@@ -8,7 +9,18 @@ export const loadModule = memoizeOnId(async (id) => {
     if (!moduleFn) {
         throw new Error(`(client) No module found for '${id}' in module lookup for "use client" directive`);
     }
-    return await moduleFn();
+    try {
+        return await moduleFn();
+    }
+    catch (error) {
+        if (isDynamicImportFailure(error) && isRecoveryConfigured()) {
+            startRecovery("module-not-found");
+            // Stall this import forever so React doesn't crash before the recovery
+            // flow reloads the page.
+            return new Promise(() => { });
+        }
+        throw error;
+    }
 });
 // context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
 export const clientWebpackRequire = memoizeOnId(async (id) => {

package/dist/runtime/lib/db/DOSqliteIntrospector.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { type DatabaseMetadata, type DatabaseMetadataOptions, type Kysely, type SchemaMetadata, type TableMetadata } from "kysely";
+export declare class DOSqliteIntrospector {
+    #private;
+    constructor(db: Kysely<any>);
+    getSchemas(): Promise<SchemaMetadata[]>;
+    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
+    getMetadata(options: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
+}

package/dist/runtime/lib/db/DOSqliteIntrospector.js ADDED Viewed

@@ -0,0 +1,129 @@
+// NOTE(justinvdm, 9 Jun 2026): This file copies Kysely's SqliteIntrospector.
+// Before trying to simplify it, read this comment.
+//
+// Problem: Cloudflare's DO SQLite adds internal tables (_cf_KV, _cf_METADATA)
+// when storage.put/setAlarm is used. Kysely's SqliteIntrospector discovers
+// these via sqlite_master, then runs PRAGMA table_info on each. Cloudflare's
+// authorizer rejects PRAGMA on _cf_* tables with SQLITE_AUTH, breaking
+// migrations and rendering the DO unusable.
+//
+// Why we copied instead of composed:
+// - Kysely's SqliteIntrospector uses JS private fields (#db, #tablesQuery,
+//   #getTableMetadata). Private fields are truly private — subclasses cannot
+//   override them, and wrappers cannot intercept internal calls.
+// - We considered a lighter approach: query sqlite_master with Kysely's
+//   builder, then run PRAGMA table_info per-table. This is lighter but
+//   requires inlining the table name into raw SQL. Even with escaping,
+//   any injection risk is unacceptable. The CTE approach below uses
+//   `pragma_table_info(tl.name)` where `tl.name` is a column reference,
+//   not an inlined value — zero injection surface.
+// - We also considered Kysely plugins (AST rewriting, SQL string rewriting)
+//   but these are fragile: they depend on Kysely's internal AST shape and
+//   SQL formatting, both of which can change between releases.
+//
+// This is a copy of Kysely's SqliteIntrospector (MIT licensed) with one
+// change: `.where('name', 'not like', '_cf_%')` to exclude Cloudflare tables.
+//
+// See: https://github.com/redwoodjs/sdk/issues/1219
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DOSqliteIntrospector_instances, _DOSqliteIntrospector_db, _DOSqliteIntrospector_tablesQuery, _DOSqliteIntrospector_getTableMetadata;
+import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, sql, } from "kysely";
+export class DOSqliteIntrospector {
+    constructor(db) {
+        _DOSqliteIntrospector_instances.add(this);
+        _DOSqliteIntrospector_db.set(this, void 0);
+        __classPrivateFieldSet(this, _DOSqliteIntrospector_db, db, "f");
+    }
+    async getSchemas() {
+        // Sqlite doesn't support schemas.
+        return [];
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        return await __classPrivateFieldGet(this, _DOSqliteIntrospector_instances, "m", _DOSqliteIntrospector_getTableMetadata).call(this, options);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+}
+_DOSqliteIntrospector_db = new WeakMap(), _DOSqliteIntrospector_instances = new WeakSet(), _DOSqliteIntrospector_tablesQuery = function _DOSqliteIntrospector_tablesQuery(qb, options) {
+    let tablesQuery = qb
+        .selectFrom("sqlite_master")
+        .where("type", "in", ["table", "view"])
+        .where("name", "not like", "sqlite_%")
+        // context(justinvdm, 9 Jun 2026): Exclude Cloudflare internal tables.
+        // These are added by the DO runtime and cannot be introspected.
+        .where("name", "not like", "_cf_%")
+        .select(["name", "sql", "type"])
+        .orderBy("name");
+    if (!options.withInternalKyselyTables) {
+        tablesQuery = tablesQuery
+            .where("name", "!=", DEFAULT_MIGRATION_TABLE)
+            .where("name", "!=", DEFAULT_MIGRATION_LOCK_TABLE);
+    }
+    return tablesQuery;
+}, _DOSqliteIntrospector_getTableMetadata = async function _DOSqliteIntrospector_getTableMetadata(options) {
+    const tablesResult = await __classPrivateFieldGet(this, _DOSqliteIntrospector_instances, "m", _DOSqliteIntrospector_tablesQuery).call(this, __classPrivateFieldGet(this, _DOSqliteIntrospector_db, "f"), options).execute();
+    const tableMetadata = await __classPrivateFieldGet(this, _DOSqliteIntrospector_db, "f")
+        .with("table_list", (qb) => __classPrivateFieldGet(this, _DOSqliteIntrospector_instances, "m", _DOSqliteIntrospector_tablesQuery).call(this, qb, options))
+        .selectFrom([
+        "table_list as tl",
+        sql `pragma_table_info(tl.name)`.as("p"),
+    ])
+        .select([
+        "tl.name as table",
+        "p.cid",
+        "p.name",
+        "p.type",
+        "p.notnull",
+        "p.dflt_value",
+        "p.pk",
+    ])
+        .orderBy("tl.name")
+        .orderBy("p.cid")
+        .execute();
+    const columnsByTable = {};
+    for (const row of tableMetadata) {
+        columnsByTable[row.table] ??= [];
+        columnsByTable[row.table].push(row);
+    }
+    return tablesResult.map(({ name, sql: tableSql, type }) => {
+        let autoIncrementCol = tableSql
+            ?.split(/[\(\),]/)
+            ?.find((it) => it.toLowerCase().includes("autoincrement"))
+            ?.trimStart()
+            ?.split(/\s+/)?.[0]
+            ?.replace(/["`]/g, "");
+        const columns = columnsByTable[name] ?? [];
+        if (!autoIncrementCol) {
+            const pkCols = columns.filter((r) => r.pk > 0);
+            if (pkCols.length === 1 &&
+                pkCols[0].type.toLowerCase() === "integer") {
+                autoIncrementCol = pkCols[0].name;
+            }
+        }
+        return {
+            name: name,
+            isView: type === "view",
+            columns: columns.map((col) => ({
+                name: col.name,
+                dataType: col.type,
+                isNullable: !col.notnull,
+                isAutoIncrementing: col.name === autoIncrementCol,
+                hasDefaultValue: col.dflt_value != null,
+                comment: undefined,
+            })),
+        };
+    });
+};

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

@@ -1,4 +1,5 @@
-import { DatabaseConnection, Driver, QueryResult, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
+import { DatabaseConnection, Driver, QueryResult, SqliteAdapter, SqliteQueryCompiler } from "kysely";
+import { DOSqliteIntrospector } from "./DOSqliteIntrospector.js";
 type DOWorkerDialectConfig = {
     kyselyExecuteQuery: (compiledQuery: {
         sql: string;
@@ -11,7 +12,7 @@ export declare class DOWorkerDialect {
     createAdapter(): SqliteAdapter;
     createDriver(): DOWorkerDriver;
     createQueryCompiler(): SqliteQueryCompiler;
-    createIntrospector(db: any): SqliteIntrospector;
+    createIntrospector(db: any): DOSqliteIntrospector;
 }
 declare class DOWorkerDriver implements Driver {
     config: DOWorkerDialectConfig;