or3-provider-sqlite 0.0.4 → 0.0.6

package/dist/runtime/server/db/d1.js

@@ -0,0 +1,30 @@
+import { getD1Database } from "./kysely.js";
+function assertSuccess(result) {
+  if (result.success === false) {
+    throw new Error(result.error ?? "Cloudflare D1 statement failed.");
+  }
+  if (result.error) throw new Error(result.error);
+}
+export async function d1All(sql, ...parameters) {
+  const result = await getD1Database().prepare(sql).bind(...parameters).all();
+  assertSuccess(result);
+  return result.results ?? [];
+}
+export async function d1Run(sql, ...parameters) {
+  const result = await getD1Database().prepare(sql).bind(...parameters).run();
+  assertSuccess(result);
+  return result;
+}
+export async function d1Batch(statements) {
+  const database = getD1Database();
+  if (!database.batch) {
+    throw new Error("The configured D1 binding does not support batch().");
+  }
+  const results = await database.batch(
+    statements.map(
+      ({ sql, parameters = [] }) => database.prepare(sql).bind(...parameters)
+    )
+  );
+  for (const result of results) assertSuccess(result);
+  return results;
+}

package/dist/runtime/server/db/kysely.d.ts

@@ -1,32 +1,70 @@
 /**
- * Kysely singleton for the SQLite provider.
+ * Shared database initialization for the SQLite provider.
  *
- * Creates a single Kysely instance backed by better-sqlite3.
- * Applies WAL + NORMAL pragmas for safe concurrent reads.
+ * The default remains better-sqlite3. Bun and Turso expose the same
+ * synchronous SQLite shape, while Cloudflare D1 uses its native async binding.
  */
 import { Kysely } from 'kysely';
-import Database from 'better-sqlite3';
+import { type D1Database } from './d1-dialect.js';
 import type { Or3SqliteDb } from './schema.js';
+export type SqliteDriver = 'better-sqlite3' | 'bun' | 'turso' | 'd1';
+export interface SqliteRawStatement {
+    readonly reader?: boolean;
+    all(...parameters: unknown[]): unknown[];
+    get(...parameters: unknown[]): unknown;
+    run(...parameters: unknown[]): {
+        changes: number;
+        lastInsertRowid?: number | bigint;
+    };
+    iterate(...parameters: unknown[]): IterableIterator<unknown>;
+}
+type SqliteTransaction<T> = ((...args: unknown[]) => T) & {
+    immediate: (...args: unknown[]) => T;
+};
+export interface SqliteRawDatabase {
+    close(): void;
+    prepare(sql: string): SqliteRawStatement;
+    pragma?(source: string): unknown;
+    exec(source: string): unknown;
+    transaction<T>(fn: (...args: unknown[]) => T): SqliteTransaction<T>;
+}
 export interface SqliteDbOptions {
-    path: string;
+    /** SQLite file path for better-sqlite3 and Bun. */
+    path?: string;
+    /** Explicitly selects a native runtime. Defaults to better-sqlite3. */
+    driver?: SqliteDriver | string;
     journalMode?: string;
     synchronous?: string;
+    /** Turso/libSQL database URL. */
+    tursoUrl?: string;
+    /** Turso/libSQL auth token. */
+    tursoAuthToken?: string;
+    /** Cloudflare D1 binding name. Defaults to DB. */
+    d1Binding?: string;
+    /** Allows integrations and tests to provide a D1 binding directly. */
+    d1Database?: D1Database;
 }
 /**
- * Get or create the singleton Kysely DB.
- * First call initializes the connection and sets pragmas.
+ * Initialize the singleton once during server startup. This is async because
+ * all native runtimes are loaded lazily, keeping Workers bundles Node-free.
  */
-export declare function getSqliteDb(options?: SqliteDbOptions): Kysely<Or3SqliteDb>;
+export declare function initializeSqliteDb(options?: SqliteDbOptions): Promise<Kysely<Or3SqliteDb>>;
 /**
- * Get the underlying better-sqlite3 instance for raw transactions.
- * Only available after getSqliteDb() has been called.
+ * Return the initialized Kysely singleton.
  */
-export declare function getRawDb(): InstanceType<typeof Database>;
+export declare function getSqliteDb(): Kysely<Or3SqliteDb>;
+/** The selected driver, resolving the current environment before initialization. */
+export declare function getSqliteDriver(): SqliteDriver;
+export declare function isD1Driver(): boolean;
 /**
- * Destroy the connection (for tests/cleanup).
+ * Get the native local SQLite connection for synchronous compatibility paths.
+ * D1 intentionally has no synchronous raw connection.
  */
+export declare function getRawDb(): SqliteRawDatabase;
+/** Return the initialized D1 binding when the D1 driver is selected. */
+export declare function getD1Database(): D1Database;
+/** Destroy the current connection (primarily for tests). */
 export declare function destroySqliteDb(): Promise<void>;
-/**
- * Reset the module-level singleton (for tests only).
- */
+/** Reset module state for tests. */
 export declare function _resetForTest(): void;
+export {};

package/dist/runtime/server/db/kysely.js

@@ -1,14 +1,46 @@
 import { Kysely, SqliteDialect } from "kysely";
-import Database from "better-sqlite3";
+import { D1Dialect } from "./d1-dialect.js";
 let instance = null;
 let rawDb = null;
+let d1Db = null;
+let selectedDriver = null;
+let initialization = null;
 function envFlag(value) {
   if (!value) return false;
   const normalized = value.trim().toLowerCase();
   return normalized === "1" || normalized === "true" || normalized === "yes";
 }
-export function getSqliteDb(options) {
-  if (instance) return instance;
+function normalizeDriver(value) {
+  switch (value?.trim().toLowerCase()) {
+    case void 0:
+    case "":
+    case "better-sqlite3":
+    case "better":
+    case "sqlite":
+      return "better-sqlite3";
+    case "bun":
+    case "bun:sqlite":
+      return "bun";
+    case "turso":
+    case "libsql":
+      return "turso";
+    case "d1":
+    case "cloudflare-d1":
+    case "cloudflare":
+      return "d1";
+    default:
+      throw new Error(
+        `Unsupported OR3_SQLITE_DRIVER value "${value}". Use better-sqlite3, bun, turso, or d1.`
+      );
+  }
+}
+function resolveDriver(options) {
+  const configured = options?.driver ?? process.env.OR3_SQLITE_DRIVER;
+  if (configured) return normalizeDriver(configured);
+  if (options?.d1Database) return "d1";
+  return "better-sqlite3";
+}
+function resolveLocalPath(options) {
   const isTestEnv = process.env.NODE_ENV === "test" || envFlag(process.env.VITEST);
   const allowInMemory = envFlag(process.env.OR3_SQLITE_ALLOW_IN_MEMORY);
   const strictMode = envFlag(process.env.OR3_SQLITE_STRICT);
@@ -34,29 +66,355 @@ export function getSqliteDb(options) {
       "[or3-sqlite] OR3_SQLITE_ALLOW_IN_MEMORY=true enabled. Data will be lost on process restart."
     );
   }
-  const journalMode = options?.journalMode ?? process.env.OR3_SQLITE_PRAGMA_JOURNAL_MODE ?? "WAL";
-  const synchronous = options?.synchronous ?? process.env.OR3_SQLITE_PRAGMA_SYNCHRONOUS ?? "NORMAL";
-  rawDb = new Database(path);
-  rawDb.pragma(`journal_mode = ${journalMode}`);
-  rawDb.pragma(`synchronous = ${synchronous}`);
-  rawDb.pragma("foreign_keys = ON");
+  return path;
+}
+function normalizeParameters(parameters) {
+  return parameters.length === 1 && Array.isArray(parameters[0]) ? parameters[0] : parameters;
+}
+function isReaderStatement(sql) {
+  const normalized = sql.trim().toLowerCase();
+  return /^(select|pragma|explain|with)\b/.test(normalized) || /\breturning\b/.test(normalized);
+}
+class BunStatementAdapter {
+  constructor(statement, sql) {
+    this.statement = statement;
+    this.sql = sql;
+  }
+  get reader() {
+    return this.statement.columnNames ? this.statement.columnNames.length > 0 : isReaderStatement(this.sql);
+  }
+  all(...parameters) {
+    return this.statement.all(...normalizeParameters(parameters));
+  }
+  get(...parameters) {
+    return this.statement.get(...normalizeParameters(parameters));
+  }
+  run(...parameters) {
+    const result = this.statement.run(...normalizeParameters(parameters));
+    return {
+      changes: result.changes ?? 0,
+      lastInsertRowid: result.lastInsertRowid
+    };
+  }
+  iterate(...parameters) {
+    const values = normalizeParameters(parameters);
+    return this.statement.iterate ? this.statement.iterate(...values) : this.statement.all(...values)[Symbol.iterator]();
+  }
+}
+class BunDatabaseAdapter {
+  constructor(database) {
+    this.database = database;
+  }
+  close() {
+    this.database.close();
+  }
+  prepare(sql) {
+    return new BunStatementAdapter(this.database.prepare(sql), sql);
+  }
+  pragma(source) {
+    if (this.database.run) return this.database.run(`PRAGMA ${source}`);
+    return this.database.exec?.(`PRAGMA ${source}`);
+  }
+  exec(source) {
+    return this.database.exec?.(source);
+  }
+  transaction(fn) {
+    if (!this.database.transaction) {
+      throw new Error("bun:sqlite does not expose transaction() in this Bun runtime.");
+    }
+    const transaction = this.database.transaction(fn);
+    if (!transaction.immediate) {
+      transaction.immediate = (...args) => transaction(...args);
+    }
+    return transaction;
+  }
+}
+function stripLibsqlMetadata(value) {
+  if (!isRecord(value) || !("_metadata" in value)) return value;
+  const { _metadata: _ignored, ...row } = value;
+  return row;
+}
+class TursoStatementAdapter {
+  constructor(statement) {
+    this.statement = statement;
+  }
+  get reader() {
+    return this.statement.reader;
+  }
+  all(...parameters) {
+    return this.statement.all(...parameters).map(stripLibsqlMetadata);
+  }
+  get(...parameters) {
+    return stripLibsqlMetadata(this.statement.get(...parameters));
+  }
+  run(...parameters) {
+    return stripLibsqlMetadata(
+      this.statement.run(...parameters)
+    );
+  }
+  iterate(...parameters) {
+    return Array.from(
+      this.statement.iterate(...parameters),
+      stripLibsqlMetadata
+    )[Symbol.iterator]();
+  }
+}
+class TursoDatabaseAdapter {
+  constructor(database) {
+    this.database = database;
+  }
+  close() {
+    this.database.close();
+  }
+  prepare(sql) {
+    return new TursoStatementAdapter(this.database.prepare(sql));
+  }
+  pragma(source) {
+    return this.database.pragma?.(source);
+  }
+  exec(source) {
+    return this.database.exec(source);
+  }
+  transaction(fn) {
+    return this.database.transaction(fn);
+  }
+}
+class KyselyStatementAdapter {
+  constructor(statement, sql) {
+    this.statement = statement;
+    this.sql = sql;
+  }
+  get reader() {
+    return this.statement.reader ?? isReaderStatement(this.sql);
+  }
+  all(parameters) {
+    return this.statement.all(parameters);
+  }
+  run(parameters) {
+    const result = this.statement.run(parameters);
+    return {
+      changes: result.changes,
+      lastInsertRowid: result.lastInsertRowid ?? 0
+    };
+  }
+  iterate(parameters) {
+    return this.statement.iterate(parameters);
+  }
+}
+class KyselyDatabaseAdapter {
+  constructor(database) {
+    this.database = database;
+  }
+  close() {
+    this.database.close();
+  }
+  prepare(sql) {
+    return new KyselyStatementAdapter(this.database.prepare(sql), sql);
+  }
+}
+function validatePragmaValue(name, value) {
+  const normalized = value.trim();
+  if (!/^[a-z0-9_]+$/i.test(normalized)) {
+    throw new Error(`Invalid ${name} pragma value.`);
+  }
+  return normalized;
+}
+function applyLocalPragmas(db, options) {
+  const journalMode = validatePragmaValue(
+    "journal_mode",
+    options?.journalMode ?? process.env.OR3_SQLITE_PRAGMA_JOURNAL_MODE ?? "WAL"
+  );
+  const synchronous = validatePragmaValue(
+    "synchronous",
+    options?.synchronous ?? process.env.OR3_SQLITE_PRAGMA_SYNCHRONOUS ?? "NORMAL"
+  );
+  db.pragma?.(`journal_mode = ${journalMode}`);
+  db.pragma?.(`synchronous = ${synchronous}`);
+  db.pragma?.("foreign_keys = ON");
+}
+async function importRuntimeModule(moduleName) {
+  const imported = await import(
+    /* @vite-ignore */
+    moduleName
+  );
+  if (!isRecord(imported)) {
+    throw new Error(`Runtime module "${moduleName}" did not export an object.`);
+  }
+  return imported;
+}
+async function importCloudflareWorkersModule() {
+  const imported = await import(
+    /* @vite-ignore */
+    "cloudflare:workers"
+  );
+  if (!isRecord(imported)) {
+    throw new Error("cloudflare:workers did not export an object.");
+  }
+  return imported;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function asDatabaseConstructor(value) {
+  return typeof value === "function" ? value : null;
+}
+async function createBetterSqliteDatabase(path) {
+  let imported;
+  try {
+    imported = await importRuntimeModule("better-sqlite3");
+  } catch (error) {
+    throw new Error(
+      "Unable to load better-sqlite3. Install it or set OR3_SQLITE_DRIVER to bun, turso, or d1.",
+      { cause: error }
+    );
+  }
+  const Database = asDatabaseConstructor(imported.default);
+  if (!Database) {
+    throw new Error("better-sqlite3 did not provide a Database constructor.");
+  }
+  return new Database(path);
+}
+async function createBunSqliteDatabase(path) {
+  let imported;
+  try {
+    imported = await import(
+      /* @vite-ignore */
+      "bun:sqlite"
+    );
+  } catch (error) {
+    throw new Error(
+      "OR3_SQLITE_DRIVER=bun requires Bun and its built-in bun:sqlite module.",
+      { cause: error }
+    );
+  }
+  const Database = asDatabaseConstructor(
+    imported.Database ?? imported.default
+  );
+  if (!Database) {
+    throw new Error("bun:sqlite did not provide a Database constructor.");
+  }
+  return new BunDatabaseAdapter(new Database(path));
+}
+async function createTursoDatabase(options) {
+  const url = options?.tursoUrl ?? process.env.OR3_SQLITE_TURSO_URL;
+  const authToken = options?.tursoAuthToken ?? process.env.OR3_SQLITE_TURSO_AUTH_TOKEN;
+  if (!url?.trim()) {
+    throw new Error("OR3_SQLITE_TURSO_URL is required when OR3_SQLITE_DRIVER=turso.");
+  }
+  if (!authToken?.trim()) {
+    throw new Error(
+      "OR3_SQLITE_TURSO_AUTH_TOKEN is required when OR3_SQLITE_DRIVER=turso."
+    );
+  }
+  let imported;
+  try {
+    imported = await importRuntimeModule("libsql");
+  } catch (error) {
+    throw new Error(
+      "Unable to load libsql for Turso. Install the libsql package and try again.",
+      { cause: error }
+    );
+  }
+  const Database = asDatabaseConstructor(
+    imported.default ?? imported.Database
+  );
+  if (!Database) {
+    throw new Error("libsql did not provide a Database constructor.");
+  }
+  return new TursoDatabaseAdapter(new Database(url, { authToken }));
+}
+async function resolveD1Database(options) {
+  if (options?.d1Database) return options.d1Database;
+  const binding = (options?.d1Binding ?? process.env.OR3_SQLITE_D1_BINDING ?? "DB").trim();
+  if (!binding) {
+    throw new Error("OR3_SQLITE_D1_BINDING must name a Cloudflare D1 binding.");
+  }
+  let imported;
+  try {
+    imported = await importCloudflareWorkersModule();
+  } catch (error) {
+    throw new Error(
+      "OR3_SQLITE_DRIVER=d1 requires a Cloudflare Workers runtime with a D1 binding.",
+      { cause: error }
+    );
+  }
+  const env = imported.env;
+  const database = isRecord(env) ? env[binding] : void 0;
+  if (!isD1Database(database)) {
+    throw new Error(
+      `Cloudflare D1 binding "${binding}" was not found. Set OR3_SQLITE_D1_BINDING to the binding name from wrangler.jsonc.`
+    );
+  }
+  return database;
+}
+function isD1Database(value) {
+  return isRecord(value) && typeof value.prepare === "function";
+}
+async function initialize(options) {
+  const driver = resolveDriver(options);
+  selectedDriver = driver;
+  if (driver === "d1") {
+    d1Db = await resolveD1Database(options);
+    instance = new Kysely({
+      dialect: new D1Dialect(d1Db)
+    });
+    return instance;
+  }
+  const path = resolveLocalPath(options);
+  rawDb = driver === "bun" ? await createBunSqliteDatabase(path) : driver === "turso" ? await createTursoDatabase(options) : await createBetterSqliteDatabase(path);
+  if (driver !== "turso") applyLocalPragmas(rawDb, options);
   instance = new Kysely({
-    dialect: new SqliteDialect({ database: rawDb })
+    dialect: new SqliteDialect({ database: new KyselyDatabaseAdapter(rawDb) })
   });
   return instance;
 }
+export async function initializeSqliteDb(options) {
+  if (instance) return instance;
+  if (!initialization) {
+    initialization = initialize(options).finally(() => {
+      initialization = null;
+    });
+  }
+  return initialization;
+}
+export function getSqliteDb() {
+  if (!instance) {
+    throw new Error(
+      "SQLite DB not initialized \u2014 await initializeSqliteDb() before calling getSqliteDb()."
+    );
+  }
+  return instance;
+}
+export function getSqliteDriver() {
+  return selectedDriver ?? resolveDriver(void 0);
+}
+export function isD1Driver() {
+  return getSqliteDriver() === "d1";
+}
 export function getRawDb() {
-  if (!rawDb) throw new Error("SQLite DB not initialized \u2014 call getSqliteDb() first");
+  if (!rawDb) {
+    const suffix = isD1Driver() ? " Cloudflare D1 uses an async native binding." : "";
+    throw new Error(`SQLite raw DB not initialized.${suffix}`);
+  }
   return rawDb;
 }
-export async function destroySqliteDb() {
-  if (instance) {
-    await instance.destroy();
-    instance = null;
-    rawDb = null;
+export function getD1Database() {
+  if (!d1Db) {
+    throw new Error("Cloudflare D1 is not initialized \u2014 call initializeSqliteDb() first.");
   }
+  return d1Db;
+}
+export async function destroySqliteDb() {
+  if (instance) await instance.destroy();
+  instance = null;
+  rawDb = null;
+  d1Db = null;
+  selectedDriver = null;
 }
 export function _resetForTest() {
   instance = null;
   rawDb = null;
+  d1Db = null;
+  selectedDriver = null;
+  initialization = null;
 }

package/dist/runtime/server/db/migrate.js

@@ -14,6 +14,7 @@ import * as m012 from "./migrations/012_connect_credential_redelivery.js";
 import * as m013 from "./migrations/013_connect_environment_lifecycle.js";
 import * as m014 from "./migrations/014_connect_retention_activation.js";
 import * as m015 from "./migrations/015_rate_limits.js";
+import * as m016 from "./migrations/016_connect_runtime_binding.js";
 const REQUIRED_SCHEMA_TABLES = [
   "users",
   "auth_accounts",
@@ -55,7 +56,8 @@ const migrations = {
   "012_connect_credential_redelivery": m012,
   "013_connect_environment_lifecycle": m013,
   "014_connect_retention_activation": m014,
-  "015_rate_limits": m015
+  "015_rate_limits": m015,
+  "016_connect_runtime_binding": m016
 };
 class StaticMigrationProvider {
   async getMigrations() {

package/dist/runtime/server/db/migrations/016_connect_runtime_binding.d.ts

@@ -0,0 +1,4 @@
+import { type Kysely } from 'kysely';
+/** Adds the additive runtime binding used by Runs-compatible Connect hosts. */
+export declare function up(db: Kysely<unknown>): Promise<void>;
+export declare function down(db: Kysely<unknown>): Promise<void>;

package/dist/runtime/server/db/migrations/016_connect_runtime_binding.js

@@ -0,0 +1,28 @@
+import { sql } from "kysely";
+export async function up(db) {
+  const result = await sql`
+        PRAGMA table_info(connect_environments)
+    `.execute(db);
+  const columns = new Set(result.rows.map((column) => column.name));
+  if (!columns.has("driver")) {
+    await sql`
+            ALTER TABLE connect_environments
+            ADD COLUMN driver TEXT
+        `.execute(db);
+  }
+  if (!columns.has("runtime")) {
+    await sql`
+            ALTER TABLE connect_environments
+            ADD COLUMN runtime TEXT
+        `.execute(db);
+  }
+  if (!columns.has("base_path")) {
+    await sql`
+            ALTER TABLE connect_environments
+            ADD COLUMN base_path TEXT
+        `.execute(db);
+  }
+}
+export async function down(db) {
+  void db;
+}

package/dist/runtime/server/db/schema.d.ts

@@ -164,6 +164,9 @@ export interface ConnectEnvironmentsTable {
     control_token_hash: string;
     access_credential_ciphertext: string;
     tunnel_secret_ciphertext: string | null;
+    driver: 'intern' | 'runs' | null;
+    runtime: 'intern' | 'openclaw' | 'hermes' | null;
+    base_path: '/' | '/or3/' | null;
     status: 'provisioning' | 'active' | 'revoking' | 'revoked' | 'error';
     lifecycle_attempts: number;
     lifecycle_next_attempt_at: number;

package/dist/runtime/server/plugins/register.js

@@ -16,18 +16,24 @@ import {
 } from "../admin/stores/sqlite-store.js";
 import { sqliteSyncAdminAdapter } from "../admin/adapters/sync-sqlite.js";
 import { createSqliteConnectStore } from "../connect/sqlite-connect-store.js";
-import { getSqliteDb } from "../db/kysely.js";
+import { getSqliteDriver, initializeSqliteDb } from "../db/kysely.js";
 import { runMigrations } from "../db/migrate.js";
 import { sqliteRateLimitProvider } from "../rate-limit/sqlite-provider.js";
 import { useRuntimeConfig } from "#imports";
 const SQLITE_PROVIDER_ID = "sqlite";
-export default defineNitroPlugin(async () => {
+let d1RuntimeInitialization;
+export default defineNitroPlugin(async (nitroApp) => {
   const config = useRuntimeConfig();
   if (!config.auth?.enabled) return;
   const syncSelected = config.sync?.enabled === true && config.sync?.provider === SQLITE_PROVIDER_ID;
   const connectSelected = config.connect?.enabled === true && config.connect?.provider === SQLITE_PROVIDER_ID;
   if (!syncSelected && !connectSelected) return;
-  const db = getSqliteDb();
+  const driver = getSqliteDriver();
+  if (driver === "d1" && connectSelected) {
+    throw new Error(
+      "[or3-sqlite] Cloudflare D1 supports Auth and Sync, but OR3 Connect still requires a synchronous SQLite runtime. Set OR3_CONNECT_ENABLED=false or choose better-sqlite3, Bun, or Turso."
+    );
+  }
   registerAuthWorkspaceStore({
     id: SQLITE_PROVIDER_ID,
     order: 100,
@@ -48,24 +54,38 @@ export default defineNitroPlugin(async () => {
       create: createSqliteConnectStore
     });
   }
-  registerWebhookStore({
-    id: SQLITE_PROVIDER_ID,
-    order: 100,
-    create: createSqliteWebhookStore
-  });
+  if (driver !== "d1") {
+    registerWebhookStore({
+      id: SQLITE_PROVIDER_ID,
+      order: 100,
+      create: createSqliteWebhookStore
+    });
+  } else {
+    console.warn(
+      "[or3-sqlite] Webhook persistence is unavailable with Cloudflare D1."
+    );
+  }
   registerAdminStoreProvider({
     id: SQLITE_PROVIDER_ID,
     createWorkspaceAccessStore: createSqliteWorkspaceAccessStore,
     createWorkspaceSettingsStore: createSqliteWorkspaceSettingsStore,
     createAdminUserStore: createSqliteAdminUserStore,
     getCapabilities: () => ({
-      supportsServerSideAdmin: true,
-      supportsUserSearch: true,
-      supportsWorkspaceList: true,
-      supportsWorkspaceManagement: true,
-      supportsDeploymentAdminGrants: true
+      supportsServerSideAdmin: driver !== "d1",
+      supportsUserSearch: driver !== "d1",
+      supportsWorkspaceList: driver !== "d1",
+      supportsWorkspaceManagement: driver !== "d1",
+      supportsDeploymentAdminGrants: driver !== "d1"
     })
   });
   registerProviderAdminAdapter(sqliteSyncAdminAdapter);
+  if (driver === "d1") {
+    nitroApp.hooks.hook("request", async () => {
+      d1RuntimeInitialization ??= initializeSqliteDb().then(runMigrations);
+      await d1RuntimeInitialization;
+    });
+    return;
+  }
+  const db = await initializeSqliteDb();
   await runMigrations(db);
 });

package/dist/runtime/server/rate-limit/sqlite-provider.d.ts

@@ -3,5 +3,7 @@ export declare class SqliteRateLimitProvider implements RateLimitProvider {
     readonly name = "sqlite";
     checkAndRecord(key: string, config: RateLimitConfig): Promise<RateLimitResult>;
     getStats(key: string, config: RateLimitConfig): Promise<RateLimitStats | null>;
+    private checkAndRecordInD1;
+    private getStatsInD1;
 }
 export declare const sqliteRateLimitProvider: SqliteRateLimitProvider;