@tursodatabase/serverless 1.1.1 → 1.1.2-pre.1

package/dist/compat/index.js

@@ -1 +1,882 @@
-export * from '../compat.js';
+// src/error.ts
+var DatabaseError = class _DatabaseError extends Error {
+  constructor(message, code, rawCode, cause) {
+    super(message);
+    this.name = "DatabaseError";
+    this.code = code;
+    this.rawCode = rawCode;
+    this.cause = cause;
+    Object.setPrototypeOf(this, _DatabaseError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends DatabaseError {
+  constructor(message = "Query timed out", cause) {
+    super(message, "TIMEOUT", void 0, cause);
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+
+// src/protocol.ts
+function encodeValue(value) {
+  if (value === null || value === void 0) {
+    return { type: "null" };
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Only finite numbers (not Infinity or NaN) can be passed as arguments");
+    }
+    if (Number.isInteger(value)) {
+      return { type: "integer", value: value.toString() };
+    }
+    return { type: "float", value };
+  }
+  if (typeof value === "bigint") {
+    return { type: "integer", value: value.toString() };
+  }
+  if (typeof value === "boolean") {
+    return { type: "integer", value: value ? "1" : "0" };
+  }
+  if (typeof value === "string") {
+    return { type: "text", value };
+  }
+  if (value instanceof ArrayBuffer || value instanceof Uint8Array) {
+    const base64 = btoa(String.fromCharCode(...new Uint8Array(value)));
+    return { type: "blob", base64 };
+  }
+  return { type: "text", value: String(value) };
+}
+function decodeValue(value, safeIntegers = false) {
+  switch (value.type) {
+    case "null":
+      return null;
+    case "integer":
+      if (safeIntegers) {
+        return BigInt(value.value);
+      }
+      return parseInt(value.value, 10);
+    case "float":
+      return value.value;
+    case "text":
+      return value.value;
+    case "blob":
+      if (value.base64 !== void 0 && value.base64 !== null) {
+        let b64 = value.base64;
+        while (b64.length % 4 !== 0) {
+          b64 += "=";
+        }
+        const binaryString = atob(b64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+          bytes[i] = binaryString.charCodeAt(i);
+        }
+        return Buffer.from(bytes);
+      }
+      return Buffer.alloc(0);
+    default:
+      return null;
+  }
+}
+var ENCRYPTION_KEY_HEADER = "x-turso-encryption-key";
+function wrapAbortError(error) {
+  if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) {
+    throw new TimeoutError("Query timed out");
+  }
+  throw error;
+}
+async function executeCursor(url, authToken, request, remoteEncryptionKey, signal) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (authToken) {
+    headers["Authorization"] = `Bearer ${authToken}`;
+  }
+  if (remoteEncryptionKey) {
+    headers[ENCRYPTION_KEY_HEADER] = remoteEncryptionKey;
+  }
+  let response;
+  try {
+    response = await fetch(`${url}/v3/cursor`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      signal
+    });
+  } catch (error) {
+    wrapAbortError(error);
+  }
+  if (!response.ok) {
+    let errorMessage = `HTTP error! status: ${response.status}`;
+    try {
+      const errorBody = await response.text();
+      const errorData = JSON.parse(errorBody);
+      if (errorData.message) {
+        errorMessage = errorData.message;
+      }
+    } catch {
+    }
+    throw new DatabaseError(errorMessage);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new DatabaseError("No response body");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let cursorResponse;
+  try {
+    while (!cursorResponse) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line) {
+          cursorResponse = JSON.parse(line);
+          break;
+        }
+      }
+    }
+  } catch (error) {
+    reader.releaseLock();
+    wrapAbortError(error);
+  }
+  if (!cursorResponse) {
+    reader.releaseLock();
+    throw new DatabaseError("No cursor response received");
+  }
+  async function* parseEntries() {
+    try {
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line) {
+          yield JSON.parse(line);
+        }
+      }
+      while (true) {
+        let readResult;
+        try {
+          readResult = await reader.read();
+        } catch (error) {
+          wrapAbortError(error);
+        }
+        if (readResult.done) break;
+        buffer += decoder.decode(readResult.value, { stream: true });
+        while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, newlineIndex).trim();
+          buffer = buffer.slice(newlineIndex + 1);
+          if (line) {
+            yield JSON.parse(line);
+          }
+        }
+      }
+      if (buffer.trim()) {
+        yield JSON.parse(buffer.trim());
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  return { response: cursorResponse, entries: parseEntries() };
+}
+async function executePipeline(url, authToken, request, remoteEncryptionKey, signal) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (authToken) {
+    headers["Authorization"] = `Bearer ${authToken}`;
+  }
+  if (remoteEncryptionKey) {
+    headers[ENCRYPTION_KEY_HEADER] = remoteEncryptionKey;
+  }
+  let response;
+  try {
+    response = await fetch(`${url}/v3/pipeline`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      signal
+    });
+  } catch (error) {
+    wrapAbortError(error);
+  }
+  if (!response.ok) {
+    throw new DatabaseError(`HTTP error! status: ${response.status}`);
+  }
+  return response.json();
+}
+
+// src/session.ts
+function normalizeUrl(url) {
+  return url.replace(/^libsql:\/\//, "https://");
+}
+function isValidIdentifier(str) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str);
+}
+var Session = class {
+  constructor(config) {
+    this.baton = null;
+    this.config = config;
+    this.baseUrl = normalizeUrl(config.url);
+  }
+  createAbortSignal(queryOptions) {
+    const timeout = queryOptions?.queryTimeout ?? this.config.defaultQueryTimeout;
+    if (timeout != null && timeout > 0) {
+      return AbortSignal.timeout(timeout);
+    }
+    return void 0;
+  }
+  /**
+   * Describe a SQL statement to get its column metadata.
+   * 
+   * @param sql - The SQL statement to describe
+   * @returns Promise resolving to the statement description
+   */
+  async describe(sql, queryOptions) {
+    const request = {
+      baton: this.baton,
+      requests: [{
+        type: "describe",
+        sql
+      }]
+    };
+    let response;
+    try {
+      response = await executePipeline(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey, this.createAbortSignal(queryOptions));
+    } catch (e) {
+      this.baton = null;
+      throw e;
+    }
+    this.baton = response.baton;
+    if (response.base_url) {
+      this.baseUrl = response.base_url;
+    }
+    if (response.results && response.results[0]) {
+      const result = response.results[0];
+      if (result.type === "error") {
+        throw new DatabaseError(result.error?.message || "Describe execution failed", result.error?.code);
+      }
+      if (result.response?.type === "describe" && result.response.result) {
+        return result.response.result;
+      }
+    }
+    throw new DatabaseError("Unexpected describe response");
+  }
+  /**
+   * Execute a SQL statement and return all results.
+   * 
+   * @param sql - The SQL statement to execute
+   * @param args - Optional array of parameter values or object with named parameters
+   * @param safeIntegers - Whether to return integers as BigInt
+   * @returns Promise resolving to the complete result set
+   */
+  async execute(sql, args = [], safeIntegers = false, queryOptions) {
+    const { response, entries } = await this.executeRaw(sql, args, queryOptions);
+    const result = await this.processCursorEntries(entries, safeIntegers);
+    return result;
+  }
+  /**
+   * Execute a SQL statement and return the raw response and entries.
+   * 
+   * @param sql - The SQL statement to execute
+   * @param args - Optional array of parameter values or object with named parameters
+   * @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 request = {
+      baton: this.baton,
+      batch: {
+        steps: [{
+          stmt: {
+            sql,
+            args: positionalArgs,
+            named_args: namedArgs,
+            want_rows: true
+          }
+        }]
+      }
+    };
+    let result;
+    try {
+      result = await executeCursor(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey, this.createAbortSignal(queryOptions));
+    } catch (e) {
+      this.baton = null;
+      throw e;
+    }
+    const { response, entries } = result;
+    this.baton = response.baton;
+    if (response.base_url) {
+      this.baseUrl = response.base_url;
+    }
+    return { response, entries };
+  }
+  /**
+   * Process cursor entries into a structured result.
+   *
+   * @param entries - Async generator of cursor entries
+   * @returns Promise resolving to the processed result
+   */
+  async processCursorEntries(entries, safeIntegers = false) {
+    let columns = [];
+    let columnTypes = [];
+    let rows = [];
+    let rowsAffected = 0;
+    let lastInsertRowid;
+    for await (const entry of entries) {
+      switch (entry.type) {
+        case "step_begin":
+          if (entry.cols) {
+            columns = entry.cols.map((col) => col.name);
+            columnTypes = entry.cols.map((col) => col.decltype || "");
+          }
+          break;
+        case "row":
+          if (entry.row) {
+            const decodedRow = entry.row.map((value) => decodeValue(value, safeIntegers));
+            const rowObject = this.createRowObject(decodedRow, columns);
+            rows.push(rowObject);
+          }
+          break;
+        case "step_end":
+          if (entry.affected_row_count !== void 0) {
+            rowsAffected = 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);
+          }
+          break;
+        case "step_error":
+        case "error":
+          throw new DatabaseError(entry.error?.message || "SQL execution failed", entry.error?.code);
+      }
+    }
+    return {
+      columns,
+      columnTypes,
+      rows,
+      rowsAffected,
+      lastInsertRowid
+    };
+  }
+  /**
+   * Create a row object with both array and named property access.
+   * 
+   * @param values - Array of column values
+   * @param columns - Array of column names
+   * @returns Row object with dual access patterns
+   */
+  createRowObject(values, columns) {
+    const row = [...values];
+    columns.forEach((column, index) => {
+      if (column && isValidIdentifier(column)) {
+        Object.defineProperty(row, column, {
+          value: values[index],
+          enumerable: false,
+          writable: false,
+          configurable: true
+        });
+      }
+    });
+    return row;
+  }
+  /**
+   * Execute multiple SQL statements in a batch.
+   * 
+   * @param statements - Array of SQL statements to execute
+   * @returns Promise resolving to batch execution results
+   */
+  async batch(statements, queryOptions) {
+    const request = {
+      baton: this.baton,
+      batch: {
+        steps: statements.map((sql) => ({
+          stmt: {
+            sql,
+            args: [],
+            named_args: [],
+            want_rows: false
+          }
+        }))
+      }
+    };
+    let batchResult;
+    try {
+      batchResult = await executeCursor(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey, this.createAbortSignal(queryOptions));
+    } catch (e) {
+      this.baton = null;
+      throw e;
+    }
+    const { response, entries } = batchResult;
+    this.baton = response.baton;
+    if (response.base_url) {
+      this.baseUrl = response.base_url;
+    }
+    let totalRowsAffected = 0;
+    let lastInsertRowid;
+    for await (const entry of entries) {
+      switch (entry.type) {
+        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);
+          }
+          break;
+        case "step_error":
+        case "error":
+          throw new DatabaseError(entry.error?.message || "Batch execution failed", entry.error?.code);
+      }
+    }
+    return {
+      rowsAffected: totalRowsAffected,
+      lastInsertRowid
+    };
+  }
+  /**
+   * Execute a sequence of SQL statements separated by semicolons.
+   * 
+   * @param sql - SQL string containing multiple statements separated by semicolons
+   * @returns Promise resolving when all statements are executed
+   */
+  async sequence(sql, queryOptions) {
+    const request = {
+      baton: this.baton,
+      requests: [{
+        type: "sequence",
+        sql
+      }]
+    };
+    let seqResponse;
+    try {
+      seqResponse = await executePipeline(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey, this.createAbortSignal(queryOptions));
+    } catch (e) {
+      this.baton = null;
+      throw e;
+    }
+    this.baton = seqResponse.baton;
+    if (seqResponse.base_url) {
+      this.baseUrl = seqResponse.base_url;
+    }
+    if (seqResponse.results && seqResponse.results[0]) {
+      const result = seqResponse.results[0];
+      if (result.type === "error") {
+        throw new DatabaseError(result.error?.message || "Sequence execution failed", result.error?.code);
+      }
+    }
+  }
+  /**
+   * Close the session.
+   *
+   * This sends a close request to the server to properly clean up the stream
+   * before resetting the local state.
+   */
+  async close() {
+    if (this.baton) {
+      try {
+        const request = {
+          baton: this.baton,
+          requests: [{
+            type: "close"
+          }]
+        };
+        await executePipeline(this.baseUrl, this.config.authToken, request, this.config.remoteEncryptionKey);
+      } catch {
+      }
+    }
+    this.baton = null;
+    this.baseUrl = "";
+  }
+};
+
+// src/async-lock.ts
+var AsyncLock = class {
+  constructor() {
+    this.locked = false;
+    this.queue = [];
+  }
+  async acquire() {
+    if (!this.locked) {
+      this.locked = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+};
+
+// src/compat.ts
+var LibsqlError = class extends Error {
+  constructor(message, code, extendedCode, rawCode, cause) {
+    super(message);
+    this.name = "LibsqlError";
+    this.code = code;
+    this.extendedCode = extendedCode;
+    this.rawCode = rawCode;
+    this.cause = cause;
+  }
+};
+var LibSQLClient = class {
+  constructor(config) {
+    this.execLock = new AsyncLock();
+    this._closed = false;
+    this._defaultSafeIntegers = false;
+    this.validateConfig(config);
+    const sessionConfig = {
+      url: config.url,
+      authToken: config.authToken || "",
+      remoteEncryptionKey: config.remoteEncryptionKey
+    };
+    this.sessionConfig = sessionConfig;
+    this.session = new Session(sessionConfig);
+  }
+  validateConfig(config) {
+    const unsupportedOptions = [];
+    if (config.encryptionKey !== void 0) {
+      unsupportedOptions.push({ key: "encryptionKey", value: config.encryptionKey });
+    }
+    if (config.syncUrl !== void 0) {
+      unsupportedOptions.push({ key: "syncUrl", value: config.syncUrl });
+    }
+    if (config.syncInterval !== void 0) {
+      unsupportedOptions.push({ key: "syncInterval", value: config.syncInterval });
+    }
+    if (config.readYourWrites !== void 0) {
+      unsupportedOptions.push({ key: "readYourWrites", value: config.readYourWrites });
+    }
+    if (config.offline !== void 0) {
+      unsupportedOptions.push({ key: "offline", value: config.offline });
+    }
+    if (config.tls !== void 0) {
+      unsupportedOptions.push({ key: "tls", value: config.tls });
+    }
+    if (config.intMode !== void 0) {
+      unsupportedOptions.push({ key: "intMode", value: config.intMode });
+    }
+    if (config.fetch !== void 0) {
+      unsupportedOptions.push({ key: "fetch", value: config.fetch });
+    }
+    if (config.concurrency !== void 0) {
+      unsupportedOptions.push({ key: "concurrency", value: config.concurrency });
+    }
+    if (unsupportedOptions.length > 0) {
+      const optionsList = unsupportedOptions.map((opt) => `'${opt.key}'`).join(", ");
+      throw new LibsqlError(
+        `Unsupported configuration options: ${optionsList}. Only 'url', 'authToken', and 'remoteEncryptionKey' are supported in the serverless compatibility layer.`,
+        "UNSUPPORTED_CONFIG"
+      );
+    }
+    if (!config.url) {
+      throw new LibsqlError("Missing required 'url' configuration option", "MISSING_URL");
+    }
+  }
+  get closed() {
+    return this._closed;
+  }
+  get protocol() {
+    return "http";
+  }
+  normalizeStatement(stmt) {
+    if (typeof stmt === "string") {
+      return { sql: stmt, args: [] };
+    }
+    const args = stmt.args || [];
+    if (Array.isArray(args)) {
+      return { sql: stmt.sql, args };
+    }
+    return { sql: stmt.sql, args: Object.values(args) };
+  }
+  convertResult(result) {
+    const resultSet = {
+      columns: result.columns || [],
+      columnTypes: result.columnTypes || [],
+      rows: result.rows || [],
+      rowsAffected: result.rowsAffected || 0,
+      lastInsertRowid: result.lastInsertRowid ? BigInt(result.lastInsertRowid) : void 0,
+      toJSON() {
+        return {
+          columns: this.columns,
+          columnTypes: this.columnTypes,
+          rows: this.rows,
+          rowsAffected: this.rowsAffected,
+          lastInsertRowid: this.lastInsertRowid?.toString()
+        };
+      }
+    };
+    return resultSet;
+  }
+  async execute(stmtOrSql, args) {
+    await this.execLock.acquire();
+    try {
+      if (this._closed) {
+        throw new LibsqlError("Client is closed", "CLIENT_CLOSED");
+      }
+      let normalizedStmt;
+      if (typeof stmtOrSql === "string") {
+        const normalizedArgs = args ? Array.isArray(args) ? args : Object.values(args) : [];
+        normalizedStmt = { sql: stmtOrSql, args: normalizedArgs };
+      } else {
+        normalizedStmt = this.normalizeStatement(stmtOrSql);
+      }
+      const result = await this.session.execute(normalizedStmt.sql, normalizedStmt.args, this._defaultSafeIntegers);
+      return this.convertResult(result);
+    } catch (error) {
+      if (error instanceof LibsqlError) {
+        throw error;
+      }
+      throw mapDatabaseError(error, "EXECUTE_ERROR");
+    } finally {
+      this.execLock.release();
+    }
+  }
+  async batch(stmts, mode) {
+    await this.execLock.acquire();
+    try {
+      if (this._closed) {
+        throw new LibsqlError("Client is closed", "CLIENT_CLOSED");
+      }
+      const sqlStatements = stmts.map((stmt) => {
+        const normalized = this.normalizeStatement(stmt);
+        return normalized.sql;
+      });
+      const result = await this.session.batch(sqlStatements);
+      return [this.convertResult(result)];
+    } catch (error) {
+      if (error instanceof LibsqlError) {
+        throw error;
+      }
+      throw mapDatabaseError(error, "BATCH_ERROR");
+    } finally {
+      this.execLock.release();
+    }
+  }
+  async migrate(stmts) {
+    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) {
+    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(() => void 0).finally(() => {
+          void closeTx();
+        });
+      },
+      get closed() {
+        return txClosed;
+      }
+    };
+  }
+  async executeMultiple(sql) {
+    await this.execLock.acquire();
+    try {
+      if (this._closed) {
+        throw new LibsqlError("Client is closed", "CLIENT_CLOSED");
+      }
+      await this.session.sequence(sql);
+    } catch (error) {
+      if (error instanceof LibsqlError) {
+        throw error;
+      }
+      throw mapDatabaseError(error, "EXECUTE_MULTIPLE_ERROR");
+    } finally {
+      this.execLock.release();
+    }
+  }
+  async sync() {
+    throw new LibsqlError("Sync not supported for remote databases", "NOT_SUPPORTED");
+  }
+  close() {
+    this._closed = true;
+    this.session.close().catch((error) => {
+      console.error("Error closing session:", error);
+    });
+  }
+};
+function createClient(config) {
+  return new LibSQLClient(config);
+}
+var sqliteBaseErrorCodes = /* @__PURE__ */ new Set([
+  "SQLITE_ERROR",
+  "SQLITE_INTERNAL",
+  "SQLITE_PERM",
+  "SQLITE_ABORT",
+  "SQLITE_BUSY",
+  "SQLITE_LOCKED",
+  "SQLITE_NOMEM",
+  "SQLITE_READONLY",
+  "SQLITE_INTERRUPT",
+  "SQLITE_IOERR",
+  "SQLITE_CORRUPT",
+  "SQLITE_NOTFOUND",
+  "SQLITE_FULL",
+  "SQLITE_CANTOPEN",
+  "SQLITE_PROTOCOL",
+  "SQLITE_EMPTY",
+  "SQLITE_SCHEMA",
+  "SQLITE_TOOBIG",
+  "SQLITE_CONSTRAINT",
+  "SQLITE_MISMATCH",
+  "SQLITE_MISUSE",
+  "SQLITE_NOLFS",
+  "SQLITE_AUTH",
+  "SQLITE_FORMAT",
+  "SQLITE_RANGE",
+  "SQLITE_NOTADB",
+  "SQLITE_NOTICE",
+  "SQLITE_WARNING"
+]);
+function parseErrorCode(serverCode) {
+  if (sqliteBaseErrorCodes.has(serverCode)) {
+    return { code: serverCode };
+  }
+  for (const base of sqliteBaseErrorCodes) {
+    if (serverCode.startsWith(base + "_")) {
+      return { code: base, extendedCode: serverCode };
+    }
+  }
+  return { code: serverCode };
+}
+function mapDatabaseError(error, fallbackCode) {
+  if (error instanceof DatabaseError && error.code) {
+    const { code, extendedCode } = parseErrorCode(error.code);
+    return new LibsqlError(error.message, code, extendedCode, error.rawCode, error);
+  }
+  const cause = error instanceof Error ? error : void 0;
+  return new LibsqlError(error.message ?? String(error), fallbackCode, void 0, void 0, cause);
+}
+
+export { LibsqlError, createClient };