libsql-client: Report batch statement index on error

If a batch statement fails, the SQL over HTTP protocol does report back
exactly what step failed. However, we also need to propagate that
information to the caller.

Author: penberg

packages/libsql-client/src/hrana.ts

@@ -134,16 +134,28 @@ export abstract class HranaTransaction implements Transaction {
             }
 
             const resultSets = [];
-            for (const rowsPromise of rowsPromises) {
-                const rows = await rowsPromise;
-                if (rows === undefined) {
-                    throw new LibsqlError(
-                        "Statement in a transaction was not executed, " +
-                            "probably because the transaction has been rolled back",
-                        "TRANSACTION_CLOSED",
-                    );
+            for (let i = 0; i < rowsPromises.length; i++) {
+                try {
+                    const rows = await rowsPromises[i];
+                    if (rows === undefined) {
+                        throw new LibsqlError(
+                            `Statement at index ${i} in a transaction was not executed, ` +
+                                "probably because the transaction has been rolled back",
+                            "TRANSACTION_CLOSED",
+                        );
+                    }
+                    resultSets.push(resultSetFromHrana(rows));
+                } catch (e) {
+                    if (e instanceof LibsqlError) {
+                        throw new LibsqlError(
+                            `Statement at index ${i} failed: ${e.message}`,
+                            e.code,
+                            e.rawCode,
+                            e.cause,
+                        );
+                    }
+                    throw e;
                 }
-                resultSets.push(resultSetFromHrana(rows));
             }
             return resultSets;
         } catch (e) {
@@ -295,15 +307,27 @@ export async function executeHranaBatch(
 
     const resultSets = [];
     await beginPromise;
-    for (const stmtPromise of stmtPromises) {
-        const hranaRows = await stmtPromise;
-        if (hranaRows === undefined) {
-            throw new LibsqlError(
-                "Statement in a batch was not executed, probably because the transaction has been rolled back",
-                "TRANSACTION_CLOSED",
-            );
+    for (let i = 0; i < stmtPromises.length; i++) {
+        try {
+            const hranaRows = await stmtPromises[i];
+            if (hranaRows === undefined) {
+                throw new LibsqlError(
+                    `Statement at index ${i} in a batch was not executed, probably because the transaction has been rolled back`,
+                    "TRANSACTION_CLOSED",
+                );
+            }
+            resultSets.push(resultSetFromHrana(hranaRows));
+        } catch (e) {
+            if (e instanceof LibsqlError) {
+                throw new LibsqlError(
+                    `Statement at index ${i} failed: ${e.message}`,
+                    e.code,
+                    e.rawCode,
+                    e.cause,
+                );
+            }
+            throw e;
         }
-        resultSets.push(resultSetFromHrana(hranaRows));
     }
     await commitPromise;
 

packages/libsql-client/src/sqlite3.ts

@@ -148,18 +148,33 @@ export class Sqlite3Client implements Client {
         const db = this.#getDb();
         try {
             executeStmt(db, transactionModeToBegin(mode), this.#intMode);
-            const resultSets = stmts.map((stmt) => {
-                if (!db.inTransaction) {
-                    throw new LibsqlError(
-                        "The transaction has been rolled back",
-                        "TRANSACTION_CLOSED",
+            const resultSets = [];
+            for (let i = 0; i < stmts.length; i++) {
+                try {
+                    if (!db.inTransaction) {
+                        throw new LibsqlError(
+                            `Statement at index ${i}: The transaction has been rolled back`,
+                            "TRANSACTION_CLOSED",
+                        );
+                    }
+                    const normalizedStmt: InStatement = Array.isArray(stmts[i])
+                        ? { sql: stmts[i][0], args: stmts[i][1] || [] }
+                        : stmts[i];
+                    resultSets.push(
+                        executeStmt(db, normalizedStmt, this.#intMode),
                     );
+                } catch (e) {
+                    if (e instanceof LibsqlError) {
+                        throw new LibsqlError(
+                            `Statement at index ${i} failed: ${e.message}`,
+                            e.code,
+                            e.rawCode,
+                            e.cause,
+                        );
+                    }
+                    throw e;
                 }
-                const normalizedStmt: InStatement = Array.isArray(stmt)
-                    ? { sql: stmt[0], args: stmt[1] || [] }
-                    : stmt;
-                return executeStmt(db, normalizedStmt, this.#intMode);
-            });
+            }
             executeStmt(db, "COMMIT", this.#intMode);
             return resultSets;
         } finally {