@tursodatabase/serverless 1.1.2-pre.1 → 1.1.3

package/dist/compat/index.cjs

@@ -28,7 +28,7 @@ function encodeValue(value) {
     if (!Number.isFinite(value)) {
       throw new Error("Only finite numbers (not Infinity or NaN) can be passed as arguments");
     }
-    if (Number.isInteger(value)) {
+    if (Number.isSafeInteger(value)) {
       return { type: "integer", value: value.toString() };
     }
     return { type: "float", value };

package/dist/compat/index.js

@@ -26,7 +26,7 @@ function encodeValue(value) {
     if (!Number.isFinite(value)) {
       throw new Error("Only finite numbers (not Infinity or NaN) can be passed as arguments");
     }
-    if (Number.isInteger(value)) {
+    if (Number.isSafeInteger(value)) {
       return { type: "integer", value: value.toString() };
     }
     return { type: "float", value };

package/dist/index.cjs

@@ -53,7 +53,7 @@ function encodeValue(value) {
     if (!Number.isFinite(value)) {
       throw new Error("Only finite numbers (not Infinity or NaN) can be passed as arguments");
     }
-    if (Number.isInteger(value)) {
+    if (Number.isSafeInteger(value)) {
       return { type: "integer", value: value.toString() };
     }
     return { type: "float", value };
@@ -547,6 +547,37 @@ var Session = class {
   }
 };
 
+// src/args.ts
+function normalizeArgs(args) {
+  if (args === void 0) return [];
+  if (Array.isArray(args)) return args;
+  if (args !== null && typeof args === "object" && args.constructor === Object) {
+    return args;
+  }
+  return [args];
+}
+function isQueryOptions(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, "queryTimeout");
+}
+function splitBindParameters(bindParameters) {
+  if (bindParameters.length === 0) {
+    return { params: void 0, queryOptions: void 0 };
+  }
+  if (isQueryOptions(bindParameters[bindParameters.length - 1])) {
+    if (bindParameters.length === 1) {
+      return { params: void 0, queryOptions: bindParameters[0] };
+    }
+    return {
+      params: bindParameters.length === 2 ? bindParameters[0] : bindParameters.slice(0, -1),
+      queryOptions: bindParameters[bindParameters.length - 1]
+    };
+  }
+  return {
+    params: bindParameters.length === 1 ? bindParameters[0] : bindParameters,
+    queryOptions: void 0
+  };
+}
+
 // src/statement.ts
 var Statement = class _Statement {
   constructor(sessionConfig, sql, columns) {
@@ -678,7 +709,7 @@ var Statement = class _Statement {
    */
   async run(args, queryOptions) {
     return await this.withLock(async () => {
-      const normalizedArgs = this.normalizeArgs(args);
+      const normalizedArgs = normalizeArgs(args);
       const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
       return { changes: result.rowsAffected, lastInsertRowid: result.lastInsertRowid };
     });
@@ -700,7 +731,7 @@ var Statement = class _Statement {
    */
   async get(args, queryOptions) {
     return await this.withLock(async () => {
-      const normalizedArgs = this.normalizeArgs(args);
+      const normalizedArgs = normalizeArgs(args);
       const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
       const row = result.rows[0];
       if (!row) {
@@ -734,7 +765,7 @@ var Statement = class _Statement {
    */
   async all(args, queryOptions) {
     return await this.withLock(async () => {
-      const normalizedArgs = this.normalizeArgs(args);
+      const normalizedArgs = normalizeArgs(args);
       const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
       if (this.presentationMode === "pluck") {
         return result.rows.map((row) => row[0]);
@@ -777,7 +808,7 @@ var Statement = class _Statement {
       }
       return;
     }
-    const normalizedArgs = this.normalizeArgs(args);
+    const normalizedArgs = normalizeArgs(args);
     const { entries } = await this.session.executeRaw(this.sql, normalizedArgs, queryOptions);
     let columns = [];
     for await (const entry of entries) {
@@ -809,22 +840,6 @@ var Statement = class _Statement {
       }
     }
   }
-  /**
-   * Normalize arguments to handle both single values and arrays.
-   * Matches the behavior of the native bindings.
-   */
-  normalizeArgs(args) {
-    if (args === void 0) {
-      return [];
-    }
-    if (Array.isArray(args)) {
-      return args;
-    }
-    if (args !== null && typeof args === "object" && args.constructor === Object) {
-      return args;
-    }
-    return [args];
-  }
 };
 
 // src/connection.ts
@@ -870,22 +885,89 @@ var Connection = class {
     if (!this.isOpen) {
       throw new TypeError("The database connection is not open");
     }
-    const session = new Session(this.config);
-    const description = await session.describe(sql);
-    await session.close();
+    await this.execLock.acquire();
+    let description;
+    try {
+      description = await this.session.describe(sql);
+    } finally {
+      this.execLock.release();
+    }
     const stmt = Statement.fromSession(this.session, sql, description.cols, this.execLock);
     if (this.defaultSafeIntegerMode) {
       stmt.safeIntegers(true);
     }
     return stmt;
   }
+  /**
+   * Like `prepare(sql).run(args)` but in a single round trip — skips `describe`
+   * since run() does not need column metadata.
+   */
+  async run(sql, ...bindParameters) {
+    if (!this.isOpen) throw new TypeError("The database connection is not open");
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    await this.execLock.acquire();
+    try {
+      const result = await this.session.execute(sql, normalizeArgs(params), this.defaultSafeIntegerMode, queryOptions);
+      return { changes: result.rowsAffected, lastInsertRowid: result.lastInsertRowid };
+    } finally {
+      this.execLock.release();
+    }
+  }
+  /**
+   * Like `prepare(sql).get(args)` but in a single round trip.
+   */
+  async get(sql, ...bindParameters) {
+    if (!this.isOpen) throw new TypeError("The database connection is not open");
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    await this.execLock.acquire();
+    try {
+      const result = await this.session.execute(sql, normalizeArgs(params), this.defaultSafeIntegerMode, queryOptions);
+      const row = result.rows[0];
+      if (!row) return void 0;
+      const obj = {};
+      result.columns.forEach((col, i) => {
+        obj[col] = row[i];
+      });
+      return obj;
+    } finally {
+      this.execLock.release();
+    }
+  }
+  /**
+   * Like `prepare(sql).all(args)` but in a single round trip.
+   */
+  async all(sql, ...bindParameters) {
+    if (!this.isOpen) throw new TypeError("The database connection is not open");
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    await this.execLock.acquire();
+    try {
+      const result = await this.session.execute(sql, normalizeArgs(params), this.defaultSafeIntegerMode, queryOptions);
+      return result.rows.map((row) => {
+        const obj = {};
+        result.columns.forEach((col, i) => {
+          obj[col] = row[i];
+        });
+        return obj;
+      });
+    } finally {
+      this.execLock.release();
+    }
+  }
+  /**
+   * Like `prepare(sql).iterate(args)` but in a single round trip. Buffers the
+   * result set — the connection lock cannot be held across `yield` points
+   * without risking deadlock on nested calls.
+   */
+  async *iterate(sql, ...bindParameters) {
+    for (const row of await this.all(sql, ...bindParameters)) yield row;
+  }
   /**
    * Execute a SQL statement and return all results.
-   * 
+   *
    * @param sql - The SQL statement to execute
    * @param args - Optional array of parameter values
    * @returns Promise resolving to the complete result set
-   * 
+   *
    * @example
    * ```typescript
    * const result = await client.execute("SELECT * FROM users WHERE id = ?", [123]);

package/dist/index.d.cts

@@ -291,11 +291,6 @@ declare class Statement {
      * ```
      */
     iterate(args?: any, queryOptions?: QueryOptions): AsyncGenerator<any>;
-    /**
-     * Normalize arguments to handle both single values and arrays.
-     * Matches the behavior of the native bindings.
-     */
-    private normalizeArgs;
 }
 
 /**
@@ -376,6 +371,25 @@ declare class Connection {
      * ```
      */
     prepare(sql: string): Promise<Statement>;
+    /**
+     * Like `prepare(sql).run(args)` but in a single round trip — skips `describe`
+     * since run() does not need column metadata.
+     */
+    run(sql: string, ...bindParameters: any[]): Promise<any>;
+    /**
+     * Like `prepare(sql).get(args)` but in a single round trip.
+     */
+    get(sql: string, ...bindParameters: any[]): Promise<any>;
+    /**
+     * Like `prepare(sql).all(args)` but in a single round trip.
+     */
+    all(sql: string, ...bindParameters: any[]): Promise<any[]>;
+    /**
+     * Like `prepare(sql).iterate(args)` but in a single round trip. Buffers the
+     * result set — the connection lock cannot be held across `yield` points
+     * without risking deadlock on nested calls.
+     */
+    iterate(sql: string, ...bindParameters: any[]): AsyncGenerator<any>;
     /**
      * Execute a SQL statement and return all results.
      *

package/dist/index.d.ts

@@ -291,11 +291,6 @@ declare class Statement {
      * ```
      */
     iterate(args?: any, queryOptions?: QueryOptions): AsyncGenerator<any>;
-    /**
-     * Normalize arguments to handle both single values and arrays.
-     * Matches the behavior of the native bindings.
-     */
-    private normalizeArgs;
 }
 
 /**
@@ -376,6 +371,25 @@ declare class Connection {
      * ```
      */
     prepare(sql: string): Promise<Statement>;
+    /**
+     * Like `prepare(sql).run(args)` but in a single round trip — skips `describe`
+     * since run() does not need column metadata.
+     */
+    run(sql: string, ...bindParameters: any[]): Promise<any>;
+    /**
+     * Like `prepare(sql).get(args)` but in a single round trip.
+     */
+    get(sql: string, ...bindParameters: any[]): Promise<any>;
+    /**
+     * Like `prepare(sql).all(args)` but in a single round trip.
+     */
+    all(sql: string, ...bindParameters: any[]): Promise<any[]>;
+    /**
+     * Like `prepare(sql).iterate(args)` but in a single round trip. Buffers the
+     * result set — the connection lock cannot be held across `yield` points
+     * without risking deadlock on nested calls.
+     */
+    iterate(sql: string, ...bindParameters: any[]): AsyncGenerator<any>;
     /**
      * Execute a SQL statement and return all results.
      *

package/dist/index.js

@@ -51,7 +51,7 @@ function encodeValue(value) {
     if (!Number.isFinite(value)) {
       throw new Error("Only finite numbers (not Infinity or NaN) can be passed as arguments");
     }
-    if (Number.isInteger(value)) {
+    if (Number.isSafeInteger(value)) {
       return { type: "integer", value: value.toString() };
     }
     return { type: "float", value };
@@ -545,6 +545,37 @@ var Session = class {
   }
 };
 
+// src/args.ts
+function normalizeArgs(args) {
+  if (args === void 0) return [];
+  if (Array.isArray(args)) return args;
+  if (args !== null && typeof args === "object" && args.constructor === Object) {
+    return args;
+  }
+  return [args];
+}
+function isQueryOptions(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, "queryTimeout");
+}
+function splitBindParameters(bindParameters) {
+  if (bindParameters.length === 0) {
+    return { params: void 0, queryOptions: void 0 };
+  }
+  if (isQueryOptions(bindParameters[bindParameters.length - 1])) {
+    if (bindParameters.length === 1) {
+      return { params: void 0, queryOptions: bindParameters[0] };
+    }
+    return {
+      params: bindParameters.length === 2 ? bindParameters[0] : bindParameters.slice(0, -1),
+      queryOptions: bindParameters[bindParameters.length - 1]
+    };
+  }
+  return {
+    params: bindParameters.length === 1 ? bindParameters[0] : bindParameters,
+    queryOptions: void 0
+  };
+}
+
 // src/statement.ts
 var Statement = class _Statement {
   constructor(sessionConfig, sql, columns) {
@@ -676,7 +707,7 @@ var Statement = class _Statement {
    */
   async run(args, queryOptions) {
     return await this.withLock(async () => {
-      const normalizedArgs = this.normalizeArgs(args);
+      const normalizedArgs = normalizeArgs(args);
       const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
       return { changes: result.rowsAffected, lastInsertRowid: result.lastInsertRowid };
     });
@@ -698,7 +729,7 @@ var Statement = class _Statement {
    */
   async get(args, queryOptions) {
     return await this.withLock(async () => {
-      const normalizedArgs = this.normalizeArgs(args);
+      const normalizedArgs = normalizeArgs(args);
       const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
       const row = result.rows[0];
       if (!row) {
@@ -732,7 +763,7 @@ var Statement = class _Statement {
    */
   async all(args, queryOptions) {
     return await this.withLock(async () => {
-      const normalizedArgs = this.normalizeArgs(args);
+      const normalizedArgs = normalizeArgs(args);
       const result = await this.session.execute(this.sql, normalizedArgs, this.safeIntegerMode, queryOptions);
       if (this.presentationMode === "pluck") {
         return result.rows.map((row) => row[0]);
@@ -775,7 +806,7 @@ var Statement = class _Statement {
       }
       return;
     }
-    const normalizedArgs = this.normalizeArgs(args);
+    const normalizedArgs = normalizeArgs(args);
     const { entries } = await this.session.executeRaw(this.sql, normalizedArgs, queryOptions);
     let columns = [];
     for await (const entry of entries) {
@@ -807,22 +838,6 @@ var Statement = class _Statement {
       }
     }
   }
-  /**
-   * Normalize arguments to handle both single values and arrays.
-   * Matches the behavior of the native bindings.
-   */
-  normalizeArgs(args) {
-    if (args === void 0) {
-      return [];
-    }
-    if (Array.isArray(args)) {
-      return args;
-    }
-    if (args !== null && typeof args === "object" && args.constructor === Object) {
-      return args;
-    }
-    return [args];
-  }
 };
 
 // src/connection.ts
@@ -868,22 +883,89 @@ var Connection = class {
     if (!this.isOpen) {
       throw new TypeError("The database connection is not open");
     }
-    const session = new Session(this.config);
-    const description = await session.describe(sql);
-    await session.close();
+    await this.execLock.acquire();
+    let description;
+    try {
+      description = await this.session.describe(sql);
+    } finally {
+      this.execLock.release();
+    }
     const stmt = Statement.fromSession(this.session, sql, description.cols, this.execLock);
     if (this.defaultSafeIntegerMode) {
       stmt.safeIntegers(true);
     }
     return stmt;
   }
+  /**
+   * Like `prepare(sql).run(args)` but in a single round trip — skips `describe`
+   * since run() does not need column metadata.
+   */
+  async run(sql, ...bindParameters) {
+    if (!this.isOpen) throw new TypeError("The database connection is not open");
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    await this.execLock.acquire();
+    try {
+      const result = await this.session.execute(sql, normalizeArgs(params), this.defaultSafeIntegerMode, queryOptions);
+      return { changes: result.rowsAffected, lastInsertRowid: result.lastInsertRowid };
+    } finally {
+      this.execLock.release();
+    }
+  }
+  /**
+   * Like `prepare(sql).get(args)` but in a single round trip.
+   */
+  async get(sql, ...bindParameters) {
+    if (!this.isOpen) throw new TypeError("The database connection is not open");
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    await this.execLock.acquire();
+    try {
+      const result = await this.session.execute(sql, normalizeArgs(params), this.defaultSafeIntegerMode, queryOptions);
+      const row = result.rows[0];
+      if (!row) return void 0;
+      const obj = {};
+      result.columns.forEach((col, i) => {
+        obj[col] = row[i];
+      });
+      return obj;
+    } finally {
+      this.execLock.release();
+    }
+  }
+  /**
+   * Like `prepare(sql).all(args)` but in a single round trip.
+   */
+  async all(sql, ...bindParameters) {
+    if (!this.isOpen) throw new TypeError("The database connection is not open");
+    const { params, queryOptions } = splitBindParameters(bindParameters);
+    await this.execLock.acquire();
+    try {
+      const result = await this.session.execute(sql, normalizeArgs(params), this.defaultSafeIntegerMode, queryOptions);
+      return result.rows.map((row) => {
+        const obj = {};
+        result.columns.forEach((col, i) => {
+          obj[col] = row[i];
+        });
+        return obj;
+      });
+    } finally {
+      this.execLock.release();
+    }
+  }
+  /**
+   * Like `prepare(sql).iterate(args)` but in a single round trip. Buffers the
+   * result set — the connection lock cannot be held across `yield` points
+   * without risking deadlock on nested calls.
+   */
+  async *iterate(sql, ...bindParameters) {
+    for (const row of await this.all(sql, ...bindParameters)) yield row;
+  }
   /**
    * Execute a SQL statement and return all results.
-   * 
+   *
    * @param sql - The SQL statement to execute
    * @param args - Optional array of parameter values
    * @returns Promise resolving to the complete result set
-   * 
+   *
    * @example
    * ```typescript
    * const result = await client.execute("SELECT * FROM users WHERE id = ?", [123]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tursodatabase/serverless",
-  "version": "1.1.2-pre.1",
+  "version": "1.1.3",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",