@remix-run/data-table-sqlite 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shopify Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,76 @@
-# Placeholder package
+# data-table-sqlite
 
-This package is intentionally empty and published only as a temporary placeholder.
+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 `better-sqlite3`.
+
+## Features
+
+- **Native `better-sqlite3` Integration**: Works well for local and embedded deployments
+- **Full `data-table` API Support**: Queries, relations, writes, and transactions
+- **SQLite Capabilities Enabled By Default**:
+  - `returning: true`
+  - `savepoints: true`
+  - `upsert: true`
+
+## Installation
+
+```sh
+npm i remix better-sqlite3
+```
+
+## Usage
+
+```ts
+import Database from 'better-sqlite3'
+import { createDatabase } from 'remix/data-table'
+import { createSqliteDatabaseAdapter } from 'remix/data-table-sqlite'
+
+let sqlite = new Database('app.db')
+let db = createDatabase(createSqliteDatabaseAdapter(sqlite))
+```
+
+This is a good fit for local development, embedded deployments, and single-node services.
+
+## Adapter Capabilities
+
+`data-table-sqlite` reports this capability set by default:
+
+- `returning: true`
+- `savepoints: true`
+- `upsert: true`
+
+## Advanced Usage
+
+### In-Memory Database For Tests
+
+```ts
+import Database from 'better-sqlite3'
+import { createDatabase } from 'remix/data-table'
+import { createSqliteDatabaseAdapter } from 'remix/data-table-sqlite'
+
+let sqlite = new Database(':memory:')
+let db = createDatabase(createSqliteDatabaseAdapter(sqlite))
+```
+
+### Capability Overrides For Fallback Testing
+
+```ts
+import { createSqliteDatabaseAdapter } from 'remix/data-table-sqlite'
+
+let adapter = createSqliteDatabaseAdapter(sqlite, {
+  capabilities: {
+    returning: false,
+  },
+})
+```
+
+## 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 definitions 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
+
+## License
+
+See [LICENSE](https://github.com/remix-run/remix/blob/main/LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { SqliteDatabaseAdapterOptions, SqliteDatabaseConnection } from './lib/adapter.ts';
+export { createSqliteDatabaseAdapter, SqliteDatabaseAdapter } from './lib/adapter.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,4BAA4B,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA;AAC9F,OAAO,EAAE,2BAA2B,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -0,0 +1 @@
+export { createSqliteDatabaseAdapter, SqliteDatabaseAdapter } from "./lib/adapter.js";

package/dist/lib/adapter.d.ts

@@ -0,0 +1,40 @@
+import type { AdapterCapabilityOverrides, AdapterExecuteRequest, AdapterResult, DatabaseAdapter, TransactionOptions, TransactionToken } from '@remix-run/data-table';
+import type { Database as BetterSqliteDatabase } from 'better-sqlite3';
+/**
+ * Better SQLite3 database handle accepted by the sqlite adapter.
+ */
+export type SqliteDatabaseConnection = BetterSqliteDatabase;
+/**
+ * Sqlite adapter configuration.
+ */
+export type SqliteDatabaseAdapterOptions = {
+    capabilities?: AdapterCapabilityOverrides;
+};
+/**
+ * `DatabaseAdapter` implementation for Better SQLite3.
+ */
+export declare class SqliteDatabaseAdapter implements DatabaseAdapter {
+    #private;
+    dialect: string;
+    capabilities: {
+        returning: boolean;
+        savepoints: boolean;
+        upsert: boolean;
+    };
+    constructor(database: SqliteDatabaseConnection, options?: SqliteDatabaseAdapterOptions);
+    execute(request: AdapterExecuteRequest): Promise<AdapterResult>;
+    beginTransaction(options?: TransactionOptions): Promise<TransactionToken>;
+    commitTransaction(token: TransactionToken): Promise<void>;
+    rollbackTransaction(token: TransactionToken): Promise<void>;
+    createSavepoint(token: TransactionToken, name: string): Promise<void>;
+    rollbackToSavepoint(token: TransactionToken, name: string): Promise<void>;
+    releaseSavepoint(token: TransactionToken, name: string): Promise<void>;
+}
+/**
+ * Creates a sqlite `DatabaseAdapter`.
+ * @param database Better SQLite3 database instance.
+ * @param options Optional adapter capability overrides.
+ * @returns A configured sqlite adapter.
+ */
+export declare function createSqliteDatabaseAdapter(database: SqliteDatabaseConnection, options?: SqliteDatabaseAdapterOptions): SqliteDatabaseAdapter;
+//# sourceMappingURL=adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/lib/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,qBAAqB,EACrB,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,uBAAuB,CAAA;AAE9B,OAAO,KAAK,EAAE,QAAQ,IAAI,oBAAoB,EAAa,MAAM,gBAAgB,CAAA;AAIjF;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,oBAAoB,CAAA;AAE3D;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,YAAY,CAAC,EAAE,0BAA0B,CAAA;CAC1C,CAAA;AAED;;GAEG;AACH,qBAAa,qBAAsB,YAAW,eAAe;;IAC3D,OAAO,SAAW;IAClB,YAAY;;;;MAAA;IAMZ,YAAY,QAAQ,EAAE,wBAAwB,EAAE,OAAO,CAAC,EAAE,4BAA4B,EAOrF;IAEK,OAAO,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,aAAa,CAAC,CAgCpE;IAEK,gBAAgB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAY9E;IAEK,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAI9D;IAEK,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhE;IAEK,eAAe,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1E;IAEK,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9E;IAEK,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG3E;CAOF;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,wBAAwB,EAClC,OAAO,CAAC,EAAE,4BAA4B,GACrC,qBAAqB,CAEvB"}

package/dist/lib/adapter.js

@@ -0,0 +1,171 @@
+import { getTablePrimaryKey } from '@remix-run/data-table';
+import { compileSqliteStatement } from "./sql-compiler.js";
+/**
+ * `DatabaseAdapter` implementation for Better SQLite3.
+ */
+export class SqliteDatabaseAdapter {
+    dialect = 'sqlite';
+    capabilities;
+    #database;
+    #transactions = new Set();
+    #transactionCounter = 0;
+    constructor(database, options) {
+        this.#database = database;
+        this.capabilities = {
+            returning: options?.capabilities?.returning ?? true,
+            savepoints: options?.capabilities?.savepoints ?? true,
+            upsert: options?.capabilities?.upsert ?? true,
+        };
+    }
+    async execute(request) {
+        if (request.statement.kind === 'insertMany' && request.statement.values.length === 0) {
+            return {
+                affectedRows: 0,
+                insertId: undefined,
+                rows: request.statement.returning ? [] : undefined,
+            };
+        }
+        let statement = compileSqliteStatement(request.statement);
+        let prepared = this.#database.prepare(statement.text);
+        if (prepared.reader) {
+            let rows = normalizeRows(prepared.all(...statement.values));
+            if (request.statement.kind === 'count' || request.statement.kind === 'exists') {
+                rows = normalizeCountRows(rows);
+            }
+            return {
+                rows,
+                affectedRows: normalizeAffectedRowsForReader(request.statement.kind, rows),
+                insertId: normalizeInsertIdForReader(request.statement.kind, request.statement, rows),
+            };
+        }
+        let result = prepared.run(...statement.values);
+        return {
+            affectedRows: normalizeAffectedRowsForRun(request.statement.kind, result),
+            insertId: normalizeInsertIdForRun(request.statement.kind, request.statement, result),
+        };
+    }
+    async beginTransaction(options) {
+        if (options?.isolationLevel === 'read uncommitted') {
+            this.#database.pragma('read_uncommitted = true');
+        }
+        this.#database.exec('begin');
+        this.#transactionCounter += 1;
+        let token = { id: 'tx_' + String(this.#transactionCounter) };
+        this.#transactions.add(token.id);
+        return token;
+    }
+    async commitTransaction(token) {
+        this.#assertTransaction(token);
+        this.#database.exec('commit');
+        this.#transactions.delete(token.id);
+    }
+    async rollbackTransaction(token) {
+        this.#assertTransaction(token);
+        this.#database.exec('rollback');
+        this.#transactions.delete(token.id);
+    }
+    async createSavepoint(token, name) {
+        this.#assertTransaction(token);
+        this.#database.exec('savepoint ' + quoteIdentifier(name));
+    }
+    async rollbackToSavepoint(token, name) {
+        this.#assertTransaction(token);
+        this.#database.exec('rollback to savepoint ' + quoteIdentifier(name));
+    }
+    async releaseSavepoint(token, name) {
+        this.#assertTransaction(token);
+        this.#database.exec('release savepoint ' + quoteIdentifier(name));
+    }
+    #assertTransaction(token) {
+        if (!this.#transactions.has(token.id)) {
+            throw new Error('Unknown transaction token: ' + token.id);
+        }
+    }
+}
+/**
+ * Creates a sqlite `DatabaseAdapter`.
+ * @param database Better SQLite3 database instance.
+ * @param options Optional adapter capability overrides.
+ * @returns A configured sqlite adapter.
+ */
+export function createSqliteDatabaseAdapter(database, options) {
+    return new SqliteDatabaseAdapter(database, options);
+}
+function normalizeRows(rows) {
+    return rows.map((row) => {
+        if (typeof row !== 'object' || row === null) {
+            return {};
+        }
+        return { ...row };
+    });
+}
+function normalizeCountRows(rows) {
+    return rows.map((row) => {
+        let count = row.count;
+        if (typeof count === 'string') {
+            let numeric = Number(count);
+            if (!Number.isNaN(numeric)) {
+                return {
+                    ...row,
+                    count: numeric,
+                };
+            }
+        }
+        if (typeof count === 'bigint') {
+            return {
+                ...row,
+                count: Number(count),
+            };
+        }
+        return row;
+    });
+}
+function normalizeAffectedRowsForReader(kind, rows) {
+    if (isWriteStatementKind(kind)) {
+        return rows.length;
+    }
+    return undefined;
+}
+function normalizeInsertIdForReader(kind, statement, rows) {
+    if (!isInsertStatementKind(kind) || !isInsertStatement(statement)) {
+        return undefined;
+    }
+    let primaryKey = getTablePrimaryKey(statement.table);
+    if (primaryKey.length !== 1) {
+        return undefined;
+    }
+    let key = primaryKey[0];
+    let row = rows[rows.length - 1];
+    return row ? row[key] : undefined;
+}
+function normalizeAffectedRowsForRun(kind, result) {
+    if (kind === 'select' || kind === 'count' || kind === 'exists') {
+        return undefined;
+    }
+    return result.changes;
+}
+function normalizeInsertIdForRun(kind, statement, result) {
+    if (!isInsertStatementKind(kind) || !isInsertStatement(statement)) {
+        return undefined;
+    }
+    if (getTablePrimaryKey(statement.table).length !== 1) {
+        return undefined;
+    }
+    return result.lastInsertRowid;
+}
+function quoteIdentifier(value) {
+    return '"' + value.replace(/"/g, '""') + '"';
+}
+function isWriteStatementKind(kind) {
+    return (kind === 'insert' ||
+        kind === 'insertMany' ||
+        kind === 'update' ||
+        kind === 'delete' ||
+        kind === 'upsert');
+}
+function isInsertStatementKind(kind) {
+    return kind === 'insert' || kind === 'insertMany' || kind === 'upsert';
+}
+function isInsertStatement(statement) {
+    return (statement.kind === 'insert' || statement.kind === 'insertMany' || statement.kind === 'upsert');
+}

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

@@ -0,0 +1,8 @@
+import type { AdapterStatement } from '@remix-run/data-table';
+type CompiledSql = {
+    text: string;
+    values: unknown[];
+};
+export declare function compileSqliteStatement(statement: AdapterStatement): CompiledSql;
+export {};
+//# sourceMappingURL=sql-compiler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sql-compiler.d.ts","sourceRoot":"","sources":["../../src/lib/sql-compiler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAa,MAAM,uBAAuB,CAAA;AAMxE,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA;AAMD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,gBAAgB,GAAG,WAAW,CAuG/E"}