@remix-run/data-table-sqlite 0.5.0 → 0.6.0

package/README.md

@@ -1,13 +1,12 @@
 # data-table-sqlite
 
-SQLite adapter for [`remix/data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table).
-Use this package when you want `data-table` APIs backed by a synchronous SQLite client.
+SQLite database driver for [`remix/data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table), backed by a synchronous SQLite client.
 
 ## Features
 
-- **Native Runtime SQLite Support**: Works with Node's `node:sqlite` `DatabaseSync`, Bun's `bun:sqlite` `Database`, and compatible synchronous SQLite clients
+- **Native Runtime SQLite Support**: Opens a configured filename with Node's `node:sqlite` or Bun's `bun:sqlite`, or uses a compatible synchronous SQLite client
 - **Full `data-table` API Support**: Queries, relations, writes, and transactions
-- **Adapter-Owned Compiler**: SQL compilation lives in this adapter, with optional shared pure helpers from `data-table`
+- **SQLite Compiler**: SQL compilation is handled automatically for SQLite
 - **Multi-Statement Migrations**: `executeScript()` runs `up.sql` / `down.sql` files via `Database.exec()`
 - **SQLite Capabilities Enabled By Default**:
   - `returning: true`
@@ -24,32 +23,42 @@ npm i remix
 
 ## Usage
 
-### Node
-
 ```ts
-import { DatabaseSync } from 'node:sqlite'
-import { createDatabase } from 'remix/data-table'
-import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
+import { createSqliteDatabase } from 'remix/data-table/sqlite'
 
-let sqlite = new DatabaseSync('app.db')
-let db = createDatabase(createSqliteDatabaseAdapter(sqlite))
+let db = createSqliteDatabase({
+  filename: 'app.db',
+  foreignKeys: true,
+})
 ```
 
-### Bun
+The config-backed database uses `node:sqlite` in Node.js and `bun:sqlite` in Bun. It supports `db.wipe()` and `db.reset()` because it can close and reopen the database file. Call `await db.close()` during application shutdown to release the connection and its file handle.
+
+Foreign key enforcement defaults to off on every runtime. When `foreignKeys` is enabled, the database restores foreign key enforcement each time it opens the connection, including after destructive lifecycle operations.
+
+The database also applies `pragma busy_timeout = 5000` whenever it opens the connection, so writes wait for a locked database instead of failing immediately with `SQLITE_BUSY`. Use `busyTimeout` to override the timeout in milliseconds (`0` disables the wait).
+
+You may also pass an existing synchronous client when your application owns its lifecycle:
 
 ```ts
 import { Database } from 'bun:sqlite'
-import { createDatabase } from 'remix/data-table'
-import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
+import { createSqliteDatabase } from 'remix/data-table/sqlite'
 
 let sqlite = new Database('app.db')
-let db = createDatabase(createSqliteDatabaseAdapter(sqlite))
+let db = createSqliteDatabase(sqlite)
+
+// Leaves the supplied client open.
+await db.close()
+
+// The application closes the client it owns.
+sqlite.close()
 ```
 
-This is a good fit for local development, embedded deployments, and single-node services.
-Import any driver-specific types you need directly from your runtime's SQLite module.
+Destructive lifecycle methods are unavailable when you pass an existing client.
+
+This is a good fit for local development, embedded deployments, and single-node services. Import any driver-specific types you need directly from your runtime's SQLite module.
 
-## Adapter Capabilities
+## Database Capabilities
 
 `data-table-sqlite` reports this capability set by default:
 
@@ -61,23 +70,30 @@ Import any driver-specific types you need directly from your runtime's SQLite mo
 
 ## Advanced Usage
 
+### Destructive Lifecycle And Locking
+
+`db.wipe()` and `db.reset()` assume a single process owns the database file. Stop other processes before wiping: on POSIX systems another process keeps writing to the deleted inode, and on Windows an open handle blocks deletion entirely. Wiping removes the `-wal`, `-shm`, and `-journal` sidecar files along with the main database file so a freshly created database never associates with stale sidecars.
+
+SQLite migrations run without a cross-process migration lock (`migrationLock: false`), so run migrations from one process at a time.
+
+`filename` resolves against the current working directory — for `remix db` commands, wherever you invoke the CLI. Prefer absolute paths or paths derived from `import.meta.dirname`.
+
 ### In-Memory Database For Tests
 
 ```ts
 import { DatabaseSync } from 'node:sqlite'
-import { createDatabase } from 'remix/data-table'
-import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
+import { createSqliteDatabase } from 'remix/data-table/sqlite'
 
 let sqlite = new DatabaseSync(':memory:')
-let db = createDatabase(createSqliteDatabaseAdapter(sqlite))
+let db = createSqliteDatabase(sqlite)
 ```
 
 ## Related Packages
 
 - [`data-table`](https://github.com/remix-run/remix/tree/main/packages/data-table) - Core query/relations API
 - [`data-schema`](https://github.com/remix-run/remix/tree/main/packages/data-schema) - Schema parsing and validation
-- [`data-table-postgres`](https://github.com/remix-run/remix/tree/main/packages/data-table-postgres) - PostgreSQL adapter
-- [`data-table-mysql`](https://github.com/remix-run/remix/tree/main/packages/data-table-mysql) - MySQL adapter
+- [`data-table-postgres`](https://github.com/remix-run/remix/tree/main/packages/data-table-postgres) - PostgreSQL database driver
+- [`data-table-mysql`](https://github.com/remix-run/remix/tree/main/packages/data-table-mysql) - MySQL database driver
 
 ## License
 

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { createSqliteDatabaseAdapter, SqliteDatabaseAdapter } from './lib/adapter.ts';
-export type { SqliteDatabase, SqliteRunResult, SqliteStatement } from './lib/adapter.ts';
+export { createSqliteDatabase, SqliteDatabase } from './lib/database.ts';
+export type { SqliteDatabaseClient, SqliteDatabaseConfig, SqliteRunResult, SqliteStatement, } from './lib/driver.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AACrF,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACxE,YAAY,EACV,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,eAAe,GAChB,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -1 +1 @@
-export { createSqliteDatabaseAdapter, SqliteDatabaseAdapter } from "./lib/adapter.js";
+export { createSqliteDatabase, SqliteDatabase } from './lib/database.js';

package/dist/lib/database.d.ts

@@ -0,0 +1,29 @@
+import { Database, type DatabaseOptions } from '@remix-run/data-table';
+import { type SqliteDatabaseClient, type SqliteDatabaseConfig } from './driver.ts';
+/** A {@link Database} backed by SQLite. */
+export declare class SqliteDatabase extends Database<'sqlite'> {
+    /**
+     * Creates a SQLite-backed database.
+     * @param input SQLite configuration or synchronous database client.
+     * @param options Database runtime options.
+     */
+    constructor(input: SqliteDatabaseClient | SqliteDatabaseConfig, options?: DatabaseOptions);
+}
+/**
+ * Creates a SQLite-backed database.
+ *
+ * @param input SQLite configuration or synchronous database client.
+ * @param options Database runtime options.
+ * @returns A SQLite database.
+ * @example
+ * ```ts
+ * import { createSqliteDatabase } from 'remix/data-table/sqlite'
+ *
+ * let db = createSqliteDatabase({
+ *   filename: './data/app.db',
+ *   foreignKeys: true,
+ * })
+ * ```
+ */
+export declare function createSqliteDatabase(input: SqliteDatabaseClient | SqliteDatabaseConfig, options?: DatabaseOptions): SqliteDatabase;
+//# sourceMappingURL=database.d.ts.map

package/dist/lib/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/lib/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAEtE,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EAC1B,MAAM,aAAa,CAAA;AAEpB,2CAA2C;AAC3C,qBAAa,cAAe,SAAQ,QAAQ,CAAC,QAAQ,CAAC;IACpD;;;;OAIG;IACH,YAAY,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,EAAE,OAAO,GAAE,eAAoB,EAE5F;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,EAClD,OAAO,GAAE,eAAoB,GAC5B,cAAc,CAEhB"}

package/dist/lib/database.js

@@ -0,0 +1,32 @@
+import { Database } from '@remix-run/data-table';
+import { SqliteDatabaseDriver, } from './driver.js';
+/** A {@link Database} backed by SQLite. */
+export class SqliteDatabase extends Database {
+    /**
+     * Creates a SQLite-backed database.
+     * @param input SQLite configuration or synchronous database client.
+     * @param options Database runtime options.
+     */
+    constructor(input, options = {}) {
+        super(new SqliteDatabaseDriver(input), options);
+    }
+}
+/**
+ * Creates a SQLite-backed database.
+ *
+ * @param input SQLite configuration or synchronous database client.
+ * @param options Database runtime options.
+ * @returns A SQLite database.
+ * @example
+ * ```ts
+ * import { createSqliteDatabase } from 'remix/data-table/sqlite'
+ *
+ * let db = createSqliteDatabase({
+ *   filename: './data/app.db',
+ *   foreignKeys: true,
+ * })
+ * ```
+ */
+export function createSqliteDatabase(input, options = {}) {
+    return new SqliteDatabase(input, options);
+}

package/dist/lib/{adapter.d.ts → driver.d.ts}

@@ -1,16 +1,33 @@
-import type { DataManipulationRequest, DataManipulationResult, DataManipulationOperation, DatabaseAdapter, SqlStatement, TableRef, TransactionOptions, TransactionToken } from '@remix-run/data-table';
+import type { DataManipulationOperation, DataManipulationRequest, DataManipulationResult, DatabaseDriver, SqlStatement, TableRef, TransactionOptions, TransactionToken } from '@remix-run/data-table';
 /**
- * Synchronous SQLite database client accepted by the sqlite adapter.
+ * Synchronous SQLite client accepted by `createSqliteDatabase()`.
  *
  * This matches the shared surface of Node's `node:sqlite` `DatabaseSync`, Bun's `bun:sqlite`
  * `Database`, and compatible synchronous SQLite clients.
  */
-export interface SqliteDatabase {
+export interface SqliteDatabaseClient {
     prepare(sql: string): SqliteStatement;
     exec(sql: string): unknown;
+    close?: () => void;
+}
+/** Configuration for a SQLite database created by `createSqliteDatabase()`. */
+export interface SqliteDatabaseConfig {
+    /** SQLite database filename or `:memory:` for an in-memory database. */
+    filename: string;
+    /**
+     * Enables SQLite foreign key enforcement whenever the database opens a connection.
+     * Defaults to `false` (enforcement off) on every runtime, including Node.js where
+     * `node:sqlite` would otherwise enable it by default.
+     */
+    foreignKeys?: boolean;
+    /**
+     * SQLite `busy_timeout` in milliseconds, applied whenever the database opens a connection.
+     * Defaults to `5000`. Set `0` to fail immediately when another process holds a write lock.
+     */
+    busyTimeout?: number;
 }
 /**
- * Prepared statement shape used by {@link SqliteDatabase}.
+ * Prepared statement shape used by {@link SqliteDatabaseClient}.
  */
 export interface SqliteStatement {
     all(...values: unknown[]): unknown[];
@@ -28,25 +45,25 @@ export interface SqliteRunResult {
     lastInsertRowid: unknown;
 }
 /**
- * `DatabaseAdapter` implementation for synchronous SQLite clients.
+ * SQLite database driver backed by a synchronous SQLite client.
  */
-export declare class SqliteDatabaseAdapter implements DatabaseAdapter {
+export declare class SqliteDatabaseDriver implements DatabaseDriver<'sqlite'> {
     #private;
     /**
-     * The SQL dialect identifier reported by this adapter.
+     * The SQL dialect identifier reported by this database.
      */
-    dialect: string;
+    get dialect(): 'sqlite';
     /**
-     * Feature flags describing the sqlite behaviors supported by this adapter.
+     * Feature flags describing the SQLite behaviors supported by this database.
      */
-    capabilities: {
-        returning: boolean;
-        savepoints: boolean;
-        upsert: boolean;
-        transactionalDdl: boolean;
-        migrationLock: boolean;
-    };
-    constructor(database: SqliteDatabase);
+    get capabilities(): Readonly<{
+        returning: true;
+        savepoints: true;
+        upsert: true;
+        transactionalDdl: true;
+        migrationLock: false;
+    }>;
+    constructor(input: SqliteDatabaseClient | SqliteDatabaseConfig);
     /**
      * Compiles a data-manipulation operation to sqlite SQL statements.
      * @param operation Operation to compile.
@@ -81,6 +98,20 @@ export declare class SqliteDatabaseAdapter implements DatabaseAdapter {
      * @returns `true` when the column exists.
      */
     hasColumn(table: TableRef, column: string, transaction?: TransactionToken): Promise<boolean>;
+    /**
+     * Destructively recreates the configured SQLite database.
+     * @returns A promise that resolves when the database is ready for use.
+     */
+    wipe(): Promise<void>;
+    /**
+     * Closes a database connection created from configuration.
+     *
+     * Config-backed databases keep an open handle that locks the database file on
+     * Windows until it is closed, so callers that need to move or delete the file
+     * should close the database first. Supplied clients remain caller-owned. Safe
+     * to call more than once.
+     */
+    close(): void;
     /**
      * Starts a sqlite transaction.
      * @param options Transaction options.
@@ -121,20 +152,4 @@ export declare class SqliteDatabaseAdapter implements DatabaseAdapter {
      */
     releaseSavepoint(token: TransactionToken, name: string): Promise<void>;
 }
-/**
- * Creates a sqlite `DatabaseAdapter`.
- * @param database Synchronous SQLite database client.
- * @returns A configured sqlite adapter.
- * @example
- * ```ts
- * import { DatabaseSync } from 'node:sqlite'
- * import { createDatabase } from 'remix/data-table'
- * import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
- *
- * let sqlite = new DatabaseSync('./data/app.db')
- * let adapter = createSqliteDatabaseAdapter(sqlite)
- * let db = createDatabase(adapter)
- * ```
- */
-export declare function createSqliteDatabaseAdapter(database: SqliteDatabase): SqliteDatabaseAdapter;
-//# sourceMappingURL=adapter.d.ts.map
+//# sourceMappingURL=driver.d.ts.map

package/dist/lib/driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../src/lib/driver.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,yBAAyB,EACzB,uBAAuB,EACvB,sBAAsB,EACtB,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,uBAAuB,CAAA;AAK9B;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAA;IACrC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IAC1B,KAAK,CAAC,EAAE,MAAM,IAAI,CAAA;CACnB;AAkDD,+EAA+E;AAC/E,MAAM,WAAW,oBAAoB;IACnC,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAA;IACpC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAA;IAClC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,eAAe,CAAA;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,OAAO,EAAE,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,eAAe,EAAE,OAAO,CAAA;CACzB;AAED;;GAEG;AACH,qBAAa,oBAAqB,YAAW,cAAc,CAAC,QAAQ,CAAC;;IACnE;;OAEG;IACH,IAAI,OAAO,IAAI,QAAQ,CAEtB;IAED;;OAEG;IACH,IAAI,YAAY;;;;;;OAEf;IAQD,YAAY,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,EAO7D;IAED;;;;OAIG;IACH,UAAU,CAAC,SAAS,EAAE,yBAAyB,GAAG,YAAY,EAAE,CAG/D;IAED;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAuC/E;IAED;;;;;OAKG;IACG,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ9E;IAED;;;;;OAKG;IACG,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAgBhF;IAED;;;;;;OAMG;IACG,SAAS,CACb,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,gBAAgB,GAC7B,OAAO,CAAC,OAAO,CAAC,CAclB;IAED;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAqB1B;IAED;;;;;;;OAOG;IACH,KAAK,IAAI,IAAI,CAKZ;IAED;;;;OAIG;IACG,gBAAgB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAc9E;IAED;;;;OAIG;IACG,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsB9D;IAED;;;;OAIG;IACG,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhE;IAED;;;;;OAKG;IACG,eAAe,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1E;IAED;;;;;OAKG;IACG,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9E;IAED;;;;;OAKG;IACG,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG3E;CAqDF"}

package/dist/lib/{adapter.js → driver.js}

@@ -1,29 +1,68 @@
+import { dirname } from 'node:path';
+import { mkdir, rm } from 'node:fs/promises';
+import { setTimeout } from 'node:timers/promises';
 import { getTablePrimaryKey } from '@remix-run/data-table';
-import { compileSqliteOperation } from "./sql-compiler.js";
+import { compileSqliteOperation } from './sql-compiler.js';
+const sqliteCapabilities = Object.freeze({
+    returning: true,
+    savepoints: true,
+    upsert: true,
+    transactionalDdl: true,
+    migrationLock: false,
+});
+let loadedDriverConstructor;
+// The runtime driver loads lazily on config-backed construction so client-backed databases
+// keep working in environments that cannot resolve node:sqlite or bun:sqlite at import time,
+// and so bundlers never try to resolve those specifiers statically.
+function loadSqliteDatabaseConstructor() {
+    if (!loadedDriverConstructor) {
+        if ('Bun' in globalThis) {
+            // import.meta.require is Bun's synchronous require for ES modules; Bun does not
+            // implement process.getBuiltinModule
+            let importMeta = import.meta;
+            let driver = importMeta.require?.('bun:sqlite');
+            loadedDriverConstructor = driver?.Database;
+        }
+        else {
+            // process.getBuiltinModule loads node:sqlite synchronously (Node.js 22.3+)
+            let driver = globalThis.process?.getBuiltinModule?.('node:sqlite');
+            loadedDriverConstructor = driver?.DatabaseSync;
+        }
+        if (!loadedDriverConstructor) {
+            throw new Error('SQLite config-based construction requires node:sqlite (Node.js 22.5+) or bun:sqlite; pass a SQLite database client instead');
+        }
+    }
+    return loadedDriverConstructor;
+}
 /**
- * `DatabaseAdapter` implementation for synchronous SQLite clients.
+ * SQLite database driver backed by a synchronous SQLite client.
  */
-export class SqliteDatabaseAdapter {
+export class SqliteDatabaseDriver {
     /**
-     * The SQL dialect identifier reported by this adapter.
+     * The SQL dialect identifier reported by this database.
      */
-    dialect = 'sqlite';
+    get dialect() {
+        return 'sqlite';
+    }
     /**
-     * Feature flags describing the sqlite behaviors supported by this adapter.
+     * Feature flags describing the SQLite behaviors supported by this database.
      */
-    capabilities;
+    get capabilities() {
+        return sqliteCapabilities;
+    }
+    #config;
     #database;
+    #databaseOpen = true;
     #transactions = new Set();
     #transactionCounter = 0;
-    constructor(database) {
-        this.#database = database;
-        this.capabilities = {
-            returning: true,
-            savepoints: true,
-            upsert: true,
-            transactionalDdl: true,
-            migrationLock: false,
-        };
+    constructor(input) {
+        if (isSqliteDatabase(input)) {
+            this.#database = input;
+        }
+        else {
+            this.#config = input;
+            this.#database = openSqliteDatabase(input);
+        }
     }
     /**
      * Compiles a data-manipulation operation to sqlite SQL statements.
@@ -40,6 +79,7 @@ export class SqliteDatabaseAdapter {
      * @returns Execution result.
      */
     async execute(request) {
+        this.#assertDatabaseOpen();
         if (request.operation.kind === 'insertMany' && request.operation.values.length === 0) {
             return {
                 affectedRows: 0,
@@ -47,6 +87,9 @@ export class SqliteDatabaseAdapter {
                 rows: request.operation.returning ? [] : undefined,
             };
         }
+        if (request.transaction) {
+            this.#assertTransaction(request.transaction);
+        }
         let statement = this.compileSql(request.operation)[0];
         let prepared = this.#database.prepare(statement.text);
         let values = normalizeStatementValues(statement.values);
@@ -74,6 +117,7 @@ export class SqliteDatabaseAdapter {
      * @returns A promise that resolves once execution completes.
      */
     async executeScript(sql, transaction) {
+        this.#assertDatabaseOpen();
         if (transaction) {
             this.#assertTransaction(transaction);
         }
@@ -86,6 +130,7 @@ export class SqliteDatabaseAdapter {
      * @returns `true` when the table exists.
      */
     async hasTable(table, transaction) {
+        this.#assertDatabaseOpen();
         if (transaction) {
             this.#assertTransaction(transaction);
         }
@@ -93,8 +138,9 @@ export class SqliteDatabaseAdapter {
             ? quoteIdentifier(table.schema) + '.sqlite_master'
             : 'sqlite_master';
         let statement = this.#database.prepare('select 1 from ' + masterTable + ' where type = ? and name = ? limit 1');
+        // node:sqlite returns `undefined` for a missing row while bun:sqlite returns `null`
         let row = statement.get('table', table.name);
-        return row !== undefined;
+        return row != null;
     }
     /**
      * Checks whether a column exists in sqlite.
@@ -104,6 +150,7 @@ export class SqliteDatabaseAdapter {
      * @returns `true` when the column exists.
      */
     async hasColumn(table, column, transaction) {
+        this.#assertDatabaseOpen();
         if (transaction) {
             this.#assertTransaction(transaction);
         }
@@ -112,12 +159,52 @@ export class SqliteDatabaseAdapter {
         let rows = statement.all();
         return rows.some((row) => row.name === column);
     }
+    /**
+     * Destructively recreates the configured SQLite database.
+     * @returns A promise that resolves when the database is ready for use.
+     */
+    async wipe() {
+        let config = this.#configOrThrow('wipe');
+        this.#assertNoOpenTransactions('wipe');
+        this.#closeDatabase();
+        if (config.filename === ':memory:') {
+            this.#replaceDatabase();
+            return;
+        }
+        try {
+            await mkdir(dirname(config.filename), { recursive: true });
+            await removeDatabaseFile(config.filename);
+            // SQLite associates a database file with -wal/-shm/-journal sidecars by path, so
+            // stale sidecars left next to a freshly created database are a corruption vector
+            await removeDatabaseFile(config.filename + '-wal');
+            await removeDatabaseFile(config.filename + '-shm');
+            await removeDatabaseFile(config.filename + '-journal');
+        }
+        finally {
+            this.#replaceDatabase();
+        }
+    }
+    /**
+     * Closes a database connection created from configuration.
+     *
+     * Config-backed databases keep an open handle that locks the database file on
+     * Windows until it is closed, so callers that need to move or delete the file
+     * should close the database first. Supplied clients remain caller-owned. Safe
+     * to call more than once.
+     */
+    close() {
+        this.#assertNoOpenTransactions('close');
+        if (this.#config) {
+            this.#closeDatabase();
+        }
+    }
     /**
      * Starts a sqlite transaction.
      * @param options Transaction options.
      * @returns Transaction token.
      */
     async beginTransaction(options) {
+        this.#assertDatabaseOpen();
         if (options?.isolationLevel === 'read uncommitted') {
             this.#database.exec('pragma read_uncommitted = true');
         }
@@ -134,8 +221,30 @@ export class SqliteDatabaseAdapter {
      */
     async commitTransaction(token) {
         this.#assertTransaction(token);
-        this.#database.exec('commit');
-        this.#transactions.delete(token.id);
+        try {
+            this.#database.exec('commit');
+        }
+        catch (commitError) {
+            try {
+                this.#database.exec('rollback');
+            }
+            catch (rollbackError) {
+                let failures = [commitError, rollbackError];
+                try {
+                    this.#discardUncertainConnection();
+                }
+                catch (recoveryError) {
+                    failures.push(recoveryError);
+                }
+                throw new AggregateError(failures, 'SQLite commit and rollback both failed', {
+                    cause: commitError,
+                });
+            }
+            throw commitError;
+        }
+        finally {
+            this.#transactions.delete(token.id);
+        }
     }
     /**
      * Rolls back an open sqlite transaction.
@@ -144,8 +253,21 @@ export class SqliteDatabaseAdapter {
      */
     async rollbackTransaction(token) {
         this.#assertTransaction(token);
-        this.#database.exec('rollback');
-        this.#transactions.delete(token.id);
+        try {
+            this.#database.exec('rollback');
+        }
+        catch (rollbackError) {
+            try {
+                this.#discardUncertainConnection();
+            }
+            catch (recoveryError) {
+                throw new AggregateError([rollbackError, recoveryError], 'SQLite rollback and connection cleanup both failed', { cause: rollbackError });
+            }
+            throw rollbackError;
+        }
+        finally {
+            this.#transactions.delete(token.id);
+        }
     }
     /**
      * Creates a savepoint in an open sqlite transaction.
@@ -177,29 +299,90 @@ export class SqliteDatabaseAdapter {
         this.#assertTransaction(token);
         this.#database.exec('release savepoint ' + quoteIdentifier(name));
     }
+    #replaceDatabase() {
+        if (this.#config) {
+            this.#database = openSqliteDatabase(this.#config);
+            this.#databaseOpen = true;
+        }
+    }
+    #closeDatabase() {
+        if (this.#databaseOpen) {
+            this.#databaseOpen = false;
+            this.#database.close?.();
+        }
+    }
+    #discardUncertainConnection() {
+        if (this.#config) {
+            this.#closeDatabase();
+            this.#replaceDatabase();
+        }
+        else {
+            // The supplied client remains caller-owned, but this wrapper cannot safely
+            // reuse a connection whose transaction state is unknown.
+            this.#databaseOpen = false;
+        }
+    }
+    #configOrThrow(method) {
+        if (!this.#config) {
+            throw new Error('SQLite database ' + method + '() requires config-based construction');
+        }
+        return this.#config;
+    }
+    #assertNoOpenTransactions(method) {
+        if (this.#transactions.size > 0) {
+            throw new Error('SQLite database cannot ' + method + ' while transactions are open');
+        }
+    }
     #assertTransaction(token) {
+        this.#assertDatabaseOpen();
         if (!this.#transactions.has(token.id)) {
             throw new Error('Unknown transaction token: ' + token.id);
         }
     }
+    #assertDatabaseOpen() {
+        if (!this.#databaseOpen) {
+            throw new Error('SQLite database is closed');
+        }
+    }
 }
-/**
- * Creates a sqlite `DatabaseAdapter`.
- * @param database Synchronous SQLite database client.
- * @returns A configured sqlite adapter.
- * @example
- * ```ts
- * import { DatabaseSync } from 'node:sqlite'
- * import { createDatabase } from 'remix/data-table'
- * import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
- *
- * let sqlite = new DatabaseSync('./data/app.db')
- * let adapter = createSqliteDatabaseAdapter(sqlite)
- * let db = createDatabase(adapter)
- * ```
- */
-export function createSqliteDatabaseAdapter(database) {
-    return new SqliteDatabaseAdapter(database);
+const REMOVE_RETRIES = 10;
+const REMOVE_RETRY_DELAY_MS = 100;
+async function removeDatabaseFile(filename) {
+    // Windows keeps a just-closed database file locked for a short window (deferred handle
+    // release, antivirus scans), so removal is retried with a linear backoff
+    for (let attempt = 0;; attempt++) {
+        try {
+            await rm(filename, { force: true });
+            return;
+        }
+        catch (error) {
+            if (attempt >= REMOVE_RETRIES || !isRetryableRemoveError(error)) {
+                throw error;
+            }
+        }
+        await setTimeout(REMOVE_RETRY_DELAY_MS * (attempt + 1));
+    }
+}
+function isRetryableRemoveError(error) {
+    let code = error?.code;
+    return code === 'EBUSY' || code === 'EPERM' || code === 'EMFILE' || code === 'ENFILE';
+}
+function openSqliteDatabase(config) {
+    let SqliteDatabaseConstructor = loadSqliteDatabaseConstructor();
+    let database = new SqliteDatabaseConstructor(config.filename);
+    // node:sqlite enables foreign keys by default while bun:sqlite follows SQLite's default
+    // (off), so set the pragma explicitly to make the option authoritative on both runtimes
+    database.exec('pragma foreign_keys = ' + (config.foreignKeys ? 'on' : 'off'));
+    // node:sqlite defaults to busy_timeout 0, which fails immediately with SQLITE_BUSY when
+    // another process holds a write lock
+    database.exec('pragma busy_timeout = ' + String(config.busyTimeout ?? 5000));
+    return database;
+}
+function isSqliteDatabase(input) {
+    return ('prepare' in input &&
+        typeof input.prepare === 'function' &&
+        'exec' in input &&
+        typeof input.exec === 'function');
 }
 function normalizeRows(rows) {
     return rows.map((row) => {

package/dist/lib/sql-compiler.d.ts

@@ -1,3 +1,4 @@
-import type { DataManipulationOperation, SqlStatement } from '@remix-run/data-table';
+import type { SqlStatement } from '@remix-run/data-table';
+import type { DataManipulationOperation } from '@remix-run/data-table';
 export declare function compileSqliteOperation(operation: DataManipulationOperation): SqlStatement;
 //# sourceMappingURL=sql-compiler.d.ts.map

package/dist/lib/sql-compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sql-compiler.d.ts","sourceRoot":"","sources":["../../src/lib/sql-compiler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAa,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAe/F,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,yBAAyB,GAAG,YAAY,CAuGzF"}
+{"version":3,"file":"sql-compiler.d.ts","sourceRoot":"","sources":["../../src/lib/sql-compiler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAa,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AAetE,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,yBAAyB,GAAG,YAAY,CAuGzF"}

package/dist/lib/sql-compiler.js

@@ -24,8 +24,8 @@ export function compileSqliteOperation(operation) {
                 compileGroupByClause(operation.groupBy) +
                 compileHavingClause(operation.having, context) +
                 compileOrderByClause(operation.orderBy) +
-                compileLimitClause(operation.limit) +
-                compileOffsetClause(operation.offset),
+                compileLimitClause(operation.limit, context) +
+                compileOffsetClause(operation.offset, context),
             values: context.values,
         };
     }
@@ -218,17 +218,17 @@ function compileOrderByClause(orderBy) {
             .map((clause) => quotePath(clause.column) + ' ' + clause.direction.toUpperCase())
             .join(', '));
 }
-function compileLimitClause(limit) {
+function compileLimitClause(limit, context) {
     if (limit === undefined) {
         return '';
     }
-    return ' limit ' + String(limit);
+    return ' limit ' + pushValue(context, limit);
 }
-function compileOffsetClause(offset) {
+function compileOffsetClause(offset, context) {
     if (offset === undefined) {
         return '';
     }
-    return ' offset ' + String(offset);
+    return ' offset ' + pushValue(context, offset);
 }
 function compileReturningClause(returning) {
     if (!returning) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@remix-run/data-table-sqlite",
-  "version": "0.5.0",
-  "description": "SQLite adapter for remix/data-table",
+  "version": "0.6.0",
+  "description": "SQLite database implementation for remix/data-table",
   "author": "Michael Jackson <mjijackson@gmail.com>",
   "license": "MIT",
   "repository": {
@@ -28,13 +28,13 @@
   },
   "devDependencies": {
     "@types/node": "^24.6.0",
-    "@typescript/native-preview": "7.0.0-dev.20251125.1",
-    "@remix-run/assert": "0.2.0",
-    "@remix-run/test": "0.4.0",
-    "@remix-run/data-table": "0.3.0"
+    "typescript": "^7.0.2",
+    "@remix-run/test": "0.6.0",
+    "@remix-run/data-table": "0.4.0",
+    "@remix-run/assert": "0.3.0"
   },
   "dependencies": {
-    "@remix-run/data-table": "^0.3.0"
+    "@remix-run/data-table": "^0.4.0"
   },
   "keywords": [
     "remix",
@@ -44,11 +44,11 @@
     "sql"
   ],
   "scripts": {
-    "build": "tsgo -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json",
     "clean": "git clean -fdX",
-    "test": "remix-test",
-    "test:bun": "bun x --bun remix-test",
-    "test:coverage": "remix-test --coverage",
-    "typecheck": "tsgo --noEmit"
+    "test": "remix test",
+    "test:bun": "bun x --bun remix test",
+    "test:coverage": "remix test --coverage",
+    "typecheck": "tsc --noEmit"
   }
 }

package/src/index.ts

@@ -1,2 +1,7 @@
-export { createSqliteDatabaseAdapter, SqliteDatabaseAdapter } from './lib/adapter.ts'
-export type { SqliteDatabase, SqliteRunResult, SqliteStatement } from './lib/adapter.ts'
+export { createSqliteDatabase, SqliteDatabase } from './lib/database.ts'
+export type {
+  SqliteDatabaseClient,
+  SqliteDatabaseConfig,
+  SqliteRunResult,
+  SqliteStatement,
+} from './lib/driver.ts'

package/src/lib/database.ts

@@ -0,0 +1,42 @@
+import { Database, type DatabaseOptions } from '@remix-run/data-table'
+
+import {
+  SqliteDatabaseDriver,
+  type SqliteDatabaseClient,
+  type SqliteDatabaseConfig,
+} from './driver.ts'
+
+/** A {@link Database} backed by SQLite. */
+export class SqliteDatabase extends Database<'sqlite'> {
+  /**
+   * Creates a SQLite-backed database.
+   * @param input SQLite configuration or synchronous database client.
+   * @param options Database runtime options.
+   */
+  constructor(input: SqliteDatabaseClient | SqliteDatabaseConfig, options: DatabaseOptions = {}) {
+    super(new SqliteDatabaseDriver(input), options)
+  }
+}
+
+/**
+ * Creates a SQLite-backed database.
+ *
+ * @param input SQLite configuration or synchronous database client.
+ * @param options Database runtime options.
+ * @returns A SQLite database.
+ * @example
+ * ```ts
+ * import { createSqliteDatabase } from 'remix/data-table/sqlite'
+ *
+ * let db = createSqliteDatabase({
+ *   filename: './data/app.db',
+ *   foreignKeys: true,
+ * })
+ * ```
+ */
+export function createSqliteDatabase(
+  input: SqliteDatabaseClient | SqliteDatabaseConfig,
+  options: DatabaseOptions = {},
+): SqliteDatabase {
+  return new SqliteDatabase(input, options)
+}

package/src/lib/{adapter.ts → driver.ts}

@@ -1,8 +1,12 @@
+import { dirname } from 'node:path'
+import { mkdir, rm } from 'node:fs/promises'
+import { setTimeout } from 'node:timers/promises'
+
 import type {
+  DataManipulationOperation,
   DataManipulationRequest,
   DataManipulationResult,
-  DataManipulationOperation,
-  DatabaseAdapter,
+  DatabaseDriver,
   SqlStatement,
   TableRef,
   TransactionOptions,
@@ -13,18 +17,84 @@ import { getTablePrimaryKey } from '@remix-run/data-table'
 import { compileSqliteOperation } from './sql-compiler.ts'
 
 /**
- * Synchronous SQLite database client accepted by the sqlite adapter.
+ * Synchronous SQLite client accepted by `createSqliteDatabase()`.
  *
  * This matches the shared surface of Node's `node:sqlite` `DatabaseSync`, Bun's `bun:sqlite`
  * `Database`, and compatible synchronous SQLite clients.
  */
-export interface SqliteDatabase {
+export interface SqliteDatabaseClient {
   prepare(sql: string): SqliteStatement
   exec(sql: string): unknown
+  close?: () => void
+}
+
+type SqliteDatabaseConstructor = {
+  new (path: string): SqliteDatabaseClient
+}
+
+type SqliteDriverModule = {
+  Database?: SqliteDatabaseConstructor
+  DatabaseSync?: SqliteDatabaseConstructor
+}
+
+const sqliteCapabilities = Object.freeze({
+  returning: true,
+  savepoints: true,
+  upsert: true,
+  transactionalDdl: true,
+  migrationLock: false,
+})
+
+let loadedDriverConstructor: SqliteDatabaseConstructor | undefined
+
+// The runtime driver loads lazily on config-backed construction so client-backed databases
+// keep working in environments that cannot resolve node:sqlite or bun:sqlite at import time,
+// and so bundlers never try to resolve those specifiers statically.
+function loadSqliteDatabaseConstructor(): SqliteDatabaseConstructor {
+  if (!loadedDriverConstructor) {
+    if ('Bun' in globalThis) {
+      // import.meta.require is Bun's synchronous require for ES modules; Bun does not
+      // implement process.getBuiltinModule
+      let importMeta = import.meta as ImportMeta & { require?: (id: string) => unknown }
+      let driver = importMeta.require?.('bun:sqlite') as SqliteDriverModule | undefined
+      loadedDriverConstructor = driver?.Database
+    } else {
+      // process.getBuiltinModule loads node:sqlite synchronously (Node.js 22.3+)
+      let driver = globalThis.process?.getBuiltinModule?.('node:sqlite') as
+        | SqliteDriverModule
+        | undefined
+      loadedDriverConstructor = driver?.DatabaseSync
+    }
+
+    if (!loadedDriverConstructor) {
+      throw new Error(
+        'SQLite config-based construction requires node:sqlite (Node.js 22.5+) or bun:sqlite; pass a SQLite database client instead',
+      )
+    }
+  }
+
+  return loadedDriverConstructor
+}
+
+/** Configuration for a SQLite database created by `createSqliteDatabase()`. */
+export interface SqliteDatabaseConfig {
+  /** SQLite database filename or `:memory:` for an in-memory database. */
+  filename: string
+  /**
+   * Enables SQLite foreign key enforcement whenever the database opens a connection.
+   * Defaults to `false` (enforcement off) on every runtime, including Node.js where
+   * `node:sqlite` would otherwise enable it by default.
+   */
+  foreignKeys?: boolean
+  /**
+   * SQLite `busy_timeout` in milliseconds, applied whenever the database opens a connection.
+   * Defaults to `5000`. Set `0` to fail immediately when another process holds a write lock.
+   */
+  busyTimeout?: number
 }
 
 /**
- * Prepared statement shape used by {@link SqliteDatabase}.
+ * Prepared statement shape used by {@link SqliteDatabaseClient}.
  */
 export interface SqliteStatement {
   all(...values: unknown[]): unknown[]
@@ -44,31 +114,35 @@ export interface SqliteRunResult {
 }
 
 /**
- * `DatabaseAdapter` implementation for synchronous SQLite clients.
+ * SQLite database driver backed by a synchronous SQLite client.
  */
-export class SqliteDatabaseAdapter implements DatabaseAdapter {
+export class SqliteDatabaseDriver implements DatabaseDriver<'sqlite'> {
   /**
-   * The SQL dialect identifier reported by this adapter.
+   * The SQL dialect identifier reported by this database.
    */
-  dialect = 'sqlite'
+  get dialect(): 'sqlite' {
+    return 'sqlite'
+  }
 
   /**
-   * Feature flags describing the sqlite behaviors supported by this adapter.
+   * Feature flags describing the SQLite behaviors supported by this database.
    */
-  capabilities
+  get capabilities() {
+    return sqliteCapabilities
+  }
 
-  #database: SqliteDatabase
+  #config?: SqliteDatabaseConfig
+  #database: SqliteDatabaseClient
+  #databaseOpen = true
   #transactions = new Set<string>()
   #transactionCounter = 0
 
-  constructor(database: SqliteDatabase) {
-    this.#database = database
-    this.capabilities = {
-      returning: true,
-      savepoints: true,
-      upsert: true,
-      transactionalDdl: true,
-      migrationLock: false,
+  constructor(input: SqliteDatabaseClient | SqliteDatabaseConfig) {
+    if (isSqliteDatabase(input)) {
+      this.#database = input
+    } else {
+      this.#config = input
+      this.#database = openSqliteDatabase(input)
     }
   }
 
@@ -88,6 +162,8 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
    * @returns Execution result.
    */
   async execute(request: DataManipulationRequest): Promise<DataManipulationResult> {
+    this.#assertDatabaseOpen()
+
     if (request.operation.kind === 'insertMany' && request.operation.values.length === 0) {
       return {
         affectedRows: 0,
@@ -96,6 +172,10 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
       }
     }
 
+    if (request.transaction) {
+      this.#assertTransaction(request.transaction)
+    }
+
     let statement = this.compileSql(request.operation)[0]
     let prepared = this.#database.prepare(statement.text)
     let values = normalizeStatementValues(statement.values)
@@ -129,6 +209,8 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
    * @returns A promise that resolves once execution completes.
    */
   async executeScript(sql: string, transaction?: TransactionToken): Promise<void> {
+    this.#assertDatabaseOpen()
+
     if (transaction) {
       this.#assertTransaction(transaction)
     }
@@ -143,6 +225,8 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
    * @returns `true` when the table exists.
    */
   async hasTable(table: TableRef, transaction?: TransactionToken): Promise<boolean> {
+    this.#assertDatabaseOpen()
+
     if (transaction) {
       this.#assertTransaction(transaction)
     }
@@ -153,8 +237,9 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
     let statement = this.#database.prepare(
       'select 1 from ' + masterTable + ' where type = ? and name = ? limit 1',
     )
+    // node:sqlite returns `undefined` for a missing row while bun:sqlite returns `null`
     let row = statement.get('table', table.name)
-    return row !== undefined
+    return row != null
   }
 
   /**
@@ -169,6 +254,8 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
     column: string,
     transaction?: TransactionToken,
   ): Promise<boolean> {
+    this.#assertDatabaseOpen()
+
     if (transaction) {
       this.#assertTransaction(transaction)
     }
@@ -182,12 +269,56 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
     return rows.some((row) => row.name === column)
   }
 
+  /**
+   * Destructively recreates the configured SQLite database.
+   * @returns A promise that resolves when the database is ready for use.
+   */
+  async wipe(): Promise<void> {
+    let config = this.#configOrThrow('wipe')
+    this.#assertNoOpenTransactions('wipe')
+    this.#closeDatabase()
+
+    if (config.filename === ':memory:') {
+      this.#replaceDatabase()
+      return
+    }
+
+    try {
+      await mkdir(dirname(config.filename), { recursive: true })
+      await removeDatabaseFile(config.filename)
+      // SQLite associates a database file with -wal/-shm/-journal sidecars by path, so
+      // stale sidecars left next to a freshly created database are a corruption vector
+      await removeDatabaseFile(config.filename + '-wal')
+      await removeDatabaseFile(config.filename + '-shm')
+      await removeDatabaseFile(config.filename + '-journal')
+    } finally {
+      this.#replaceDatabase()
+    }
+  }
+
+  /**
+   * Closes a database connection created from configuration.
+   *
+   * Config-backed databases keep an open handle that locks the database file on
+   * Windows until it is closed, so callers that need to move or delete the file
+   * should close the database first. Supplied clients remain caller-owned. Safe
+   * to call more than once.
+   */
+  close(): void {
+    this.#assertNoOpenTransactions('close')
+    if (this.#config) {
+      this.#closeDatabase()
+    }
+  }
+
   /**
    * Starts a sqlite transaction.
    * @param options Transaction options.
    * @returns Transaction token.
    */
   async beginTransaction(options?: TransactionOptions): Promise<TransactionToken> {
+    this.#assertDatabaseOpen()
+
     if (options?.isolationLevel === 'read uncommitted') {
       this.#database.exec('pragma read_uncommitted = true')
     }
@@ -208,8 +339,26 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
    */
   async commitTransaction(token: TransactionToken): Promise<void> {
     this.#assertTransaction(token)
-    this.#database.exec('commit')
-    this.#transactions.delete(token.id)
+    try {
+      this.#database.exec('commit')
+    } catch (commitError) {
+      try {
+        this.#database.exec('rollback')
+      } catch (rollbackError) {
+        let failures: unknown[] = [commitError, rollbackError]
+        try {
+          this.#discardUncertainConnection()
+        } catch (recoveryError) {
+          failures.push(recoveryError)
+        }
+        throw new AggregateError(failures, 'SQLite commit and rollback both failed', {
+          cause: commitError,
+        })
+      }
+      throw commitError
+    } finally {
+      this.#transactions.delete(token.id)
+    }
   }
 
   /**
@@ -219,8 +368,22 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
    */
   async rollbackTransaction(token: TransactionToken): Promise<void> {
     this.#assertTransaction(token)
-    this.#database.exec('rollback')
-    this.#transactions.delete(token.id)
+    try {
+      this.#database.exec('rollback')
+    } catch (rollbackError) {
+      try {
+        this.#discardUncertainConnection()
+      } catch (recoveryError) {
+        throw new AggregateError(
+          [rollbackError, recoveryError],
+          'SQLite rollback and connection cleanup both failed',
+          { cause: rollbackError },
+        )
+      }
+      throw rollbackError
+    } finally {
+      this.#transactions.delete(token.id)
+    }
   }
 
   /**
@@ -256,30 +419,107 @@ export class SqliteDatabaseAdapter implements DatabaseAdapter {
     this.#database.exec('release savepoint ' + quoteIdentifier(name))
   }
 
+  #replaceDatabase(): void {
+    if (this.#config) {
+      this.#database = openSqliteDatabase(this.#config)
+      this.#databaseOpen = true
+    }
+  }
+
+  #closeDatabase(): void {
+    if (this.#databaseOpen) {
+      this.#databaseOpen = false
+      this.#database.close?.()
+    }
+  }
+
+  #discardUncertainConnection(): void {
+    if (this.#config) {
+      this.#closeDatabase()
+      this.#replaceDatabase()
+    } else {
+      // The supplied client remains caller-owned, but this wrapper cannot safely
+      // reuse a connection whose transaction state is unknown.
+      this.#databaseOpen = false
+    }
+  }
+
+  #configOrThrow(method: string): SqliteDatabaseConfig {
+    if (!this.#config) {
+      throw new Error('SQLite database ' + method + '() requires config-based construction')
+    }
+
+    return this.#config
+  }
+
+  #assertNoOpenTransactions(method: string): void {
+    if (this.#transactions.size > 0) {
+      throw new Error('SQLite database cannot ' + method + ' while transactions are open')
+    }
+  }
+
   #assertTransaction(token: TransactionToken): void {
+    this.#assertDatabaseOpen()
     if (!this.#transactions.has(token.id)) {
       throw new Error('Unknown transaction token: ' + token.id)
     }
   }
+
+  #assertDatabaseOpen(): void {
+    if (!this.#databaseOpen) {
+      throw new Error('SQLite database is closed')
+    }
+  }
 }
 
-/**
- * Creates a sqlite `DatabaseAdapter`.
- * @param database Synchronous SQLite database client.
- * @returns A configured sqlite adapter.
- * @example
- * ```ts
- * import { DatabaseSync } from 'node:sqlite'
- * import { createDatabase } from 'remix/data-table'
- * import { createSqliteDatabaseAdapter } from 'remix/data-table/sqlite'
- *
- * let sqlite = new DatabaseSync('./data/app.db')
- * let adapter = createSqliteDatabaseAdapter(sqlite)
- * let db = createDatabase(adapter)
- * ```
- */
-export function createSqliteDatabaseAdapter(database: SqliteDatabase): SqliteDatabaseAdapter {
-  return new SqliteDatabaseAdapter(database)
+const REMOVE_RETRIES = 10
+const REMOVE_RETRY_DELAY_MS = 100
+
+async function removeDatabaseFile(filename: string): Promise<void> {
+  // Windows keeps a just-closed database file locked for a short window (deferred handle
+  // release, antivirus scans), so removal is retried with a linear backoff
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await rm(filename, { force: true })
+      return
+    } catch (error) {
+      if (attempt >= REMOVE_RETRIES || !isRetryableRemoveError(error)) {
+        throw error
+      }
+    }
+
+    await setTimeout(REMOVE_RETRY_DELAY_MS * (attempt + 1))
+  }
+}
+
+function isRetryableRemoveError(error: unknown): boolean {
+  let code = (error as NodeJS.ErrnoException | null)?.code
+  return code === 'EBUSY' || code === 'EPERM' || code === 'EMFILE' || code === 'ENFILE'
+}
+
+function openSqliteDatabase(config: SqliteDatabaseConfig): SqliteDatabaseClient {
+  let SqliteDatabaseConstructor = loadSqliteDatabaseConstructor()
+  let database = new SqliteDatabaseConstructor(config.filename)
+
+  // node:sqlite enables foreign keys by default while bun:sqlite follows SQLite's default
+  // (off), so set the pragma explicitly to make the option authoritative on both runtimes
+  database.exec('pragma foreign_keys = ' + (config.foreignKeys ? 'on' : 'off'))
+  // node:sqlite defaults to busy_timeout 0, which fails immediately with SQLITE_BUSY when
+  // another process holds a write lock
+  database.exec('pragma busy_timeout = ' + String(config.busyTimeout ?? 5000))
+
+  return database
+}
+
+function isSqliteDatabase(
+  input: SqliteDatabaseClient | SqliteDatabaseConfig,
+): input is SqliteDatabaseClient {
+  return (
+    'prepare' in input &&
+    typeof input.prepare === 'function' &&
+    'exec' in input &&
+    typeof input.exec === 'function'
+  )
 }
 
 function normalizeRows(rows: unknown[]): Record<string, unknown>[] {

package/src/lib/sql-compiler.ts

@@ -1,5 +1,6 @@
 import { getTableName, getTablePrimaryKey } from '@remix-run/data-table'
-import type { DataManipulationOperation, Predicate, SqlStatement } from '@remix-run/data-table'
+import type { Predicate, SqlStatement } from '@remix-run/data-table'
+import type { DataManipulationOperation } from '@remix-run/data-table'
 import {
   collectColumns as collectColumnsHelper,
   normalizeJoinType as normalizeJoinTypeHelper,
@@ -43,8 +44,8 @@ export function compileSqliteOperation(operation: DataManipulationOperation): Sq
         compileGroupByClause(operation.groupBy) +
         compileHavingClause(operation.having, context) +
         compileOrderByClause(operation.orderBy) +
-        compileLimitClause(operation.limit) +
-        compileOffsetClause(operation.offset),
+        compileLimitClause(operation.limit, context) +
+        compileOffsetClause(operation.offset, context),
       values: context.values,
     }
   }
@@ -309,20 +310,20 @@ function compileOrderByClause(orderBy: { column: string; direction: 'asc' | 'des
   )
 }
 
-function compileLimitClause(limit: number | undefined): string {
+function compileLimitClause(limit: number | undefined, context: CompileContext): string {
   if (limit === undefined) {
     return ''
   }
 
-  return ' limit ' + String(limit)
+  return ' limit ' + pushValue(context, limit)
 }
 
-function compileOffsetClause(offset: number | undefined): string {
+function compileOffsetClause(offset: number | undefined, context: CompileContext): string {
   if (offset === undefined) {
     return ''
   }
 
-  return ' offset ' + String(offset)
+  return ' offset ' + pushValue(context, offset)
 }
 
 function compileReturningClause(returning: '*' | string[] | undefined): string {

package/dist/lib/adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/lib/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,eAAe,EACf,YAAY,EACZ,QAAQ,EACR,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,uBAAuB,CAAA;AAK9B;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAA;IACrC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAA;IACpC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAA;IAClC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,eAAe,CAAA;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,OAAO,EAAE,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,eAAe,EAAE,OAAO,CAAA;CACzB;AAED;;GAEG;AACH,qBAAa,qBAAsB,YAAW,eAAe;;IAC3D;;OAEG;IACH,OAAO,SAAW;IAElB;;OAEG;IACH,YAAY;;;;;;MAAA;IAMZ,YAAY,QAAQ,EAAE,cAAc,EASnC;IAED;;;;OAIG;IACH,UAAU,CAAC,SAAS,EAAE,yBAAyB,GAAG,YAAY,EAAE,CAG/D;IAED;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAiC/E;IAED;;;;;OAKG;IACG,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAM9E;IAED;;;;;OAKG;IACG,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAahF;IAED;;;;;;OAMG;IACG,SAAS,CACb,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,gBAAgB,GAC7B,OAAO,CAAC,OAAO,CAAC,CAYlB;IAED;;;;OAIG;IACG,gBAAgB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAY9E;IAED;;;;OAIG;IACG,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAI9D;IAED;;;;OAIG;IACG,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhE;IAED;;;;;OAKG;IACG,eAAe,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1E;IAED;;;;;OAKG;IACG,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9E;IAED;;;;;OAKG;IACG,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG3E;CAOF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,cAAc,GAAG,qBAAqB,CAE3F"}