@tursodatabase/database 0.1.4-pre.10

package/dist/promise.js

@@ -0,0 +1,383 @@
+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;
+    _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(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: () => 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 (...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.batch(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.
+     */
+    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");
+    }
+    /**
+     * 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);
+        }
+    }
+}
+/**
+ * Creates a new database connection asynchronously.
+ *
+ * @param {string} path - Path to the database file.
+ * @param {Object} opts - Options for database behavior.
+ * @returns {Promise<Database>} - A promise that resolves to a Database instance.
+ */
+async function connect(path, opts = {}) {
+    return new Database(path, opts);
+}
+export { Database, SqliteError, connect };

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

@@ -0,0 +1,130 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/** A database connection. */
+export declare class Database {
+  /**
+   * Creates a new database instance.
+   *
+   * # Arguments
+   * * `path` - The path to the database file.
+   */
+  constructor(path: string)
+  /** Returns whether the database is in memory-only mode. */
+  get memory(): boolean
+  /** Returns whether the database connection is open. */
+  get open(): boolean
+  /**
+   * Executes a batch of SQL statements.
+   *
+   * # Arguments
+   *
+   * * `sql` - The SQL statements to execute.
+   *
+   * # Returns
+   */
+  batch(sql: string): void
+  /**
+   * Prepares a statement for execution.
+   *
+   * # Arguments
+   *
+   * * `sql` - The SQL statement to prepare.
+   *
+   * # Returns
+   *
+   * A `Statement` instance.
+   */
+  prepare(sql: string): Statement
+  /**
+   * Returns the rowid of the last row inserted.
+   *
+   * # Returns
+   *
+   * The rowid of the last row inserted.
+   */
+  lastInsertRowid(): number
+  /**
+   * Returns the number of changes made by the last statement.
+   *
+   * # Returns
+   *
+   * The number of changes made by the last statement.
+   */
+  changes(): number
+  /**
+   * Returns the total number of changes made by all statements.
+   *
+   * # Returns
+   *
+   * The total number of changes made by all statements.
+   */
+  totalChanges(): number
+  /**
+   * Closes the database connection.
+   *
+   * # Returns
+   *
+   * `Ok(())` if the database is closed successfully.
+   */
+  close(): void
+  /**
+   * Sets the default safe integers mode for all statements from this database.
+   *
+   * # Arguments
+   *
+   * * `toggle` - Whether to use safe integers by default.
+   */
+  defaultSafeIntegers(toggle?: boolean | undefined | null): void
+  /** Runs the I/O loop synchronously. */
+  ioLoopSync(): void
+  /** Runs the I/O loop asynchronously, returning a Promise. */
+  ioLoopAsync(): Promise<void>
+}
+
+/** A prepared statement. */
+export declare class Statement {
+  reset(): void
+  /** Returns the number of parameters in the statement. */
+  parameterCount(): number
+  /**
+   * Returns the name of a parameter at a specific 1-based index.
+   *
+   * # Arguments
+   *
+   * * `index` - The 1-based parameter index.
+   */
+  parameterName(index: number): string | null
+  /**
+   * Binds a parameter at a specific 1-based index with explicit type.
+   *
+   * # Arguments
+   *
+   * * `index` - The 1-based parameter index.
+   * * `value_type` - The type constant (0=null, 1=int, 2=float, 3=text, 4=blob).
+   * * `value` - The value to bind.
+   */
+  bindAt(index: number, value: unknown): void
+  /**
+   * Step the statement and return result code:
+   * 1 = Row available, 2 = Done, 3 = I/O needed
+   */
+  step(): number
+  /** Get the current row data according to the presentation mode */
+  row(): unknown
+  /** Sets the presentation mode to raw. */
+  raw(raw?: boolean | undefined | null): void
+  /** Sets the presentation mode to pluck. */
+  pluck(pluck?: boolean | undefined | null): void
+  /**
+   * Sets safe integers mode for this statement.
+   *
+   * # Arguments
+   *
+   * * `toggle` - Whether to use safe integers.
+   */
+  safeIntegers(toggle?: boolean | undefined | null): void
+  /** Get column information for the statement */
+  columns(): unknown[]
+  /** Finalizes the statement. */
+  finalize(): void
+}