@tursodatabase/database 0.1.4-pre.5

package/README.md

@@ -0,0 +1,82 @@
+# @tursodatabase/database
+
+The next evolution of SQLite: A high-performance, SQLite-compatible database library for Node.js
+
+## Features
+
+- **SQLite Compatible**: Drop-in replacement for better-sqlite3 with familiar API
+- **High Performance**: Built with Rust for maximum speed and efficiency
+- **In-Process**: No network overhead, runs directly in your Node.js process
+- **TypeScript Support**: Full TypeScript definitions included
+- **Cross-Platform**: Supports Linux, macOS, Windows and browsers (through WebAssembly)
+- **Transaction Support**: Full ACID transactions with rollback support
+- **Prepared Statements**: Optimized query execution with parameter binding
+
+## Installation
+
+```bash
+npm install @tursodatabase/database
+```
+
+## Quick Start
+
+### In-Memory Database
+
+```javascript
+import Database from '@tursodatabase/database';
+
+// Create an in-memory database
+const db = new Database(':memory:');
+
+// Create a table
+db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');
+
+// Insert data
+const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+insert.run('Alice', 'alice@example.com');
+insert.run('Bob', 'bob@example.com');
+
+// Query data
+const users = db.prepare('SELECT * FROM users').all();
+console.log(users);
+// Output: [
+//   { id: 1, name: 'Alice', email: 'alice@example.com' },
+//   { id: 2, name: 'Bob', email: 'bob@example.com' }
+// ]
+```
+
+### File-Based Database
+
+```javascript
+import Database from '@tursodatabase/database';
+
+// Create or open a database file
+const db = new Database('my-database.db');
+
+// Create a table
+db.exec(`
+  CREATE TABLE IF NOT EXISTS posts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    title TEXT NOT NULL,
+    content TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  )
+`);
+
+// Insert a post
+const insertPost = db.prepare('INSERT INTO posts (title, content) VALUES (?, ?)');
+const result = insertPost.run('Hello World', 'This is my first blog post!');
+
+console.log(`Inserted post with ID: ${result.lastInsertRowid}`);
+```
+
+## API Reference
+## License
+
+MIT
+
+## Support
+
+- [GitHub Issues](https://github.com/tursodatabase/turso/issues)
+- [Documentation](https://docs.turso.tech)
+- [Discord Community](https://discord.gg/turso)

package/browser.js

@@ -0,0 +1 @@
+export * from '@tursodatabase/database-wasm32-wasi'

package/dist/bind.js

@@ -0,0 +1,64 @@
+// Bind parameters to a statement.
+//
+// This function is used to bind parameters to a statement. It supports both
+// named and positional parameters, and nested arrays.
+//
+// The `stmt` parameter is a statement object.
+// The `params` parameter is an array of parameters.
+//
+// The function returns void.
+export function bindParams(stmt, params) {
+    const len = params?.length;
+    if (len === 0) {
+        return;
+    }
+    if (len === 1) {
+        const param = params[0];
+        if (isPlainObject(param)) {
+            bindNamedParams(stmt, param);
+            return;
+        }
+        bindValue(stmt, 1, param);
+        return;
+    }
+    bindPositionalParams(stmt, params);
+}
+// Check if object is plain (no prototype chain)
+function isPlainObject(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const proto = Object.getPrototypeOf(obj);
+    return proto === Object.prototype || proto === null;
+}
+// Handle named parameters
+function bindNamedParams(stmt, paramObj) {
+    const paramCount = stmt.parameterCount();
+    for (let i = 1; i <= paramCount; i++) {
+        const paramName = stmt.parameterName(i);
+        if (paramName) {
+            const key = paramName.substring(1); // Remove ':' or '$' prefix
+            const value = paramObj[key];
+            if (value !== undefined) {
+                bindValue(stmt, i, value);
+            }
+        }
+    }
+}
+// Handle positional parameters (including nested arrays)
+function bindPositionalParams(stmt, params) {
+    let bindIndex = 1;
+    for (let i = 0; i < params.length; i++) {
+        const param = params[i];
+        if (Array.isArray(param)) {
+            for (let j = 0; j < param.length; j++) {
+                bindValue(stmt, bindIndex++, param[j]);
+            }
+        }
+        else {
+            bindValue(stmt, bindIndex++, param);
+        }
+    }
+}
+function bindValue(stmt, index, value) {
+    stmt.bindAt(index, value);
+}

package/dist/promise.js

@@ -0,0 +1,352 @@
+import { Database as NativeDB } from "#entry-point";
+import { bindParams } from "./bind.js";
+import { SqliteError } from "./sqlite-error.js";
+// Step result constants
+const STEP_ROW = 1;
+const STEP_DONE = 2;
+const STEP_IO = 3;
+const convertibleErrorTypes = { TypeError };
+const CONVERTIBLE_ERROR_PREFIX = "[TURSO_CONVERT_TYPE]";
+function convertError(err) {
+    if ((err.code ?? "").startsWith(CONVERTIBLE_ERROR_PREFIX)) {
+        return createErrorByName(err.code.substring(CONVERTIBLE_ERROR_PREFIX.length), err.message);
+    }
+    return new SqliteError(err.message, err.code, err.rawCode);
+}
+function createErrorByName(name, message) {
+    const ErrorConstructor = convertibleErrorTypes[name];
+    if (!ErrorConstructor) {
+        throw new Error(`unknown error type ${name} from Turso`);
+    }
+    return new ErrorConstructor(message);
+}
+/**
+ * Database represents a connection that can prepare and execute SQL statements.
+ */
+class Database {
+    db;
+    memory;
+    open;
+    /**
+     * Creates a new database connection. If the database file pointed to by `path` does not exists, it will be created.
+     *
+     * @constructor
+     * @param {string} path - Path to the database file.
+     * @param {Object} opts - Options for database behavior.
+     * @param {boolean} [opts.readonly=false] - Open the database in read-only mode.
+     * @param {boolean} [opts.fileMustExist=false] - If true, throws if database file does not exist.
+     * @param {number} [opts.timeout=0] - Timeout duration in milliseconds for database operations. Defaults to 0 (no timeout).
+     */
+    constructor(path, opts = {}) {
+        opts.readonly = opts.readonly === undefined ? false : opts.readonly;
+        opts.fileMustExist =
+            opts.fileMustExist === undefined ? false : opts.fileMustExist;
+        opts.timeout = opts.timeout === undefined ? 0 : opts.timeout;
+        const db = new NativeDB(path);
+        this.initialize(db, opts.path, opts.readonly);
+    }
+    static create() {
+        return Object.create(this.prototype);
+    }
+    initialize(db, name, readonly) {
+        this.db = db;
+        this.memory = db.memory;
+        Object.defineProperties(this, {
+            inTransaction: {
+                get() {
+                    throw new Error("not implemented");
+                },
+            },
+            name: {
+                get() {
+                    return name;
+                },
+            },
+            readonly: {
+                get() {
+                    return readonly;
+                },
+            },
+            open: {
+                get() {
+                    return this.db.open;
+                },
+            },
+        });
+    }
+    /**
+     * Prepares a SQL statement for execution.
+     *
+     * @param {string} sql - The SQL statement string to prepare.
+     */
+    prepare(sql) {
+        if (!this.open) {
+            throw new TypeError("The database connection is not open");
+        }
+        if (!sql) {
+            throw new RangeError("The supplied SQL string contains no statements");
+        }
+        try {
+            return new Statement(this.db.prepare(sql), this);
+        }
+        catch (err) {
+            throw convertError(err);
+        }
+    }
+    /**
+     * Returns a function that executes the given function in a transaction.
+     *
+     * @param {function} fn - The function to wrap in a transaction.
+     */
+    transaction(fn) {
+        if (typeof fn !== "function")
+            throw new TypeError("Expected first argument to be a function");
+        const db = this;
+        const wrapTxn = (mode) => {
+            return (...bindParameters) => {
+                db.exec("BEGIN " + mode);
+                try {
+                    const result = fn(...bindParameters);
+                    db.exec("COMMIT");
+                    return result;
+                }
+                catch (err) {
+                    db.exec("ROLLBACK");
+                    throw err;
+                }
+            };
+        };
+        const properties = {
+            default: { value: wrapTxn("") },
+            deferred: { value: wrapTxn("DEFERRED") },
+            immediate: { value: wrapTxn("IMMEDIATE") },
+            exclusive: { value: wrapTxn("EXCLUSIVE") },
+            database: { value: this, enumerable: true },
+        };
+        Object.defineProperties(properties.default.value, properties);
+        Object.defineProperties(properties.deferred.value, properties);
+        Object.defineProperties(properties.immediate.value, properties);
+        Object.defineProperties(properties.exclusive.value, properties);
+        return properties.default.value;
+    }
+    pragma(source, options) {
+        if (options == null)
+            options = {};
+        if (typeof source !== "string")
+            throw new TypeError("Expected first argument to be a string");
+        if (typeof options !== "object")
+            throw new TypeError("Expected second argument to be an options object");
+        const pragma = `PRAGMA ${source}`;
+        const stmt = this.prepare(pragma);
+        const results = stmt.all();
+        return results;
+    }
+    backup(filename, options) {
+        throw new Error("not implemented");
+    }
+    serialize(options) {
+        throw new Error("not implemented");
+    }
+    function(name, options, fn) {
+        throw new Error("not implemented");
+    }
+    aggregate(name, options) {
+        throw new Error("not implemented");
+    }
+    table(name, factory) {
+        throw new Error("not implemented");
+    }
+    loadExtension(path) {
+        throw new Error("not implemented");
+    }
+    maxWriteReplicationIndex() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Executes a SQL statement.
+     *
+     * @param {string} sql - The SQL statement string to execute.
+     */
+    exec(sql) {
+        if (!this.open) {
+            throw new TypeError("The database connection is not open");
+        }
+        try {
+            this.db.batch(sql);
+        }
+        catch (err) {
+            throw convertError(err);
+        }
+    }
+    /**
+     * Interrupts the database connection.
+     */
+    interrupt() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Closes the database connection.
+     */
+    close() {
+        this.db.close();
+    }
+}
+/**
+ * Statement represents a prepared SQL statement that can be executed.
+ */
+class Statement {
+    stmt;
+    db;
+    constructor(stmt, database) {
+        this.stmt = stmt;
+        this.db = database;
+    }
+    /**
+     * Toggle raw mode.
+     *
+     * @param raw Enable or disable raw mode. If you don't pass the parameter, raw mode is enabled.
+     */
+    raw(raw) {
+        this.stmt.raw(raw);
+        return this;
+    }
+    /**
+     * Toggle pluck mode.
+     *
+     * @param pluckMode Enable or disable pluck mode. If you don't pass the parameter, pluck mode is enabled.
+     */
+    pluck(pluckMode) {
+        this.stmt.pluck(pluckMode);
+        return this;
+    }
+    get source() {
+        throw new Error("not implemented");
+    }
+    get reader() {
+        throw new Error("not implemented");
+    }
+    get database() {
+        return this.db;
+    }
+    /**
+     * Executes the SQL statement and returns an info object.
+     */
+    async run(...bindParameters) {
+        const totalChangesBefore = this.db.db.totalChanges();
+        this.stmt.reset();
+        bindParams(this.stmt, bindParameters);
+        while (true) {
+            const stepResult = this.stmt.step();
+            if (stepResult === STEP_IO) {
+                await this.db.db.ioLoopAsync();
+                continue;
+            }
+            if (stepResult === STEP_DONE) {
+                break;
+            }
+            if (stepResult === STEP_ROW) {
+                // For run(), we don't need the row data, just continue
+                continue;
+            }
+        }
+        const lastInsertRowid = this.db.db.lastInsertRowid();
+        const changes = this.db.db.totalChanges() === totalChangesBefore ? 0 : this.db.db.changes();
+        return { changes, lastInsertRowid };
+    }
+    /**
+     * Executes the SQL statement and returns the first row.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    async get(...bindParameters) {
+        this.stmt.reset();
+        bindParams(this.stmt, bindParameters);
+        while (true) {
+            const stepResult = this.stmt.step();
+            if (stepResult === STEP_IO) {
+                await this.db.db.ioLoopAsync();
+                continue;
+            }
+            if (stepResult === STEP_DONE) {
+                return undefined;
+            }
+            if (stepResult === STEP_ROW) {
+                return this.stmt.row();
+            }
+        }
+    }
+    /**
+     * Executes the SQL statement and returns an iterator to the resulting rows.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    async *iterate(...bindParameters) {
+        this.stmt.reset();
+        bindParams(this.stmt, bindParameters);
+        while (true) {
+            const stepResult = this.stmt.step();
+            if (stepResult === STEP_IO) {
+                await this.db.db.ioLoopAsync();
+                continue;
+            }
+            if (stepResult === STEP_DONE) {
+                break;
+            }
+            if (stepResult === STEP_ROW) {
+                yield this.stmt.row();
+            }
+        }
+    }
+    /**
+     * Executes the SQL statement and returns an array of the resulting rows.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    async all(...bindParameters) {
+        this.stmt.reset();
+        bindParams(this.stmt, bindParameters);
+        const rows = [];
+        while (true) {
+            const stepResult = this.stmt.step();
+            if (stepResult === STEP_IO) {
+                await this.db.db.ioLoopAsync();
+                continue;
+            }
+            if (stepResult === STEP_DONE) {
+                break;
+            }
+            if (stepResult === STEP_ROW) {
+                rows.push(this.stmt.row());
+            }
+        }
+        return rows;
+    }
+    /**
+     * Interrupts the statement.
+     */
+    interrupt() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Returns the columns in the result set returned by this prepared statement.
+     */
+    columns() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Binds the given parameters to the statement _permanently_
+     *
+     * @param bindParameters - The bind parameters for binding the statement.
+     * @returns this - Statement with binded parameters
+     */
+    bind(...bindParameters) {
+        try {
+            bindParams(this.stmt, bindParameters);
+            return this;
+        }
+        catch (err) {
+            throw convertError(err);
+        }
+    }
+}
+export { Database, SqliteError };

package/dist/sqlite-error.js

@@ -0,0 +1,12 @@
+export class SqliteError extends Error {
+    name;
+    code;
+    rawCode;
+    constructor(message, code, rawCode) {
+        super(message);
+        this.name = 'SqliteError';
+        this.code = code;
+        this.rawCode = rawCode;
+        Error.captureStackTrace(this, SqliteError);
+    }
+}

package/dist/sync.js

@@ -0,0 +1,346 @@
+import { Database as NativeDB } from "#entry-point";
+import { bindParams } from "./bind.js";
+import { SqliteError } from "./sqlite-error.js";
+// Step result constants
+const STEP_ROW = 1;
+const STEP_DONE = 2;
+const STEP_IO = 3;
+const convertibleErrorTypes = { TypeError };
+const CONVERTIBLE_ERROR_PREFIX = "[TURSO_CONVERT_TYPE]";
+function convertError(err) {
+    if ((err.code ?? "").startsWith(CONVERTIBLE_ERROR_PREFIX)) {
+        return createErrorByName(err.code.substring(CONVERTIBLE_ERROR_PREFIX.length), err.message);
+    }
+    return new SqliteError(err.message, err.code, err.rawCode);
+}
+function createErrorByName(name, message) {
+    const ErrorConstructor = convertibleErrorTypes[name];
+    if (!ErrorConstructor) {
+        throw new Error(`unknown error type ${name} from Turso`);
+    }
+    return new ErrorConstructor(message);
+}
+/**
+ * Database represents a connection that can prepare and execute SQL statements.
+ */
+class Database {
+    db;
+    memory;
+    open;
+    /**
+     * Creates a new database connection. If the database file pointed to by `path` does not exists, it will be created.
+     *
+     * @constructor
+     * @param {string} path - Path to the database file.
+     * @param {Object} opts - Options for database behavior.
+     * @param {boolean} [opts.readonly=false] - Open the database in read-only mode.
+     * @param {boolean} [opts.fileMustExist=false] - If true, throws if database file does not exist.
+     * @param {number} [opts.timeout=0] - Timeout duration in milliseconds for database operations. Defaults to 0 (no timeout).
+     */
+    constructor(path, opts = {}) {
+        opts.readonly = opts.readonly === undefined ? false : opts.readonly;
+        opts.fileMustExist =
+            opts.fileMustExist === undefined ? false : opts.fileMustExist;
+        opts.timeout = opts.timeout === undefined ? 0 : opts.timeout;
+        this.db = new NativeDB(path);
+        this.memory = this.db.memory;
+        const db = this.db;
+        Object.defineProperties(this, {
+            inTransaction: {
+                get() {
+                    throw new Error("not implemented");
+                },
+            },
+            name: {
+                get() {
+                    return path;
+                },
+            },
+            readonly: {
+                get() {
+                    return opts.readonly;
+                },
+            },
+            open: {
+                get() {
+                    return this.db.open;
+                },
+            },
+        });
+    }
+    /**
+     * Prepares a SQL statement for execution.
+     *
+     * @param {string} sql - The SQL statement string to prepare.
+     */
+    prepare(sql) {
+        if (!this.open) {
+            throw new TypeError("The database connection is not open");
+        }
+        if (!sql) {
+            throw new RangeError("The supplied SQL string contains no statements");
+        }
+        try {
+            return new Statement(this.db.prepare(sql), this);
+        }
+        catch (err) {
+            throw convertError(err);
+        }
+    }
+    /**
+     * Returns a function that executes the given function in a transaction.
+     *
+     * @param {function} fn - The function to wrap in a transaction.
+     */
+    transaction(fn) {
+        if (typeof fn !== "function")
+            throw new TypeError("Expected first argument to be a function");
+        const db = this;
+        const wrapTxn = (mode) => {
+            return (...bindParameters) => {
+                db.exec("BEGIN " + mode);
+                try {
+                    const result = fn(...bindParameters);
+                    db.exec("COMMIT");
+                    return result;
+                }
+                catch (err) {
+                    db.exec("ROLLBACK");
+                    throw err;
+                }
+            };
+        };
+        const properties = {
+            default: { value: wrapTxn("") },
+            deferred: { value: wrapTxn("DEFERRED") },
+            immediate: { value: wrapTxn("IMMEDIATE") },
+            exclusive: { value: wrapTxn("EXCLUSIVE") },
+            database: { value: this, enumerable: true },
+        };
+        Object.defineProperties(properties.default.value, properties);
+        Object.defineProperties(properties.deferred.value, properties);
+        Object.defineProperties(properties.immediate.value, properties);
+        Object.defineProperties(properties.exclusive.value, properties);
+        return properties.default.value;
+    }
+    pragma(source, options) {
+        if (options == null)
+            options = {};
+        if (typeof source !== "string")
+            throw new TypeError("Expected first argument to be a string");
+        if (typeof options !== "object")
+            throw new TypeError("Expected second argument to be an options object");
+        const pragma = `PRAGMA ${source}`;
+        const stmt = this.prepare(pragma);
+        const results = stmt.all();
+        return results;
+    }
+    backup(filename, options) {
+        throw new Error("not implemented");
+    }
+    serialize(options) {
+        throw new Error("not implemented");
+    }
+    function(name, options, fn) {
+        throw new Error("not implemented");
+    }
+    aggregate(name, options) {
+        throw new Error("not implemented");
+    }
+    table(name, factory) {
+        throw new Error("not implemented");
+    }
+    loadExtension(path) {
+        throw new Error("not implemented");
+    }
+    maxWriteReplicationIndex() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Executes a SQL statement.
+     *
+     * @param {string} sql - The SQL statement string to execute.
+     */
+    exec(sql) {
+        if (!this.open) {
+            throw new TypeError("The database connection is not open");
+        }
+        try {
+            this.db.batch(sql);
+        }
+        catch (err) {
+            throw convertError(err);
+        }
+    }
+    /**
+     * Interrupts the database connection.
+     */
+    interrupt() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Closes the database connection.
+     */
+    close() {
+        this.db.close();
+    }
+}
+/**
+ * Statement represents a prepared SQL statement that can be executed.
+ */
+class Statement {
+    stmt;
+    db;
+    constructor(stmt, database) {
+        this.stmt = stmt;
+        this.db = database;
+    }
+    /**
+     * Toggle raw mode.
+     *
+     * @param raw Enable or disable raw mode. If you don't pass the parameter, raw mode is enabled.
+     */
+    raw(raw) {
+        this.stmt.raw(raw);
+        return this;
+    }
+    /**
+     * Toggle pluck mode.
+     *
+     * @param pluckMode Enable or disable pluck mode. If you don't pass the parameter, pluck mode is enabled.
+     */
+    pluck(pluckMode) {
+        this.stmt.pluck(pluckMode);
+        return this;
+    }
+    get source() {
+        throw new Error("not implemented");
+    }
+    get reader() {
+        throw new Error("not implemented");
+    }
+    get database() {
+        return this.db;
+    }
+    /**
+     * Executes the SQL statement and returns an info object.
+     */
+    run(...bindParameters) {
+        const totalChangesBefore = this.db.db.totalChanges();
+        this.stmt.reset();
+        bindParams(this.stmt, bindParameters);
+        for (;;) {
+            const stepResult = this.stmt.step();
+            if (stepResult === STEP_IO) {
+                this.db.db.ioLoopSync();
+                continue;
+            }
+            if (stepResult === STEP_DONE) {
+                break;
+            }
+            if (stepResult === STEP_ROW) {
+                // For run(), we don't need the row data, just continue
+                continue;
+            }
+        }
+        const lastInsertRowid = this.db.db.lastInsertRowid();
+        const changes = this.db.db.totalChanges() === totalChangesBefore ? 0 : this.db.db.changes();
+        return { changes, lastInsertRowid };
+    }
+    /**
+     * Executes the SQL statement and returns the first row.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    get(...bindParameters) {
+        this.stmt.reset();
+        bindParams(this.stmt, bindParameters);
+        for (;;) {
+            const stepResult = this.stmt.step();
+            if (stepResult === STEP_IO) {
+                this.db.db.ioLoopSync();
+                continue;
+            }
+            if (stepResult === STEP_DONE) {
+                return undefined;
+            }
+            if (stepResult === STEP_ROW) {
+                return this.stmt.row();
+            }
+        }
+    }
+    /**
+     * Executes the SQL statement and returns an iterator to the resulting rows.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    *iterate(...bindParameters) {
+        this.stmt.reset();
+        bindParams(this.stmt, bindParameters);
+        while (true) {
+            const stepResult = this.stmt.step();
+            if (stepResult === STEP_IO) {
+                this.db.db.ioLoopSync();
+                continue;
+            }
+            if (stepResult === STEP_DONE) {
+                break;
+            }
+            if (stepResult === STEP_ROW) {
+                yield this.stmt.row();
+            }
+        }
+    }
+    /**
+     * Executes the SQL statement and returns an array of the resulting rows.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    all(...bindParameters) {
+        this.stmt.reset();
+        bindParams(this.stmt, bindParameters);
+        const rows = [];
+        for (;;) {
+            const stepResult = this.stmt.step();
+            if (stepResult === STEP_IO) {
+                this.db.db.ioLoopSync();
+                continue;
+            }
+            if (stepResult === STEP_DONE) {
+                break;
+            }
+            if (stepResult === STEP_ROW) {
+                rows.push(this.stmt.row());
+            }
+        }
+        return rows;
+    }
+    /**
+     * Interrupts the statement.
+     */
+    interrupt() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Returns the columns in the result set returned by this prepared statement.
+     */
+    columns() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Binds the given parameters to the statement _permanently_
+     *
+     * @param bindParameters - The bind parameters for binding the statement.
+     * @returns this - Statement with binded parameters
+     */
+    bind(...bindParameters) {
+        try {
+            bindParams(this.stmt, bindParameters);
+            return this;
+        }
+        catch (err) {
+            throw convertError(err);
+        }
+    }
+}
+export { Database, SqliteError };

package/index.js

@@ -0,0 +1,398 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const __dirname = new URL('.', import.meta.url).pathname
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./turso.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-android-arm64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./turso.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-android-arm-eabi')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-win32-x64-msvc')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./turso.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-win32-ia32-msvc')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-win32-arm64-msvc')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./turso.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      return require('@tursodatabase/database-darwin-universal')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-darwin-x64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-darwin-arm64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./turso.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-freebsd-x64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./turso.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-freebsd-arm64')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          return require('@tursodatabase/database-linux-x64-musl')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          return require('@tursodatabase/database-linux-x64-gnu')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          return require('@tursodatabase/database-linux-arm64-musl')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          return require('@tursodatabase/database-linux-arm64-gnu')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          return require('@tursodatabase/database-linux-arm-musleabihf')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          return require('@tursodatabase/database-linux-arm-gnueabihf')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./turso.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          return require('@tursodatabase/database-linux-riscv64-musl')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./turso.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          return require('@tursodatabase/database-linux-riscv64-gnu')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./turso.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-linux-ppc64-gnu')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./turso.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-linux-s390x-gnu')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./turso.linux-arm64-ohos.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-linux-arm64-ohos')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./turso.linux-x64-ohos.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-linux-x64-ohos')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./turso.linux-arm-ohos.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        return require('@tursodatabase/database-linux-arm-ohos')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require('./turso.wasi.cjs')
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      loadErrors.push(err)
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      nativeBinding = require('@tursodatabase/database-wasm32-wasi')
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err)
+      }
+    }
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+      { cause: loadErrors }
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { Database, Statement } = nativeBinding
+export { Database }
+export { Statement }

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@tursodatabase/database",
+  "version": "0.1.4-pre.5",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tursodatabase/turso"
+  },
+  "description": "The Turso database library",
+  "module": "./dist/promise.js",
+  "main": "./dist/promise.js",
+  "type": "module",
+  "exports": {
+    ".": "./dist/promise.js",
+    "./sync": "./dist/sync.js"
+  },
+  "files": [
+    "browser.js",
+    "index.js",
+    "dist/**"
+  ],
+  "types": "index.d.ts",
+  "napi": {
+    "binaryName": "turso",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc",
+      "universal-apple-darwin",
+      "wasm32-wasip1-threads"
+    ]
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@napi-rs/cli": "^3.0.4",
+    "@napi-rs/wasm-runtime": "^1.0.1",
+    "ava": "^6.0.1",
+    "better-sqlite3": "^11.9.1",
+    "typescript": "^5.9.2"
+  },
+  "ava": {
+    "timeout": "3m"
+  },
+  "engines": {
+    "node": ">= 10"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build": "npm exec tsc && napi build --platform --release --esm",
+    "build:debug": "npm exec tsc && napi build --platform",
+    "prepublishOnly": "npm exec tsc && napi prepublish -t npm",
+    "test": "true",
+    "universal": "napi universalize",
+    "version": "napi version"
+  },
+  "packageManager": "yarn@4.9.2",
+  "imports": {
+    "#entry-point": {
+      "types": "./index.d.ts",
+      "browser": "./browser.js",
+      "node": "./index.js"
+    }
+  },
+  "optionalDependencies": {
+    "@tursodatabase/database-linux-x64-gnu": "0.1.4-pre.5",
+    "@tursodatabase/database-win32-x64-msvc": "0.1.4-pre.5",
+    "@tursodatabase/database-darwin-universal": "0.1.4-pre.5",
+    "@tursodatabase/database-wasm32-wasi": "0.1.4-pre.5"
+  }
+}