@happyvertical/sql 0.80.0 → 0.80.2

package/dist/chunks/sqlite-CPCNeJIH.js

@@ -1,937 +0,0 @@
-import { DatabaseError } from "@happyvertical/utils";
-import { r as resolveSchemas, v as validateTableName, a as validateIndexName, b as validateColumnName, g as generateCreateIndexStatement, f as formatDbError, c as generateAddColumnStatement, D as DatabaseSchemaManager, d as buildWhere } from "./index-CzdYvRFp.js";
-const memoryConnectionCache = /* @__PURE__ */ new Map();
-const pendingConnections = /* @__PURE__ */ new Map();
-const NULL_AWARE_UPSERT_MAX_ATTEMPTS = 8;
-const NULL_AWARE_UPSERT_BASE_DELAY_MS = 25;
-const nullAwareUpsertLocks = /* @__PURE__ */ new Map();
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isRetriableSqliteTransactionError(error) {
-  const formatted = formatDbError(error).toLowerCase();
-  return formatted.includes("busy") || formatted.includes("locked") || formatted.includes("database is locked");
-}
-async function withNullAwareUpsertLock(lockKey, callback) {
-  const previous = nullAwareUpsertLocks.get(lockKey) ?? Promise.resolve();
-  let release = () => {
-  };
-  const current = new Promise((resolve) => {
-    release = resolve;
-  });
-  const next = previous.catch(() => {
-  }).then(() => current);
-  nullAwareUpsertLocks.set(lockKey, next);
-  await previous.catch(() => {
-  });
-  try {
-    return await callback();
-  } finally {
-    release();
-    if (nullAwareUpsertLocks.get(lockKey) === next) {
-      nullAwareUpsertLocks.delete(lockKey);
-    }
-  }
-}
-function generateDbId() {
-  return `memory-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-async function createLibSQLClient(options) {
-  const { url = ":memory:", authToken, encryptionKey } = options;
-  let libsqlUrl = url;
-  if (url !== ":memory:" && !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("libsql://") && !url.startsWith("file:")) {
-    const { resolve } = await import("node:path");
-    const absolutePath = resolve(url);
-    libsqlUrl = `file://${absolutePath}`;
-  }
-  try {
-    const libsqlClient = "@libsql/client";
-    const { createClient } = await import(
-      /* @vite-ignore */
-      libsqlClient
-    );
-    return createClient({ url: libsqlUrl, authToken, encryptionKey });
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (errorMessage?.includes("URL_SCHEME_NOT_SUPPORTED")) {
-      throw new DatabaseError(
-        `Unsupported URL scheme. Use ':memory:' for in-memory databases or 'libsql://' for remote LibSQL databases. Original: ${url}, Converted: ${libsqlUrl}`,
-        { url: libsqlUrl, originalError: errorMessage }
-      );
-    }
-    throw new DatabaseError(`Failed to create LibSQL client: ${errorMessage}`, {
-      url: libsqlUrl,
-      originalError: errorMessage
-    });
-  }
-}
-function hasNativeSqliteCapabilities(options) {
-  return Boolean(
-    options.capabilities?.notifications || options.capabilities?.vector
-  );
-}
-async function createTablesFromSchemas(client, schemas) {
-  for (const [tableName, schema] of Object.entries(schemas)) {
-    try {
-      const result = await client.execute({
-        sql: `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
-        args: [tableName]
-      });
-      if (result.rows.length > 0) {
-        console.log(`[sqlite] Table ${tableName} already exists, skipping`);
-        continue;
-      }
-      console.log(`[sqlite] Creating table ${tableName} from provided schema`);
-      await client.execute(schema.ddl);
-      if (schema.indexes && schema.indexes.length > 0) {
-        for (const indexSQL of schema.indexes) {
-          try {
-            await client.execute(indexSQL);
-          } catch (error) {
-            console.warn(
-              `[sqlite] Failed to create index for ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        }
-      }
-      if (schema.triggers && schema.triggers.length > 0) {
-        for (const triggerSQL of schema.triggers) {
-          try {
-            await client.execute(triggerSQL);
-          } catch (error) {
-            console.warn(
-              `[sqlite] Failed to create trigger for ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        }
-      }
-    } catch (error) {
-      console.error(
-        `[sqlite] Error creating table ${tableName}:`,
-        error instanceof Error ? error.message : String(error)
-      );
-      console.error(`[sqlite] DDL was:`, schema.ddl?.substring(0, 200) + "...");
-      throw new DatabaseError(
-        `Failed to create table ${tableName} from schema: ${error instanceof Error ? error.message : String(error)}`,
-        {
-          tableName,
-          schema,
-          originalError: error instanceof Error ? error.message : String(error)
-        }
-      );
-    }
-  }
-}
-async function getDatabase(options = {}) {
-  const url = options.url || ":memory:";
-  if (url === ":memory:" && !options.dbid) {
-    options.dbid = generateDbId();
-  }
-  if (hasNativeSqliteCapabilities(options)) {
-    const sqliteNative = await import("./sqlite-native-DqVPKNUu.js");
-    return sqliteNative.getNativeSqliteDatabase(options);
-  }
-  if (options.dbid) {
-    const cached = memoryConnectionCache.get(options.dbid);
-    if (cached) {
-      return cached;
-    }
-    const pending = pendingConnections.get(options.dbid);
-    if (pending) {
-      return pending;
-    }
-  }
-  const connectionPromise = (async () => {
-    const client = await createLibSQLClient(options);
-    const resolvedSchemas = resolveSchemas(options.schemas);
-    if (resolvedSchemas && Object.keys(resolvedSchemas).length > 0) {
-      await createTablesFromSchemas(client, resolvedSchemas);
-    }
-    const serializeValue = (value) => {
-      if (value === null || value === void 0) {
-        return value;
-      }
-      if (value instanceof Date) {
-        return value.toISOString();
-      }
-      if (typeof value === "object") {
-        return JSON.stringify(value);
-      }
-      return value;
-    };
-    const serializeRecord = (record) => {
-      const serialized = {};
-      for (const [key, value] of Object.entries(record)) {
-        if (value === void 0) {
-          continue;
-        }
-        serialized[key] = serializeValue(value);
-      }
-      return serialized;
-    };
-    const hasNullConflictValue = (conflictColumns, data) => conflictColumns.some((col) => data[col] === null);
-    const buildNullAwareUpsertLockKey = (table2, conflictColumns, data) => {
-      const conflictValues = conflictColumns.map((col) => `${col}:${JSON.stringify(data[col])}`).join("|");
-      return `${url}:${table2}:${conflictValues}`;
-    };
-    const validateUpsertConflictColumns = (table2, conflictColumns, serializedData) => {
-      const missingColumns = conflictColumns.filter(
-        (col) => !(col in serializedData)
-      );
-      if (missingColumns.length > 0) {
-        throw new DatabaseError("Conflict columns missing from data", {
-          table: table2,
-          conflictColumns,
-          missingColumns,
-          availableColumns: Object.keys(serializedData),
-          hint: "All columns specified in ON CONFLICT must be present in the data being inserted. Undefined values are filtered out during serialization - consider using null or an empty string instead."
-        });
-      }
-    };
-    const executeStandardUpsert = async (table2, conflictColumns, serializedData) => {
-      const keys = Object.keys(serializedData);
-      const values = Object.values(serializedData);
-      const placeholders = keys.map(() => "?").join(", ");
-      const updateSet = keys.map((key) => `${key} = excluded.${key}`).join(", ");
-      const conflict = conflictColumns.join(", ");
-      const sql = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${conflict}) DO UPDATE SET ${updateSet}`;
-      const result = await client.execute({ sql, args: values });
-      return { operation: "upsert", affected: result.rowsAffected };
-    };
-    const executeNullAwareUpsertAttempt = async (executor, table2, conflictColumns, serializedData) => {
-      const keys = Object.keys(serializedData);
-      const values = Object.values(serializedData);
-      const updateSet = keys.map((key) => `${key} = ?`).join(", ");
-      const whereClause = conflictColumns.map((col) => `${col} IS ?`).join(" AND ");
-      const whereValues = conflictColumns.map((col) => serializedData[col]);
-      const updateSql = `UPDATE ${table2} SET ${updateSet} WHERE ${whereClause}`;
-      const updateResult = await executor.execute({
-        sql: updateSql,
-        args: [...values, ...whereValues]
-      });
-      if ((updateResult.rowsAffected ?? 0) > 0) {
-        return { operation: "upsert", affected: updateResult.rowsAffected };
-      }
-      const placeholders = keys.map(() => "?").join(", ");
-      const insertSql = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES (${placeholders})`;
-      const insertResult = await executor.execute({
-        sql: insertSql,
-        args: values
-      });
-      return { operation: "upsert", affected: insertResult.rowsAffected };
-    };
-    const executeNullAwareUpsertWithRetry = async (table2, conflictColumns, serializedData) => {
-      if (url === ":memory:") {
-        return executeNullAwareUpsertAttempt(
-          client,
-          table2,
-          conflictColumns,
-          serializedData
-        );
-      }
-      let lastError;
-      for (let attempt = 0; attempt < NULL_AWARE_UPSERT_MAX_ATTEMPTS; attempt++) {
-        let transaction2;
-        try {
-          transaction2 = await client.transaction("write");
-          const result = await executeNullAwareUpsertAttempt(
-            transaction2,
-            table2,
-            conflictColumns,
-            serializedData
-          );
-          await transaction2.commit();
-          return result;
-        } catch (error) {
-          lastError = error;
-          if (transaction2 && !transaction2.closed) {
-            try {
-              await transaction2.rollback();
-            } catch (_rollbackError) {
-            }
-          }
-        } finally {
-          transaction2?.close();
-        }
-        if (lastError && attempt < NULL_AWARE_UPSERT_MAX_ATTEMPTS - 1 && isRetriableSqliteTransactionError(lastError)) {
-          await delay(NULL_AWARE_UPSERT_BASE_DELAY_MS * 2 ** attempt);
-          continue;
-        }
-        break;
-      }
-      throw lastError;
-    };
-    const executeUpsert = async (table2, conflictColumns, data, options2, acquireTransaction) => {
-      const serializedData = serializeRecord(data);
-      validateUpsertConflictColumns(table2, conflictColumns, serializedData);
-      if (options2?.nullsDistinct || !hasNullConflictValue(conflictColumns, serializedData)) {
-        return executeStandardUpsert(table2, conflictColumns, serializedData);
-      }
-      if (!acquireTransaction) {
-        return executeNullAwareUpsertAttempt(
-          client,
-          table2,
-          conflictColumns,
-          serializedData
-        );
-      }
-      return withNullAwareUpsertLock(
-        buildNullAwareUpsertLockKey(table2, conflictColumns, serializedData),
-        () => executeNullAwareUpsertWithRetry(
-          table2,
-          conflictColumns,
-          serializedData
-        )
-      );
-    };
-    const insert = async (table2, data) => {
-      let sql;
-      let values;
-      if (Array.isArray(data)) {
-        const serializedRecords = data.map(
-          (record) => serializeRecord(record)
-        );
-        const keys = Object.keys(serializedRecords[0]);
-        const placeholders = serializedRecords.map(() => `(${keys.map(() => "?").join(", ")})`).join(", ");
-        sql = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES ${placeholders}`;
-        const flattenedValues = [];
-        for (const record of serializedRecords) {
-          flattenedValues.push(...Object.values(record));
-        }
-        values = flattenedValues;
-      } else {
-        const serializedData = serializeRecord(data);
-        const keys = Object.keys(serializedData);
-        const placeholders = keys.map(() => "?").join(", ");
-        sql = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES (${placeholders})`;
-        values = Object.values(serializedData);
-      }
-      try {
-        const result = await client.execute({ sql, args: values });
-        return { operation: "insert", affected: result.rowsAffected };
-      } catch (e) {
-        throw new DatabaseError("Failed to insert records into table", {
-          table: table2,
-          sql,
-          values,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const get = async (table2, where) => {
-      const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
-      if (!whereClause) {
-        throw new DatabaseError(
-          "GET requires at least one WHERE condition to prevent returning an arbitrary record",
-          { table: table2 }
-        );
-      }
-      const sql = `SELECT * FROM ${table2} ${whereClause}`;
-      try {
-        const result = await client.execute({ sql, args: values });
-        return result.rows[0] || null;
-      } catch (e) {
-        throw new DatabaseError("Failed to retrieve record from table", {
-          table: table2,
-          sql,
-          values,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const list = async (table2, where) => {
-      const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
-      const sql = `SELECT * FROM ${table2} ${whereClause}`;
-      try {
-        const result = await client.execute({ sql, args: values });
-        return result.rows;
-      } catch (e) {
-        throw new DatabaseError("Failed to list records from table", {
-          table: table2,
-          sql,
-          values,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const update = async (table2, where, data) => {
-      const serializedData = serializeRecord(data);
-      const keys = Object.keys(serializedData);
-      const values = Object.values(serializedData);
-      const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-      const { sql: whereClause, values: whereValues } = buildWhere(
-        where,
-        values.length + 1,
-        "sqlite"
-      );
-      if (!whereClause) {
-        throw new DatabaseError(
-          "UPDATE requires at least one WHERE condition to prevent accidental update of all records",
-          { table: table2 }
-        );
-      }
-      const sql = `UPDATE ${table2} SET ${setClause} ${whereClause}`;
-      try {
-        const result = await client.execute({
-          sql,
-          args: [...values, ...whereValues]
-        });
-        return { operation: "update", affected: result.rowsAffected };
-      } catch (e) {
-        throw new DatabaseError("Failed to update records in table", {
-          table: table2,
-          sql,
-          values: [...values, ...whereValues],
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const upsert = async (table2, conflictColumns, data, options2) => {
-      try {
-        return await executeUpsert(table2, conflictColumns, data, options2, true);
-      } catch (e) {
-        if (e instanceof DatabaseError && e.message === "Conflict columns missing from data") {
-          throw e;
-        }
-        throw new DatabaseError("Failed to upsert record into table", {
-          table: table2,
-          values: data,
-          conflictColumns,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const upsertInCurrentTransaction = async (table2, conflictColumns, data, options2) => {
-      try {
-        return await executeUpsert(
-          table2,
-          conflictColumns,
-          data,
-          options2,
-          false
-        );
-      } catch (e) {
-        if (e instanceof DatabaseError && e.message === "Conflict columns missing from data") {
-          throw e;
-        }
-        throw new DatabaseError("Failed to upsert record into table", {
-          table: table2,
-          values: data,
-          conflictColumns,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const getOrInsert = async (table2, where, data) => {
-      const result = await get(table2, where);
-      if (result) return result;
-      await insert(table2, data);
-      const inserted = await get(table2, where);
-      if (!inserted) {
-        throw new DatabaseError("Failed to insert and retrieve record", {
-          table: table2,
-          where,
-          data
-        });
-      }
-      return inserted;
-    };
-    const deleteRecords = async (table2, where) => {
-      validateTableName(table2);
-      const keys = Object.keys(where);
-      if (keys.length === 0) {
-        throw new DatabaseError(
-          "DELETE requires at least one WHERE condition to prevent accidental deletion of all records",
-          { table: table2 }
-        );
-      }
-      const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
-      try {
-        await client.execute({
-          sql: `DELETE FROM ${table2} ${whereClause}`,
-          args: values
-        });
-        return { operation: "delete", affected: 1 };
-      } catch (e) {
-        throw new DatabaseError("Failed to delete records from table", {
-          table: table2,
-          where,
-          originalError: e
-        });
-      }
-    };
-    const count = async (table2, where) => {
-      validateTableName(table2);
-      try {
-        if (!where || Object.keys(where).length === 0) {
-          const result2 = await pluck`SELECT COUNT(*) FROM ${table2}`;
-          return Number(result2) || 0;
-        }
-        const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
-        const result = await client.execute({
-          sql: `SELECT COUNT(*) as count FROM ${table2} ${whereClause}`,
-          args: values
-        });
-        return Number(result.rows[0]?.count) || 0;
-      } catch (e) {
-        throw new DatabaseError("Failed to count records in table", {
-          table: table2,
-          where,
-          originalError: e
-        });
-      }
-    };
-    const tableExists = async (tableName) => {
-      const tableExists2 = !!await pluck`SELECT name FROM sqlite_master WHERE type='table' AND name=${tableName}`;
-      return tableExists2;
-    };
-    const syncSchema = async (schema) => {
-      console.log(
-        "[sqlite.syncSchema] Starting schema sync for dbid:",
-        options.dbid
-      );
-      console.log("[sqlite.syncSchema] Schema length:", schema.length, "chars");
-      const reservedKeywords = /* @__PURE__ */ new Set([
-        "references",
-        "order",
-        "group",
-        "table",
-        "index",
-        "select",
-        "from",
-        "where",
-        "join",
-        "left",
-        "right",
-        "inner",
-        "outer",
-        "on",
-        "as",
-        "and",
-        "or",
-        "not",
-        "like",
-        "in",
-        "between",
-        "case",
-        "when",
-        "then",
-        "else",
-        "end",
-        "union",
-        "distinct",
-        "having",
-        "limit",
-        "offset",
-        "default",
-        "check",
-        "unique",
-        "primary",
-        "foreign",
-        "key",
-        "constraint",
-        "cascade"
-      ]);
-      let normalizedSchema = schema.replace(/\s+/g, " ").replace(/DEFAULT CAST\(([^)]+)\s+AS\s+\w+\)/gi, "DEFAULT $1").trim();
-      normalizedSchema = normalizedSchema.replace(
-        /"(\w+)"/g,
-        (match, identifier) => {
-          return reservedKeywords.has(identifier.toLowerCase()) ? match : identifier;
-        }
-      );
-      console.log("[sqlite.syncSchema] Normalized schema:", normalizedSchema);
-      const commands = normalizedSchema.split(";").map((cmd) => cmd.trim()).filter((cmd) => cmd.length > 0);
-      console.log(
-        "[sqlite.syncSchema] Found",
-        commands.length,
-        "commands to process"
-      );
-      for (const command of commands) {
-        try {
-          console.log(
-            "[sqlite.syncSchema] Executing:",
-            `${command.substring(0, 50)}...`
-          );
-          await client.execute(command);
-          console.log("[sqlite.syncSchema] Successfully executed command");
-        } catch (error) {
-          console.error(
-            "[sqlite.syncSchema] Failed to execute command:",
-            command
-          );
-          console.error("[sqlite.syncSchema] Error:", error);
-          throw error;
-        }
-      }
-    };
-    const transaction = async (callback) => {
-      try {
-        await client.execute({ sql: "BEGIN TRANSACTION", args: [] });
-        const txDb = {
-          url,
-          client,
-          insert,
-          get,
-          list,
-          update,
-          upsert: upsertInCurrentTransaction,
-          getOrInsert,
-          delete: deleteRecords,
-          count,
-          table,
-          many,
-          single,
-          pluck,
-          execute,
-          query,
-          oo: many,
-          oO: single,
-          ox: pluck,
-          xx: execute,
-          tableExists,
-          syncSchema,
-          transaction
-        };
-        const result = await callback(txDb);
-        await client.execute({ sql: "COMMIT", args: [] });
-        return result;
-      } catch (error) {
-        await client.execute({ sql: "ROLLBACK", args: [] });
-        throw error;
-      }
-    };
-    const beginTransaction = async () => {
-      await client.execute({ sql: "BEGIN TRANSACTION", args: [] });
-      let active = true;
-      const commit = async () => {
-        if (!active) {
-          throw new DatabaseError("Transaction already ended", {});
-        }
-        await client.execute({ sql: "COMMIT", args: [] });
-        active = false;
-      };
-      const rollback = async () => {
-        if (!active) {
-          throw new DatabaseError("Transaction already ended", {});
-        }
-        await client.execute({ sql: "ROLLBACK", args: [] });
-        active = false;
-      };
-      const isActive = () => active;
-      const txHandle = {
-        url,
-        client,
-        insert,
-        get,
-        list,
-        update,
-        upsert: upsertInCurrentTransaction,
-        getOrInsert,
-        delete: deleteRecords,
-        count,
-        table,
-        many,
-        single,
-        pluck,
-        execute,
-        query,
-        oo: many,
-        oO: single,
-        ox: pluck,
-        xx: execute,
-        tableExists,
-        syncSchema,
-        transaction,
-        commit,
-        rollback,
-        isActive
-      };
-      return txHandle;
-    };
-    const table = (tableName) => ({
-      insert: (data) => insert(tableName, data),
-      get: (where) => get(tableName, where),
-      list: (where) => list(tableName, where)
-    });
-    const parseTemplate = (strings, ...vars) => {
-      let sql = strings[0];
-      const values = [];
-      for (let i = 0; i < vars.length; i++) {
-        values.push(vars[i]);
-        sql += `?${strings[i + 1]}`;
-      }
-      return { sql, values };
-    };
-    const pluck = async (strings, ...vars) => {
-      const { sql, values } = parseTemplate(strings, ...vars);
-      try {
-        const result = await client.execute({ sql, args: values });
-        return result.rows[0]?.[Object.keys(result.rows[0])[0]] ?? null;
-      } catch (e) {
-        throw new DatabaseError("Failed to execute pluck query", {
-          sql,
-          values,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const single = async (strings, ...vars) => {
-      const { sql, values } = parseTemplate(strings, ...vars);
-      try {
-        const result = await client.execute({ sql, args: values });
-        return result.rows[0] || null;
-      } catch (e) {
-        throw new DatabaseError("Failed to execute single query", {
-          sql,
-          values,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const many = async (strings, ...vars) => {
-      const { sql, values } = parseTemplate(strings, ...vars);
-      try {
-        const result = await client.execute({ sql, args: values });
-        return result.rows;
-      } catch (e) {
-        throw new DatabaseError("Failed to execute many query", {
-          sql,
-          values,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const execute = async (strings, ...vars) => {
-      const { sql, values } = parseTemplate(strings, ...vars);
-      try {
-        await client.execute({ sql, args: values });
-      } catch (e) {
-        throw new DatabaseError("Failed to execute query", {
-          sql,
-          values,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const query = async (str, ...values) => {
-      const sql = str;
-      const args = Array.isArray(values[0]) ? values[0] : values;
-      try {
-        const result = await client.execute({ sql, args });
-        return {
-          command: sql.split(" ")[0].toUpperCase(),
-          rowCount: result.rowsAffected ?? result.rows.length,
-          oid: null,
-          fields: Object.keys(result.rows[0] || {}).map((name) => ({
-            name,
-            tableID: 0,
-            columnID: 0,
-            dataTypeID: 0,
-            dataTypeSize: -1,
-            dataTypeModifier: -1,
-            format: "text"
-          })),
-          rows: result.rows
-        };
-      } catch (e) {
-        throw new DatabaseError("Failed to execute raw query", {
-          sql,
-          args,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const oo = many;
-    const oO = single;
-    const ox = pluck;
-    const xx = execute;
-    const initializeSchemas = async (options2) => {
-      const schemaManager = new DatabaseSchemaManager();
-      const currentDb = {
-        url,
-        client,
-        query,
-        insert,
-        update,
-        upsert,
-        get,
-        list,
-        getOrInsert,
-        delete: deleteRecords,
-        count,
-        table,
-        tableExists,
-        many,
-        single,
-        pluck,
-        execute,
-        oo,
-        oO,
-        ox,
-        xx,
-        syncSchema,
-        transaction
-      };
-      await schemaManager.initializeSchemas(currentDb, options2);
-    };
-    const getTableSchema = async (table2) => {
-      validateTableName(table2);
-      try {
-        const exists = await tableExists(table2);
-        if (!exists) {
-          return null;
-        }
-        const columnRows = await many`SELECT * FROM pragma_table_info(${table2})`;
-        const columns = {};
-        for (const row of columnRows) {
-          const colName = row.name;
-          columns[colName] = {
-            type: row.type,
-            primaryKey: row.pk === 1,
-            notNull: row.notnull === 1,
-            defaultValue: row.dflt_value
-          };
-        }
-        const indexRows = await many`
-        SELECT name, sql FROM sqlite_master
-        WHERE type = 'index'
-          AND tbl_name = ${table2}
-          AND name NOT LIKE 'sqlite_%'
-      `;
-        const indexes = [];
-        for (const row of indexRows) {
-          const indexName = row.name;
-          const indexInfoRows = await many`SELECT * FROM pragma_index_info(${indexName})`;
-          const indexColumns = [];
-          for (const infoRow of indexInfoRows) {
-            indexColumns.push(infoRow.name);
-          }
-          const indexListRow = await single`SELECT * FROM pragma_index_list(${table2}) WHERE name = ${indexName}`;
-          indexes.push({
-            name: indexName,
-            columns: indexColumns,
-            unique: indexListRow?.unique === 1
-          });
-        }
-        const fkRows = await many`SELECT * FROM pragma_foreign_key_list(${table2})`;
-        const foreignKeys = [];
-        for (const fkRow of fkRows) {
-          foreignKeys.push({
-            column: fkRow.from,
-            referencesTable: fkRow.table,
-            referencesColumn: fkRow.to,
-            onDelete: fkRow.on_delete,
-            onUpdate: fkRow.on_update
-          });
-        }
-        return {
-          tableName: table2,
-          columns,
-          indexes,
-          foreignKeys
-        };
-      } catch (e) {
-        throw new DatabaseError("Failed to retrieve table schema", {
-          table: table2,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const alterTable = {
-      /**
-       * Adds a new column to an existing table
-       *
-       * @param table - Table name
-       * @param column - Column definition with name
-       * @returns Promise that resolves when column is added
-       * @throws Error if the alter operation fails
-       */
-      addColumn: async (table2, column) => {
-        validateTableName(table2);
-        validateColumnName(column.name);
-        try {
-          const sql = generateAddColumnStatement(table2, column, "sqlite");
-          await client.execute({ sql, args: [] });
-        } catch (e) {
-          throw new DatabaseError("Failed to add column to table", {
-            table: table2,
-            column: column.name,
-            originalError: formatDbError(e)
-          });
-        }
-      },
-      /**
-       * Adds a new index to an existing table
-       *
-       * @param table - Table name
-       * @param index - Index definition
-       * @returns Promise that resolves when index is created
-       * @throws Error if the create index operation fails
-       */
-      addIndex: async (table2, index) => {
-        validateTableName(table2);
-        validateIndexName(index.name);
-        for (const col of index.columns) {
-          validateColumnName(col);
-        }
-        try {
-          const sql = generateCreateIndexStatement(table2, index);
-          await client.execute({ sql, args: [] });
-        } catch (e) {
-          throw new DatabaseError("Failed to create index on table", {
-            table: table2,
-            index: index.name,
-            originalError: formatDbError(e)
-          });
-        }
-      }
-    };
-    return {
-      url,
-      client,
-      query,
-      insert,
-      update,
-      upsert,
-      get,
-      list,
-      getOrInsert,
-      delete: deleteRecords,
-      count,
-      table,
-      tableExists,
-      many,
-      single,
-      pluck,
-      execute,
-      oo,
-      oO,
-      ox,
-      xx,
-      syncSchema,
-      initializeSchemas,
-      transaction,
-      beginTransaction,
-      getTableSchema,
-      alterTable
-    };
-  })();
-  if (options.dbid) {
-    pendingConnections.set(options.dbid, connectionPromise);
-  }
-  try {
-    const db = await connectionPromise;
-    if (options.dbid) {
-      memoryConnectionCache.set(options.dbid, db);
-    }
-    return db;
-  } finally {
-    if (options.dbid) {
-      pendingConnections.delete(options.dbid);
-    }
-  }
-}
-export {
-  getDatabase
-};
-//# sourceMappingURL=sqlite-CPCNeJIH.js.map