@tursodatabase/database 0.1.5-pre.2 → 0.1.5-pre.5

package/dist/promise.js

@@ -1,373 +1,8 @@
-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).
-     */
+import { DatabasePromise, SqliteError } from "@tursodatabase/database-common";
+import { Database as NativeDB } from "#index";
+class Database extends DatabasePromise {
     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);
-        }
+        super(new NativeDB(path, { tracing: opts.tracing }), opts);
     }
 }
 /**
@@ -380,4 +15,4 @@ class Statement {
 async function connect(path, opts = {}) {
     return new Database(path, opts);
 }
-export { Database, SqliteError, connect };
+export { connect, Database, SqliteError };

package/dist/promise.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=promise.test.d.ts.map

package/dist/promise.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.test.d.ts","sourceRoot":"","sources":["../promise.test.ts"],"names":[],"mappings":""}

package/dist/promise.test.js

@@ -0,0 +1,95 @@
+import { unlinkSync } from "node:fs";
+import { expect, test } from 'vitest';
+import { connect } from './promise.js';
+test('in-memory db', async () => {
+    const db = await connect(":memory:");
+    await db.exec("CREATE TABLE t(x)");
+    await db.exec("INSERT INTO t VALUES (1), (2), (3)");
+    const stmt = db.prepare("SELECT * FROM t WHERE x % 2 = ?");
+    const rows = await stmt.all([1]);
+    expect(rows).toEqual([{ x: 1 }, { x: 3 }]);
+});
+test('on-disk db', async () => {
+    const path = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = await connect(path);
+        await db1.exec("CREATE TABLE t(x)");
+        await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const stmt1 = db1.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt1.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows1 = await stmt1.all([1]);
+        expect(rows1).toEqual([{ x: 1 }, { x: 3 }]);
+        db1.close();
+        const db2 = await connect(path);
+        const stmt2 = db2.prepare("SELECT * FROM t WHERE x % 2 = ?");
+        expect(stmt2.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows2 = await stmt2.all([1]);
+        expect(rows2).toEqual([{ x: 1 }, { x: 3 }]);
+        db2.close();
+    }
+    finally {
+        unlinkSync(path);
+        unlinkSync(`${path}-wal`);
+    }
+});
+test('attach', async () => {
+    const path1 = `test-${(Math.random() * 10000) | 0}.db`;
+    const path2 = `test-${(Math.random() * 10000) | 0}.db`;
+    try {
+        const db1 = await connect(path1);
+        await db1.exec("CREATE TABLE t(x)");
+        await db1.exec("INSERT INTO t VALUES (1), (2), (3)");
+        const db2 = await connect(path2);
+        await db2.exec("CREATE TABLE q(x)");
+        await db2.exec("INSERT INTO q VALUES (4), (5), (6)");
+        await db1.exec(`ATTACH '${path2}' as secondary`);
+        const stmt = db1.prepare("SELECT * FROM t UNION ALL SELECT * FROM secondary.q");
+        expect(stmt.columns()).toEqual([{ name: "x", column: null, database: null, table: null, type: null }]);
+        const rows = await stmt.all([1]);
+        expect(rows).toEqual([{ x: 1 }, { x: 2 }, { x: 3 }, { x: 4 }, { x: 5 }, { x: 6 }]);
+    }
+    finally {
+        unlinkSync(path1);
+        unlinkSync(`${path1}-wal`);
+        unlinkSync(path2);
+        unlinkSync(`${path2}-wal`);
+    }
+});
+test('blobs', async () => {
+    const db = await connect(":memory:");
+    const rows = await db.prepare("SELECT x'1020' as x").all();
+    expect(rows).toEqual([{ x: Buffer.from([16, 32]) }]);
+});
+test('example-1', async () => {
+    const db = await connect(':memory:');
+    await db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');
+    const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+    await insert.run('Alice', 'alice@example.com');
+    await insert.run('Bob', 'bob@example.com');
+    const users = await db.prepare('SELECT * FROM users').all();
+    expect(users).toEqual([
+        { id: 1, name: 'Alice', email: 'alice@example.com' },
+        { id: 2, name: 'Bob', email: 'bob@example.com' }
+    ]);
+});
+test('example-2', async () => {
+    const db = await connect(':memory:');
+    await db.exec('CREATE TABLE users (name, email)');
+    // Using transactions for atomic operations
+    const transaction = db.transaction(async (users) => {
+        const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
+        for (const user of users) {
+            await insert.run(user.name, user.email);
+        }
+    });
+    // Execute transaction
+    await transaction([
+        { name: 'Alice', email: 'alice@example.com' },
+        { name: 'Bob', email: 'bob@example.com' }
+    ]);
+    const rows = await db.prepare('SELECT * FROM users').all();
+    expect(rows).toEqual([
+        { name: 'Alice', email: 'alice@example.com' },
+        { name: 'Bob', email: 'bob@example.com' }
+    ]);
+});