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

package/README.md

@@ -60,6 +60,14 @@ await conn.batch([
   "INSERT INTO users (email) VALUES ('user@example.com')",
   "INSERT INTO users (email) VALUES ('admin@example.com')",
 ]);
+
+// Parameterized batch statements also work
+await conn.transaction(async () => {
+  await conn.batch([
+    { sql: "INSERT INTO users (email) VALUES (?)", args: ["alice@example.com"] },
+    { sql: "INSERT INTO users (email) VALUES (?)", args: ["bob@example.com"] },
+  ]);
+}).concurrent();
 ```
 
 ### libSQL Compatibility Layer

package/dist/compat/index.cjs

@@ -212,6 +212,38 @@ async function executePipeline(url, authToken, request, remoteEncryptionKey, sig
   return response.json();
 }
 
+// src/args.ts
+function encodeSqlArgs(args = []) {
+  let positionalArgs = [];
+  let namedArgs = [];
+  if (Array.isArray(args)) {
+    positionalArgs = args.map(encodeValue);
+  } else {
+    const keys = Object.keys(args);
+    const isNumericKeys = keys.length > 0 && keys.every((key) => /^\d+$/.test(key));
+    if (isNumericKeys) {
+      const sortedKeys = keys.sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+      const maxIndex = parseInt(sortedKeys[sortedKeys.length - 1], 10);
+      positionalArgs = new Array(maxIndex);
+      for (const key of sortedKeys) {
+        const index = parseInt(key, 10) - 1;
+        positionalArgs[index] = encodeValue(args[key]);
+      }
+      for (let i = 0; i < positionalArgs.length; i++) {
+        if (positionalArgs[i] === void 0) {
+          positionalArgs[i] = { type: "null" };
+        }
+      }
+    } else {
+      namedArgs = Object.entries(args).map(([name, value]) => ({
+        name,
+        value: encodeValue(value)
+      }));
+    }
+  }
+  return { args: positionalArgs, namedArgs };
+}
+
 // src/session.ts
 function normalizeUrl(url) {
   return url.replace(/^libsql:\/\//, "https://");
@@ -289,41 +321,15 @@ var Session = class {
    * @returns Promise resolving to the raw response and cursor entries
    */
   async executeRaw(sql, args = [], queryOptions) {
-    let positionalArgs = [];
-    let namedArgs = [];
-    if (Array.isArray(args)) {
-      positionalArgs = args.map(encodeValue);
-    } else {
-      const keys = Object.keys(args);
-      const isNumericKeys = keys.length > 0 && keys.every((key) => /^\d+$/.test(key));
-      if (isNumericKeys) {
-        const sortedKeys = keys.sort((a, b) => parseInt(a) - parseInt(b));
-        const maxIndex = parseInt(sortedKeys[sortedKeys.length - 1]);
-        positionalArgs = new Array(maxIndex);
-        for (const key of sortedKeys) {
-          const index = parseInt(key) - 1;
-          positionalArgs[index] = encodeValue(args[key]);
-        }
-        for (let i = 0; i < positionalArgs.length; i++) {
-          if (positionalArgs[i] === void 0) {
-            positionalArgs[i] = { type: "null" };
-          }
-        }
-      } else {
-        namedArgs = Object.entries(args).map(([name, value]) => ({
-          name,
-          value: encodeValue(value)
-        }));
-      }
-    }
+    const encodedArgs = encodeSqlArgs(args);
     const request = {
       baton: this.baton,
       batch: {
         steps: [{
           stmt: {
             sql,
-            args: positionalArgs,
-            named_args: namedArgs,
+            args: encodedArgs.args,
+            named_args: encodedArgs.namedArgs,
             want_rows: true
           }
         }]
@@ -414,23 +420,76 @@ var Session = class {
   }
   /**
    * Execute multiple SQL statements in a batch.
-   * 
-   * @param statements - Array of SQL statements to execute
-   * @returns Promise resolving to batch execution results
+   *
+   * When `mode` is set, the batch is sent as a single Hrana request that
+   * also carries `BEGIN <mode>` / `COMMIT` / `ROLLBACK` steps using the
+   * server-side condition chain, giving atomic execution in one round-trip.
+   * When `mode` is omitted, the user statements are sent as-is and run
+   * under autocommit (or whatever transaction is already active on this
+   * stream).
+   *
+   * @param statements - Array of SQL statements to execute.
+   * @param mode - Optional locking mode; when set, the batch executes
+   *   atomically. Accepts the same values as `Database.transaction(...)`
+   *   variants: `"deferred"`, `"immediate"`, `"exclusive"`, `"concurrent"`.
+   * @returns Promise resolving to batch execution results.
    */
-  async batch(statements, queryOptions) {
+  async batch(statements, mode, queryOptions) {
+    const userSteps = statements.map((statement) => {
+      if (typeof statement === "string") {
+        return {
+          stmt: { sql: statement, args: [], named_args: [], want_rows: false }
+        };
+      }
+      const encodedArgs = encodeSqlArgs(statement.args ?? []);
+      return {
+        stmt: {
+          sql: statement.sql,
+          args: encodedArgs.args,
+          named_args: encodedArgs.namedArgs,
+          want_rows: false
+        }
+      };
+    });
+    let steps;
+    let firstUserStepIdx = 0;
+    let lastUserStepIdx = userSteps.length - 1;
+    let beginIdx = -1;
+    let commitIdx = -1;
+    let rollbackIdx = -1;
+    if (mode === void 0) {
+      steps = userSteps;
+    } else {
+      beginIdx = 0;
+      firstUserStepIdx = 1;
+      lastUserStepIdx = userSteps.length;
+      commitIdx = lastUserStepIdx + 1;
+      rollbackIdx = commitIdx + 1;
+      steps = [
+        { stmt: { sql: `BEGIN ${mode.toUpperCase()}`, args: [], named_args: [], want_rows: false } },
+        ...userSteps.map((step, i) => ({
+          ...step,
+          condition: { type: "ok", step: i === 0 ? beginIdx : firstUserStepIdx + i - 1 }
+        })),
+        {
+          stmt: { sql: "COMMIT", args: [], named_args: [], want_rows: false },
+          condition: { type: "ok", step: lastUserStepIdx }
+        },
+        {
+          stmt: { sql: "ROLLBACK", args: [], named_args: [], want_rows: false },
+          condition: {
+            type: "and",
+            conds: [
+              { type: "ok", step: beginIdx },
+              { type: "not", cond: { type: "ok", step: commitIdx } }
+            ]
+          }
+        }
+      ];
+    }
     const request = {
       baton: this.baton,
-      batch: {
-        steps: statements.map((sql) => ({
-          stmt: {
-            sql,
-            args: [],
-            named_args: [],
-            want_rows: false
-          }
-        }))
-      }
+      batch: { steps }
     };
     let batchResult;
     try {
@@ -446,21 +505,46 @@ var Session = class {
     }
     let totalRowsAffected = 0;
     let lastInsertRowid;
+    let deferredError = null;
+    let currentStep;
+    const isUserStep = (step) => {
+      if (mode === void 0) {
+        return true;
+      }
+      return step !== void 0 && step >= firstUserStepIdx && step <= lastUserStepIdx;
+    };
     for await (const entry of entries) {
       switch (entry.type) {
+        case "step_begin":
+          currentStep = entry.step;
+          break;
         case "step_end":
-          if (entry.affected_row_count !== void 0) {
-            totalRowsAffected += entry.affected_row_count;
-          }
-          if (entry.last_insert_rowid !== void 0 && entry.last_insert_rowid !== null) {
-            lastInsertRowid = typeof entry.last_insert_rowid === "number" ? entry.last_insert_rowid : parseInt(entry.last_insert_rowid, 10);
+          if (isUserStep(currentStep)) {
+            if (entry.affected_row_count !== void 0) {
+              totalRowsAffected += entry.affected_row_count;
+            }
+            if (entry.last_insert_rowid !== void 0 && entry.last_insert_rowid !== null) {
+              lastInsertRowid = typeof entry.last_insert_rowid === "number" ? entry.last_insert_rowid : parseInt(entry.last_insert_rowid, 10);
+            }
           }
+          currentStep = void 0;
           break;
         case "step_error":
+          if (mode === void 0) {
+            throw new DatabaseError(entry.error?.message || "Batch execution failed", entry.error?.code);
+          }
+          if (deferredError === null && entry.step !== rollbackIdx) {
+            deferredError = new DatabaseError(entry.error?.message || "Batch execution failed", entry.error?.code);
+          }
+          currentStep = void 0;
+          break;
         case "error":
           throw new DatabaseError(entry.error?.message || "Batch execution failed", entry.error?.code);
       }
     }
+    if (deferredError !== null) {
+      throw deferredError;
+    }
     return {
       rowsAffected: totalRowsAffected,
       lastInsertRowid

package/dist/compat/index.js

@@ -210,6 +210,38 @@ async function executePipeline(url, authToken, request, remoteEncryptionKey, sig
   return response.json();
 }
 
+// src/args.ts
+function encodeSqlArgs(args = []) {
+  let positionalArgs = [];
+  let namedArgs = [];
+  if (Array.isArray(args)) {
+    positionalArgs = args.map(encodeValue);
+  } else {
+    const keys = Object.keys(args);
+    const isNumericKeys = keys.length > 0 && keys.every((key) => /^\d+$/.test(key));
+    if (isNumericKeys) {
+      const sortedKeys = keys.sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+      const maxIndex = parseInt(sortedKeys[sortedKeys.length - 1], 10);
+      positionalArgs = new Array(maxIndex);
+      for (const key of sortedKeys) {
+        const index = parseInt(key, 10) - 1;
+        positionalArgs[index] = encodeValue(args[key]);
+      }
+      for (let i = 0; i < positionalArgs.length; i++) {
+        if (positionalArgs[i] === void 0) {
+          positionalArgs[i] = { type: "null" };
+        }
+      }
+    } else {
+      namedArgs = Object.entries(args).map(([name, value]) => ({
+        name,
+        value: encodeValue(value)
+      }));
+    }
+  }
+  return { args: positionalArgs, namedArgs };
+}
+
 // src/session.ts
 function normalizeUrl(url) {
   return url.replace(/^libsql:\/\//, "https://");
@@ -287,41 +319,15 @@ var Session = class {
    * @returns Promise resolving to the raw response and cursor entries
    */
   async executeRaw(sql, args = [], queryOptions) {
-    let positionalArgs = [];
-    let namedArgs = [];
-    if (Array.isArray(args)) {
-      positionalArgs = args.map(encodeValue);
-    } else {
-      const keys = Object.keys(args);
-      const isNumericKeys = keys.length > 0 && keys.every((key) => /^\d+$/.test(key));
-      if (isNumericKeys) {
-        const sortedKeys = keys.sort((a, b) => parseInt(a) - parseInt(b));
-        const maxIndex = parseInt(sortedKeys[sortedKeys.length - 1]);
-        positionalArgs = new Array(maxIndex);
-        for (const key of sortedKeys) {
-          const index = parseInt(key) - 1;
-          positionalArgs[index] = encodeValue(args[key]);
-        }
-        for (let i = 0; i < positionalArgs.length; i++) {
-          if (positionalArgs[i] === void 0) {
-            positionalArgs[i] = { type: "null" };
-          }
-        }
-      } else {
-        namedArgs = Object.entries(args).map(([name, value]) => ({
-          name,
-          value: encodeValue(value)
-        }));
-      }
-    }
+    const encodedArgs = encodeSqlArgs(args);
     const request = {
       baton: this.baton,
       batch: {
         steps: [{
           stmt: {
             sql,
-            args: positionalArgs,
-            named_args: namedArgs,
+            args: encodedArgs.args,
+            named_args: encodedArgs.namedArgs,
             want_rows: true
           }
         }]
@@ -412,23 +418,76 @@ var Session = class {
   }
   /**
    * Execute multiple SQL statements in a batch.
-   * 
-   * @param statements - Array of SQL statements to execute
-   * @returns Promise resolving to batch execution results
+   *
+   * When `mode` is set, the batch is sent as a single Hrana request that
+   * also carries `BEGIN <mode>` / `COMMIT` / `ROLLBACK` steps using the
+   * server-side condition chain, giving atomic execution in one round-trip.
+   * When `mode` is omitted, the user statements are sent as-is and run
+   * under autocommit (or whatever transaction is already active on this
+   * stream).
+   *
+   * @param statements - Array of SQL statements to execute.
+   * @param mode - Optional locking mode; when set, the batch executes
+   *   atomically. Accepts the same values as `Database.transaction(...)`
+   *   variants: `"deferred"`, `"immediate"`, `"exclusive"`, `"concurrent"`.
+   * @returns Promise resolving to batch execution results.
    */
-  async batch(statements, queryOptions) {
+  async batch(statements, mode, queryOptions) {
+    const userSteps = statements.map((statement) => {
+      if (typeof statement === "string") {
+        return {
+          stmt: { sql: statement, args: [], named_args: [], want_rows: false }
+        };
+      }
+      const encodedArgs = encodeSqlArgs(statement.args ?? []);
+      return {
+        stmt: {
+          sql: statement.sql,
+          args: encodedArgs.args,
+          named_args: encodedArgs.namedArgs,
+          want_rows: false
+        }
+      };
+    });
+    let steps;
+    let firstUserStepIdx = 0;
+    let lastUserStepIdx = userSteps.length - 1;
+    let beginIdx = -1;
+    let commitIdx = -1;
+    let rollbackIdx = -1;
+    if (mode === void 0) {
+      steps = userSteps;
+    } else {
+      beginIdx = 0;
+      firstUserStepIdx = 1;
+      lastUserStepIdx = userSteps.length;
+      commitIdx = lastUserStepIdx + 1;
+      rollbackIdx = commitIdx + 1;
+      steps = [
+        { stmt: { sql: `BEGIN ${mode.toUpperCase()}`, args: [], named_args: [], want_rows: false } },
+        ...userSteps.map((step, i) => ({
+          ...step,
+          condition: { type: "ok", step: i === 0 ? beginIdx : firstUserStepIdx + i - 1 }
+        })),
+        {
+          stmt: { sql: "COMMIT", args: [], named_args: [], want_rows: false },
+          condition: { type: "ok", step: lastUserStepIdx }
+        },
+        {
+          stmt: { sql: "ROLLBACK", args: [], named_args: [], want_rows: false },
+          condition: {
+            type: "and",
+            conds: [
+              { type: "ok", step: beginIdx },
+              { type: "not", cond: { type: "ok", step: commitIdx } }
+            ]
+          }
+        }
+      ];
+    }
     const request = {
       baton: this.baton,
-      batch: {
-        steps: statements.map((sql) => ({
-          stmt: {
-            sql,
-            args: [],
-            named_args: [],
-            want_rows: false
-          }
-        }))
-      }
+      batch: { steps }
     };
     let batchResult;
     try {
@@ -444,21 +503,46 @@ var Session = class {
     }
     let totalRowsAffected = 0;
     let lastInsertRowid;
+    let deferredError = null;
+    let currentStep;
+    const isUserStep = (step) => {
+      if (mode === void 0) {
+        return true;
+      }
+      return step !== void 0 && step >= firstUserStepIdx && step <= lastUserStepIdx;
+    };
     for await (const entry of entries) {
       switch (entry.type) {
+        case "step_begin":
+          currentStep = entry.step;
+          break;
         case "step_end":
-          if (entry.affected_row_count !== void 0) {
-            totalRowsAffected += entry.affected_row_count;
-          }
-          if (entry.last_insert_rowid !== void 0 && entry.last_insert_rowid !== null) {
-            lastInsertRowid = typeof entry.last_insert_rowid === "number" ? entry.last_insert_rowid : parseInt(entry.last_insert_rowid, 10);
+          if (isUserStep(currentStep)) {
+            if (entry.affected_row_count !== void 0) {
+              totalRowsAffected += entry.affected_row_count;
+            }
+            if (entry.last_insert_rowid !== void 0 && entry.last_insert_rowid !== null) {
+              lastInsertRowid = typeof entry.last_insert_rowid === "number" ? entry.last_insert_rowid : parseInt(entry.last_insert_rowid, 10);
+            }
           }
+          currentStep = void 0;
           break;
         case "step_error":
+          if (mode === void 0) {
+            throw new DatabaseError(entry.error?.message || "Batch execution failed", entry.error?.code);
+          }
+          if (deferredError === null && entry.step !== rollbackIdx) {
+            deferredError = new DatabaseError(entry.error?.message || "Batch execution failed", entry.error?.code);
+          }
+          currentStep = void 0;
+          break;
         case "error":
           throw new DatabaseError(entry.error?.message || "Batch execution failed", entry.error?.code);
       }
     }
+    if (deferredError !== null) {
+      throw deferredError;
+    }
     return {
       rowsAffected: totalRowsAffected,
       lastInsertRowid