@tursodatabase/serverless 1.1.0-pre.1 → 1.1.0-pre.2

package/dist/compat.d.ts

@@ -87,11 +87,10 @@ export declare class LibsqlError extends Error {
     constructor(message: string, code: string, extendedCode?: string, rawCode?: number, cause?: Error);
 }
 /**
- * Interactive transaction interface (not implemented in serverless mode).
+ * Interactive transaction interface.
  *
  * @remarks
- * Transactions are not supported in the serverless compatibility layer.
- * Calling transaction() will throw a LibsqlError.
+ * A transaction keeps a dedicated session open until commit/rollback/close.
  */
 export interface Transaction {
     execute(stmt: InStatement): Promise<ResultSet>;

package/dist/compat.js

@@ -25,6 +25,7 @@ class LibSQLClient {
             authToken: config.authToken || '',
             remoteEncryptionKey: config.remoteEncryptionKey
         };
+        this.sessionConfig = sessionConfig;
         this.session = new Session(sessionConfig);
     }
     validateConfig(config) {
@@ -157,8 +158,124 @@ class LibSQLClient {
         // For now, just call batch - in a real implementation this would disable foreign keys
         return this.batch(stmts, "write");
     }
+    modeToBeginSql(mode) {
+        switch (mode) {
+            case "write":
+                return "BEGIN IMMEDIATE";
+            case "deferred":
+                return "BEGIN DEFERRED";
+            case "read":
+            default:
+                return "BEGIN";
+        }
+    }
     async transaction(mode) {
-        throw new LibsqlError("Transactions not implemented", "NOT_IMPLEMENTED");
+        await this.execLock.acquire();
+        if (this._closed) {
+            this.execLock.release();
+            throw new LibsqlError("Client is closed", "CLIENT_CLOSED");
+        }
+        const txSession = new Session(this.sessionConfig);
+        let txClosed = false;
+        let cleanupStarted = false;
+        const ensureOpen = () => {
+            if (txClosed) {
+                throw new LibsqlError("Transaction is closed", "TRANSACTION_CLOSED");
+            }
+        };
+        const closeTx = async () => {
+            if (cleanupStarted)
+                return;
+            cleanupStarted = true;
+            txClosed = true;
+            try {
+                await txSession.close();
+            }
+            finally {
+                this.execLock.release();
+            }
+        };
+        const executeInTx = async (stmt) => {
+            ensureOpen();
+            const normalized = this.normalizeStatement(stmt);
+            try {
+                const result = await txSession.execute(normalized.sql, normalized.args, this._defaultSafeIntegers);
+                return this.convertResult(result);
+            }
+            catch (error) {
+                throw mapDatabaseError(error, "EXECUTE_ERROR");
+            }
+        };
+        try {
+            await txSession.sequence(this.modeToBeginSql(mode));
+        }
+        catch (error) {
+            await closeTx();
+            throw mapDatabaseError(error, "BEGIN_ERROR");
+        }
+        return {
+            execute: async (stmtOrSql, args) => {
+                if (typeof stmtOrSql === "string") {
+                    const normalizedArgs = args ? (Array.isArray(args) ? args : Object.values(args)) : [];
+                    return executeInTx({ sql: stmtOrSql, args: normalizedArgs });
+                }
+                return executeInTx(stmtOrSql);
+            },
+            batch: async (stmts) => {
+                ensureOpen();
+                const results = [];
+                for (const stmt of stmts) {
+                    results.push(await executeInTx(stmt));
+                }
+                return results;
+            },
+            executeMultiple: async (sql) => {
+                ensureOpen();
+                try {
+                    await txSession.sequence(sql);
+                }
+                catch (error) {
+                    throw mapDatabaseError(error, "EXECUTE_MULTIPLE_ERROR");
+                }
+            },
+            commit: async () => {
+                ensureOpen();
+                try {
+                    await txSession.sequence("COMMIT");
+                }
+                catch (error) {
+                    throw mapDatabaseError(error, "COMMIT_ERROR");
+                }
+                finally {
+                    await closeTx();
+                }
+            },
+            rollback: async () => {
+                ensureOpen();
+                try {
+                    await txSession.sequence("ROLLBACK");
+                }
+                catch (error) {
+                    throw mapDatabaseError(error, "ROLLBACK_ERROR");
+                }
+                finally {
+                    await closeTx();
+                }
+            },
+            close: () => {
+                if (txClosed)
+                    return;
+                txClosed = true;
+                void txSession.sequence("ROLLBACK")
+                    .catch(() => undefined)
+                    .finally(() => {
+                    void closeTx();
+                });
+            },
+            get closed() {
+                return txClosed;
+            },
+        };
     }
     async executeMultiple(sql) {
         await this.execLock.acquire();

package/dist/connection.d.ts

@@ -65,7 +65,7 @@ export declare class Connection {
     /**
      * Prepare a SQL statement for execution.
      *
-     * Each prepared statement gets its own session to avoid conflicts during concurrent execution.
+     * Prepared statements created from a Connection use the same underlying session so transaction boundaries are preserved.
      * This method fetches column metadata using the describe functionality.
      *
      * @param sql - The SQL statement to prepare

package/dist/connection.js

@@ -71,7 +71,7 @@ export class Connection {
     /**
      * Prepare a SQL statement for execution.
      *
-     * Each prepared statement gets its own session to avoid conflicts during concurrent execution.
+     * Prepared statements created from a Connection use the same underlying session so transaction boundaries are preserved.
      * This method fetches column metadata using the describe functionality.
      *
      * @param sql - The SQL statement to prepare
@@ -92,7 +92,7 @@ export class Connection {
         const session = new Session(this.config);
         const description = await session.describe(sql);
         await session.close();
-        const stmt = new Statement(this.config, sql, description.cols);
+        const stmt = Statement.fromSession(this.session, sql, description.cols, this.execLock);
         if (this.defaultSafeIntegerMode) {
             stmt.safeIntegers(true);
         }

package/dist/statement.d.ts

@@ -1,9 +1,10 @@
 import { type Column, type QueryOptions } from './protocol.js';
-import { type SessionConfig } from './session.js';
+import { Session, type SessionConfig } from './session.js';
+import { type AsyncLock } from './async-lock.js';
 /**
  * A prepared SQL statement that can be executed in multiple ways.
  *
- * Each statement has its own session to avoid conflicts during concurrent execution.
+ * Statements may either own a dedicated session or share a connection session to preserve transaction boundaries.
  * Provides three execution modes:
  * - `get(args?)`: Returns the first row or null
  * - `all(args?)`: Returns all rows as an array
@@ -15,7 +16,14 @@ export declare class Statement {
     private presentationMode;
     private safeIntegerMode;
     private columnMetadata;
+    private execLock?;
     constructor(sessionConfig: SessionConfig, sql: string, columns?: Column[]);
+    /**
+     * Create a Statement that shares an existing session and serializes execution
+     * through the given lock. Used by Connection.prepare() so prepared statements
+     * participate in the connection's transaction scope.
+     */
+    static fromSession(session: Session, sql: string, columns: Column[] | undefined, execLock: AsyncLock): Statement;
     /**
      * Whether the prepared statement returns data.
      *
@@ -81,6 +89,7 @@ export declare class Statement {
      * ```
      */
     columns(): any[];
+    private withLock;
     /**
      * Executes the prepared statement.
      *

package/dist/statement.js

@@ -4,7 +4,7 @@ import { DatabaseError } from './error.js';
 /**
  * A prepared SQL statement that can be executed in multiple ways.
  *
- * Each statement has its own session to avoid conflicts during concurrent execution.
+ * Statements may either own a dedicated session or share a connection session to preserve transaction boundaries.
  * Provides three execution modes:
  * - `get(args?)`: Returns the first row or null
  * - `all(args?)`: Returns all rows as an array
@@ -18,6 +18,21 @@ export class Statement {
         this.sql = sql;
         this.columnMetadata = columns || [];
     }
+    /**
+     * Create a Statement that shares an existing session and serializes execution
+     * through the given lock. Used by Connection.prepare() so prepared statements
+     * participate in the connection's transaction scope.
+     */
+    static fromSession(session, sql, columns, execLock) {
+        const stmt = Object.create(Statement.prototype);
+        stmt.session = session;
+        stmt.sql = sql;
+        stmt.columnMetadata = columns || [];
+        stmt.presentationMode = 'expanded';
+        stmt.safeIntegerMode = false;
+        stmt.execLock = execLock;
+        return stmt;
+    }
     /**
      * Whether the prepared statement returns data.
      *
@@ -99,6 +114,18 @@ export class Statement {
             type: col.decltype
         }));
     }
+    async withLock(fn) {
+        if (!this.execLock) {
+            return await fn();
+        }
+        await this.execLock.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.execLock.release();
+        }
+    }
     /**
      * Executes the prepared statement.
      *
@@ -113,9 +140,11 @@ export class Statement {
      * ```
      */
     async run(args, queryOptions) {
-        const normalizedArgs = this.normalizeArgs(args);
-        const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
-        return { changes: result.rowsAffected, lastInsertRowid: result.lastInsertRowid };
+        return await this.withLock(async () => {
+            const normalizedArgs = this.normalizeArgs(args);
+            const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
+            return { changes: result.rowsAffected, lastInsertRowid: result.lastInsertRowid };
+        });
     }
     /**
      * Execute the statement and return the first row.
@@ -133,27 +162,29 @@ export class Statement {
      * ```
      */
     async get(args, queryOptions) {
-        const normalizedArgs = this.normalizeArgs(args);
-        const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
-        const row = result.rows[0];
-        if (!row) {
-            return undefined;
-        }
-        if (this.presentationMode === 'pluck') {
-            // In pluck mode, return only the first column value
-            return row[0];
-        }
-        if (this.presentationMode === 'raw') {
-            // In raw mode, return the row as a plain array (it already is one)
-            // The row object is already an array with column properties added
-            return [...row];
-        }
-        // In expanded mode, convert to plain object with named properties  
-        const obj = {};
-        result.columns.forEach((col, i) => {
-            obj[col] = row[i];
+        return await this.withLock(async () => {
+            const normalizedArgs = this.normalizeArgs(args);
+            const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
+            const row = result.rows[0];
+            if (!row) {
+                return undefined;
+            }
+            if (this.presentationMode === 'pluck') {
+                // In pluck mode, return only the first column value
+                return row[0];
+            }
+            if (this.presentationMode === 'raw') {
+                // In raw mode, return the row as a plain array (it already is one)
+                // The row object is already an array with column properties added
+                return [...row];
+            }
+            // In expanded mode, convert to plain object with named properties
+            const obj = {};
+            result.columns.forEach((col, i) => {
+                obj[col] = row[i];
+            });
+            return obj;
         });
-        return obj;
     }
     /**
      * Execute the statement and return all rows.
@@ -169,22 +200,24 @@ export class Statement {
      * ```
      */
     async all(args, queryOptions) {
-        const normalizedArgs = this.normalizeArgs(args);
-        const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
-        if (this.presentationMode === 'pluck') {
-            // In pluck mode, return only the first column value from each row
-            return result.rows.map((row) => row[0]);
-        }
-        if (this.presentationMode === 'raw') {
-            return result.rows.map((row) => [...row]);
-        }
-        // In expanded mode, convert rows to plain objects with named properties
-        return result.rows.map((row) => {
-            const obj = {};
-            result.columns.forEach((col, i) => {
-                obj[col] = row[i];
+        return await this.withLock(async () => {
+            const normalizedArgs = this.normalizeArgs(args);
+            const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
+            if (this.presentationMode === 'pluck') {
+                // In pluck mode, return only the first column value from each row
+                return result.rows.map((row) => row[0]);
+            }
+            if (this.presentationMode === 'raw') {
+                return result.rows.map((row) => [...row]);
+            }
+            // In expanded mode, convert rows to plain objects with named properties
+            return result.rows.map((row) => {
+                const obj = {};
+                result.columns.forEach((col, i) => {
+                    obj[col] = row[i];
+                });
+                return obj;
             });
-            return obj;
         });
     }
     /**
@@ -206,8 +239,17 @@ export class Statement {
      * ```
      */
     async *iterate(args, queryOptions) {
+        // Shared-connection statements must not hold the connection lock across
+        // `yield` points, or nested queries in the loop body can deadlock.
+        if (this.execLock) {
+            const rows = await this.all(args, queryOptions);
+            for (const row of rows) {
+                yield row;
+            }
+            return;
+        }
         const normalizedArgs = this.normalizeArgs(args);
-        const { response, entries } = await this.session.executeRaw(this.sql, normalizedArgs, queryOptions);
+        const { entries } = await this.session.executeRaw(this.sql, normalizedArgs, queryOptions);
         let columns = [];
         for await (const entry of entries) {
             switch (entry.type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tursodatabase/serverless",
-  "version": "1.1.0-pre.1",
+  "version": "1.1.0-pre.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",