@tursodatabase/database-common 0.1.5-pre.3

package/README.md

@@ -0,0 +1,8 @@
+## About
+
+This package is the Turso embedded database common JS library which is shared between final builds for Node and Browser.
+
+Do not use this package directly - instead you must use `@tursodatabase/database` or `@tursodatabase/database-browser`.
+
+> **⚠️ Warning:** This software is ALPHA, only use for development, testing, and experimentation. We are working to make it production ready, but do not use it for critical data right now.
+

package/dist/bind.d.ts

@@ -0,0 +1,2 @@
+export declare function bindParams(stmt: any, params: any): void;
+//# sourceMappingURL=bind.d.ts.map

package/dist/bind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../bind.ts"],"names":[],"mappings":"AASA,wBAAgB,UAAU,CAAC,IAAI,KAAA,EAAE,MAAM,KAAA,QAmBtC"}

package/dist/bind.js

@@ -0,0 +1,68 @@
+// 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;
+        }
+        if (Array.isArray(param)) {
+            bindPositionalParams(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/compat.d.ts

@@ -0,0 +1,134 @@
+import { NativeDatabase, NativeStatement } from "./types.js";
+/**
+ * Database represents a connection that can prepare and execute SQL statements.
+ */
+declare class Database {
+    db: NativeDatabase;
+    memory: boolean;
+    open: boolean;
+    private _inTransaction;
+    /**
+     * 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(db: NativeDatabase, opts?: any);
+    /**
+     * Prepares a SQL statement for execution.
+     *
+     * @param {string} sql - The SQL statement string to prepare.
+     */
+    prepare(sql: any): Statement;
+    /**
+     * Returns a function that executes the given function in a transaction.
+     *
+     * @param {function} fn - The function to wrap in a transaction.
+     */
+    transaction(fn: any): (...bindParameters: any[]) => any;
+    pragma(source: any, options: any): any[];
+    backup(filename: any, options: any): void;
+    serialize(options: any): void;
+    function(name: any, options: any, fn: any): void;
+    aggregate(name: any, options: any): void;
+    table(name: any, factory: any): void;
+    loadExtension(path: any): void;
+    maxWriteReplicationIndex(): void;
+    /**
+     * Executes a SQL statement.
+     *
+     * @param {string} sql - The SQL statement string to execute.
+     */
+    exec(sql: any): void;
+    /**
+     * Interrupts the database connection.
+     */
+    interrupt(): void;
+    /**
+     * Sets the default safe integers mode for all statements from this database.
+     *
+     * @param {boolean} [toggle] - Whether to use safe integers by default.
+     */
+    defaultSafeIntegers(toggle: any): void;
+    /**
+     * Closes the database connection.
+     */
+    close(): void;
+}
+/**
+ * Statement represents a prepared SQL statement that can be executed.
+ */
+declare class Statement {
+    stmt: NativeStatement;
+    db: Database;
+    constructor(stmt: NativeStatement, database: Database);
+    /**
+     * Toggle raw mode.
+     *
+     * @param raw Enable or disable raw mode. If you don't pass the parameter, raw mode is enabled.
+     */
+    raw(raw: any): this;
+    /**
+     * Toggle pluck mode.
+     *
+     * @param pluckMode Enable or disable pluck mode. If you don't pass the parameter, pluck mode is enabled.
+     */
+    pluck(pluckMode: any): this;
+    /**
+     * Sets safe integers mode for this statement.
+     *
+     * @param {boolean} [toggle] - Whether to use safe integers.
+     */
+    safeIntegers(toggle: any): this;
+    /**
+     * Get column information for the statement.
+     *
+     * @returns {Array} An array of column objects with name, column, table, database, and type properties.
+     */
+    columns(): string[];
+    get source(): void;
+    get reader(): void;
+    get database(): Database;
+    /**
+     * Executes the SQL statement and returns an info object.
+     */
+    run(...bindParameters: any[]): {
+        changes: number;
+        lastInsertRowid: number;
+    };
+    /**
+     * Executes the SQL statement and returns the first row.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    get(...bindParameters: any[]): any;
+    /**
+     * Executes the SQL statement and returns an iterator to the resulting rows.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    iterate(...bindParameters: any[]): Generator<any, void, unknown>;
+    /**
+     * Executes the SQL statement and returns an array of the resulting rows.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    all(...bindParameters: any[]): any[];
+    /**
+     * Interrupts the statement.
+     */
+    interrupt(): void;
+    /**
+     * 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: any[]): this;
+}
+export { Database, Statement };
+//# sourceMappingURL=compat.d.ts.map

package/dist/compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.d.ts","sourceRoot":"","sources":["../compat.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAgC,MAAM,YAAY,CAAC;AAyB3F;;GAEG;AACH,cAAM,QAAQ;IACZ,EAAE,EAAE,cAAc,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,cAAc,CAAkB;IAExC;;;;;;;;;OASG;gBACS,EAAE,EAAE,cAAc,EAAE,IAAI,GAAE,GAAQ;IA+B9C;;;;OAIG;IACH,OAAO,CAAC,GAAG,KAAA;IAgBX;;;;OAIG;IACH,WAAW,CAAC,EAAE,KAAA;IAmCd,MAAM,CAAC,MAAM,KAAA,EAAE,OAAO,KAAA;IAiBtB,MAAM,CAAC,QAAQ,KAAA,EAAE,OAAO,KAAA;IAIxB,SAAS,CAAC,OAAO,KAAA;IAIjB,QAAQ,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,EAAE,KAAA;IAI1B,SAAS,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA;IAIvB,KAAK,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA;IAInB,aAAa,CAAC,IAAI,KAAA;IAIlB,wBAAwB;IAIxB;;;;OAIG;IACH,IAAI,CAAC,GAAG,KAAA;IAYR;;OAEG;IACH,SAAS;IAIT;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,KAAA;IAI1B;;OAEG;IACH,KAAK;CAGN;AAED;;GAEG;AACH,cAAM,SAAS;IACb,IAAI,EAAE,eAAe,CAAC;IACtB,EAAE,EAAE,QAAQ,CAAC;gBAED,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,QAAQ;IAKrD;;;;OAIG;IACH,GAAG,CAAC,GAAG,KAAA;IAKP;;;;OAIG;IACH,KAAK,CAAC,SAAS,KAAA;IAKf;;;;OAIG;IACH,YAAY,CAAC,MAAM,KAAA;IAKnB;;;;OAIG;IACH,OAAO;IAIP,IAAI,MAAM,SAET;IAED,IAAI,MAAM,SAET;IAED,IAAI,QAAQ,aAEX;IAED;;OAEG;IACH,GAAG,CAAC,GAAG,cAAc,OAAA;;;;IA0BrB;;;;OAIG;IACH,GAAG,CAAC,GAAG,cAAc,OAAA;IAkBrB;;;;OAIG;IACF,OAAO,CAAC,GAAG,cAAc,OAAA;IAmB1B;;;;OAIG;IACH,GAAG,CAAC,GAAG,cAAc,OAAA;IAoBrB;;OAEG;IACH,SAAS;IAKT;;;;;OAKG;IACH,IAAI,CAAC,GAAG,cAAc,OAAA;CAQvB;AAED,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAA"}

package/dist/compat.js

@@ -0,0 +1,362 @@
+import { bindParams } from "./bind.js";
+import { SqliteError } from "./sqlite-error.js";
+import { STEP_IO, STEP_ROW, STEP_DONE } from "./types.js";
+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;
+    _inTransaction = false;
+    /**
+     * 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(db, 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 = db;
+        this.memory = this.db.memory;
+        Object.defineProperties(this, {
+            inTransaction: {
+                get: () => this._inTransaction,
+            },
+            name: {
+                get() {
+                    return db.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);
+                db._inTransaction = true;
+                try {
+                    const result = fn(...bindParameters);
+                    db.exec("COMMIT");
+                    db._inTransaction = false;
+                    return result;
+                }
+                catch (err) {
+                    db.exec("ROLLBACK");
+                    db._inTransaction = false;
+                    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.batchSync(sql);
+        }
+        catch (err) {
+            throw convertError(err);
+        }
+    }
+    /**
+     * Interrupts the database connection.
+     */
+    interrupt() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Sets the default safe integers mode for all statements from this database.
+     *
+     * @param {boolean} [toggle] - Whether to use safe integers by default.
+     */
+    defaultSafeIntegers(toggle) {
+        this.db.defaultSafeIntegers(toggle);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Sets safe integers mode for this statement.
+     *
+     * @param {boolean} [toggle] - Whether to use safe integers.
+     */
+    safeIntegers(toggle) {
+        this.stmt.safeIntegers(toggle);
+        return this;
+    }
+    /**
+     * Get column information for the statement.
+     *
+     * @returns {Array} An array of column objects with name, column, table, database, and type properties.
+     */
+    columns() {
+        return this.stmt.columns();
+    }
+    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.stepSync();
+            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.stepSync();
+            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.stepSync();
+            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.stepSync();
+            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");
+    }
+    /**
+     * 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, Statement };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { NativeDatabase, NativeStatement, DatabaseOpts } from "./types.js";
+import { Database as DatabaseCompat, Statement as StatementCompat } from "./compat.js";
+import { Database as DatabasePromise, Statement as StatementPromise } from "./promise.js";
+import { SqliteError } from "./sqlite-error.js";
+export { DatabaseCompat, StatementCompat, DatabasePromise, StatementPromise, NativeDatabase, NativeStatement, SqliteError, DatabaseOpts };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,QAAQ,IAAI,cAAc,EAAE,SAAS,IAAI,eAAe,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,SAAS,IAAI,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,YAAY,EAAE,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+import { Database as DatabaseCompat, Statement as StatementCompat } from "./compat.js";
+import { Database as DatabasePromise, Statement as StatementPromise } from "./promise.js";
+import { SqliteError } from "./sqlite-error.js";
+export { DatabaseCompat, StatementCompat, DatabasePromise, StatementPromise, SqliteError };

package/dist/promise.d.ts

@@ -0,0 +1,137 @@
+import { NativeDatabase, NativeStatement, DatabaseOpts } from "./types.js";
+/**
+ * Database represents a connection that can prepare and execute SQL statements.
+ */
+declare class Database {
+    db: NativeDatabase;
+    memory: boolean;
+    open: boolean;
+    private _inTransaction;
+    /**
+     * 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(db: NativeDatabase, opts?: DatabaseOpts);
+    static create(): any;
+    initialize(db: NativeDatabase, name: any, readonly: any): void;
+    /**
+     * Prepares a SQL statement for execution.
+     *
+     * @param {string} sql - The SQL statement string to prepare.
+     */
+    prepare(sql: any): Statement;
+    /**
+     * Returns a function that executes the given function in a transaction.
+     *
+     * @param {function} fn - The function to wrap in a transaction.
+     */
+    transaction(fn: (...any: any[]) => Promise<any>): (...bindParameters: any[]) => Promise<any>;
+    pragma(source: any, options: any): Promise<any[]>;
+    backup(filename: any, options: any): void;
+    serialize(options: any): void;
+    function(name: any, options: any, fn: any): void;
+    aggregate(name: any, options: any): void;
+    table(name: any, factory: any): void;
+    loadExtension(path: any): void;
+    maxWriteReplicationIndex(): void;
+    /**
+     * Executes a SQL statement.
+     *
+     * @param {string} sql - The SQL statement string to execute.
+     */
+    exec(sql: any): Promise<void>;
+    /**
+     * Interrupts the database connection.
+     */
+    interrupt(): void;
+    /**
+     * Sets the default safe integers mode for all statements from this database.
+     *
+     * @param {boolean} [toggle] - Whether to use safe integers by default.
+     */
+    defaultSafeIntegers(toggle: any): void;
+    /**
+     * Closes the database connection.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Statement represents a prepared SQL statement that can be executed.
+ */
+declare class Statement {
+    stmt: NativeStatement;
+    db: Database;
+    constructor(stmt: any, database: any);
+    /**
+     * Toggle raw mode.
+     *
+     * @param raw Enable or disable raw mode. If you don't pass the parameter, raw mode is enabled.
+     */
+    raw(raw: any): this;
+    /**
+     * Toggle pluck mode.
+     *
+     * @param pluckMode Enable or disable pluck mode. If you don't pass the parameter, pluck mode is enabled.
+     */
+    pluck(pluckMode: any): this;
+    /**
+     * Sets safe integers mode for this statement.
+     *
+     * @param {boolean} [toggle] - Whether to use safe integers.
+     */
+    safeIntegers(toggle: any): this;
+    /**
+     * Get column information for the statement.
+     *
+     * @returns {Array} An array of column objects with name, column, table, database, and type properties.
+     */
+    columns(): string[];
+    get source(): void;
+    get reader(): void;
+    get database(): Database;
+    /**
+     * Executes the SQL statement and returns an info object.
+     */
+    run(...bindParameters: any[]): Promise<{
+        changes: number;
+        lastInsertRowid: number;
+    }>;
+    /**
+     * Executes the SQL statement and returns the first row.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    get(...bindParameters: any[]): Promise<any>;
+    /**
+     * Executes the SQL statement and returns an iterator to the resulting rows.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    iterate(...bindParameters: any[]): AsyncGenerator<any, void, unknown>;
+    /**
+     * Executes the SQL statement and returns an array of the resulting rows.
+     *
+     * @param bindParameters - The bind parameters for executing the statement.
+     */
+    all(...bindParameters: any[]): Promise<any[]>;
+    /**
+     * Interrupts the statement.
+     */
+    interrupt(): void;
+    /**
+     * 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: any[]): this;
+    close(): void;
+}
+export { Database, Statement };
+//# sourceMappingURL=promise.d.ts.map

package/dist/promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../promise.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,eAAe,EAAgC,YAAY,EAAE,MAAM,YAAY,CAAC;AAyBzG;;GAEG;AACH,cAAM,QAAQ;IACZ,EAAE,EAAE,cAAc,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,cAAc,CAAkB;IACxC;;;;;;;;;OASG;gBACS,EAAE,EAAE,cAAc,EAAE,IAAI,GAAE,YAAiB;IAQvD,MAAM,CAAC,MAAM;IAGb,UAAU,CAAC,EAAE,EAAE,cAAc,EAAE,IAAI,KAAA,EAAE,QAAQ,KAAA;IAyB7C;;;;OAIG;IACH,OAAO,CAAC,GAAG,KAAA;IAgBX;;;;OAIG;IACH,WAAW,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,OAAA,KAAK,OAAO,CAAC,GAAG,CAAC;IAmClC,MAAM,CAAC,MAAM,KAAA,EAAE,OAAO,KAAA;IAiB5B,MAAM,CAAC,QAAQ,KAAA,EAAE,OAAO,KAAA;IAIxB,SAAS,CAAC,OAAO,KAAA;IAIjB,QAAQ,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,EAAE,KAAA;IAI1B,SAAS,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA;IAIvB,KAAK,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA;IAInB,aAAa,CAAC,IAAI,KAAA;IAIlB,wBAAwB;IAIxB;;;;OAIG;IACG,IAAI,CAAC,GAAG,KAAA;IAYd;;OAEG;IACH,SAAS;IAIT;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,KAAA;IAI1B;;OAEG;IACG,KAAK;CAGZ;AAED;;GAEG;AACH,cAAM,SAAS;IACb,IAAI,EAAE,eAAe,CAAC;IACtB,EAAE,EAAE,QAAQ,CAAC;gBACD,IAAI,KAAA,EAAE,QAAQ,KAAA;IAK1B;;;;OAIG;IACH,GAAG,CAAC,GAAG,KAAA;IAKP;;;;OAIG;IACH,KAAK,CAAC,SAAS,KAAA;IAKf;;;;OAIG;IACH,YAAY,CAAC,MAAM,KAAA;IAKnB;;;;OAIG;IACH,OAAO;IAIP,IAAI,MAAM,SAET;IAED,IAAI,MAAM,SAET;IAED,IAAI,QAAQ,aAEX;IAED;;OAEG;IACG,GAAG,CAAC,GAAG,cAAc,OAAA;;;;IA2B3B;;;;OAIG;IACG,GAAG,CAAC,GAAG,cAAc,OAAA;IAmB3B;;;;OAIG;IACI,OAAO,CAAC,GAAG,cAAc,OAAA;IAmBhC;;;;OAIG;IACG,GAAG,CAAC,GAAG,cAAc,OAAA;IAqB3B;;OAEG;IACH,SAAS;IAKT;;;;;OAKG;IACH,IAAI,CAAC,GAAG,cAAc,OAAA;IAStB,KAAK;CAGN;AACD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAA"}

package/dist/promise.js

@@ -0,0 +1,371 @@
+import { bindParams } from "./bind.js";
+import { SqliteError } from "./sqlite-error.js";
+import { STEP_IO, STEP_ROW, STEP_DONE } from "./types.js";
+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;
+    _inTransaction = false;
+    /**
+     * 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(db, 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.initialize(db, opts.name, 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: () => this._inTransaction,
+            },
+            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 async (...bindParameters) => {
+                await db.exec("BEGIN " + mode);
+                db._inTransaction = true;
+                try {
+                    const result = await fn(...bindParameters);
+                    await db.exec("COMMIT");
+                    db._inTransaction = false;
+                    return result;
+                }
+                catch (err) {
+                    await db.exec("ROLLBACK");
+                    db._inTransaction = false;
+                    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;
+    }
+    async 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 = await this.prepare(pragma);
+        const results = await 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.
+     */
+    async exec(sql) {
+        if (!this.open) {
+            throw new TypeError("The database connection is not open");
+        }
+        try {
+            await this.db.batchAsync(sql);
+        }
+        catch (err) {
+            throw convertError(err);
+        }
+    }
+    /**
+     * Interrupts the database connection.
+     */
+    interrupt() {
+        throw new Error("not implemented");
+    }
+    /**
+     * Sets the default safe integers mode for all statements from this database.
+     *
+     * @param {boolean} [toggle] - Whether to use safe integers by default.
+     */
+    defaultSafeIntegers(toggle) {
+        this.db.defaultSafeIntegers(toggle);
+    }
+    /**
+     * Closes the database connection.
+     */
+    async 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;
+    }
+    /**
+     * Sets safe integers mode for this statement.
+     *
+     * @param {boolean} [toggle] - Whether to use safe integers.
+     */
+    safeIntegers(toggle) {
+        this.stmt.safeIntegers(toggle);
+        return this;
+    }
+    /**
+     * Get column information for the statement.
+     *
+     * @returns {Array} An array of column objects with name, column, table, database, and type properties.
+     */
+    columns() {
+        return this.stmt.columns();
+    }
+    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 = await this.stmt.stepAsync();
+            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 = await this.stmt.stepAsync();
+            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 = await this.stmt.stepAsync();
+            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 = await this.stmt.stepAsync();
+            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");
+    }
+    /**
+     * 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);
+        }
+    }
+    close() {
+        this.stmt.finalize();
+    }
+}
+export { Database, Statement };

package/dist/sqlite-error.d.ts

@@ -0,0 +1,7 @@
+export declare class SqliteError extends Error {
+    name: string;
+    code: string;
+    rawCode: string;
+    constructor(message: any, code: any, rawCode: any);
+}
+//# sourceMappingURL=sqlite-error.d.ts.map

package/dist/sqlite-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-error.d.ts","sourceRoot":"","sources":["../sqlite-error.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAY,SAAQ,KAAK;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,OAAO,KAAA,EAAE,IAAI,KAAA,EAAE,OAAO,KAAA;CAQnC"}

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/types.d.ts

@@ -0,0 +1,38 @@
+export interface DatabaseOpts {
+    readonly?: boolean;
+    fileMustExist?: boolean;
+    timeout?: number;
+    name?: string;
+    tracing?: 'info' | 'debug' | 'trace';
+}
+export interface NativeDatabase {
+    memory: boolean;
+    path: string;
+    new (path: string): NativeDatabase;
+    batchSync(sql: string): any;
+    batchAsync(sql: string): Promise<void>;
+    ioLoopSync(): any;
+    ioLoopAsync(): Promise<void>;
+    prepare(sql: string): NativeStatement;
+    pluck(pluckMode: boolean): any;
+    defaultSafeIntegers(toggle: boolean): any;
+    totalChanges(): number;
+    changes(): number;
+    lastInsertRowid(): number;
+    close(): any;
+}
+export declare const STEP_ROW = 1;
+export declare const STEP_DONE = 2;
+export declare const STEP_IO = 3;
+export interface NativeStatement {
+    stepAsync(): Promise<number>;
+    stepSync(): number;
+    pluck(pluckMode: boolean): any;
+    safeIntegers(toggle: boolean): any;
+    raw(toggle: boolean): any;
+    columns(): string[];
+    row(): any;
+    reset(): any;
+    finalize(): any;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;CACvC;AAED,MAAM,WAAW,cAAc;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAI,IAAI,EAAE,MAAM,GAAG,cAAc,CAAC;IAClC,SAAS,CAAC,GAAG,EAAE,MAAM,OAAE;IACvB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvC,UAAU,QAAG;IACb,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC;IAEtC,KAAK,CAAC,SAAS,EAAE,OAAO,OAAE;IAC1B,mBAAmB,CAAC,MAAM,EAAE,OAAO,OAAE;IACrC,YAAY,IAAI,MAAM,CAAC;IACvB,OAAO,IAAI,MAAM,CAAC;IAClB,eAAe,IAAI,MAAM,CAAC;IAC1B,KAAK,QAAG;CACX;AAID,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,eAAO,MAAM,OAAO,IAAI,CAAC;AAEzB,MAAM,WAAW,eAAe;IAC5B,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7B,QAAQ,IAAI,MAAM,CAAC;IAEnB,KAAK,CAAC,SAAS,EAAE,OAAO,OAAE;IAC1B,YAAY,CAAC,MAAM,EAAE,OAAO,OAAE;IAC9B,GAAG,CAAC,MAAM,EAAE,OAAO,OAAE;IACrB,OAAO,IAAI,MAAM,EAAE,CAAC;IACpB,GAAG,IAAI,GAAG,CAAC;IACX,KAAK,QAAG;IACR,QAAQ,QAAG;CACd"}

package/dist/types.js

@@ -0,0 +1,4 @@
+// Step result constants
+export const STEP_ROW = 1;
+export const STEP_DONE = 2;
+export const STEP_IO = 3;

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@tursodatabase/database-common",
+  "version": "0.1.5-pre.3",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tursodatabase/turso"
+  },
+  "type": "module",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "packageManager": "yarn@4.9.2",
+  "files": [
+    "dist/**",
+    "README.md"
+  ],
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "tsc-build": "npm exec tsc",
+    "build": "npm run tsc-build",
+    "test": "echo 'no tests'"
+  }
+}