@happyvertical/sql 0.80.0 → 0.80.2

package/dist/chunks/duckdb-B6m78QdL.js

@@ -1,924 +0,0 @@
-import { readdir } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, extname, basename } from "node:path";
-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, e as convertUniqueIndexesToInlineConstraints, d as buildWhere } from "./index-CzdYvRFp.js";
-async function createTablesFromSchemas(connection, schemas) {
-  for (const [tableName, schema] of Object.entries(schemas)) {
-    try {
-      const result = await connection.runAndReadAll(
-        `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}'`
-      );
-      const rows = result.getRowObjects();
-      if (rows.length > 0) {
-        console.log(`[duckdb] Table ${tableName} already exists, skipping`);
-        continue;
-      }
-      console.log(`[duckdb] Creating table ${tableName} from provided schema`);
-      const transformed = convertUniqueIndexesToInlineConstraints(
-        schema.ddl,
-        schema.indexes
-      );
-      await connection.run(transformed.ddl);
-      if (transformed.indexes && transformed.indexes.length > 0) {
-        for (const indexSQL of transformed.indexes) {
-          try {
-            await connection.run(indexSQL);
-          } catch (error) {
-            console.warn(
-              `[duckdb] 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 connection.run(triggerSQL);
-          } catch (error) {
-            console.warn(
-              `[duckdb] Failed to create trigger for ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        }
-      }
-    } catch (error) {
-      throw new DatabaseError(
-        `Failed to create table ${tableName} from schema`,
-        {
-          tableName,
-          schema,
-          originalError: error instanceof Error ? error.message : String(error)
-        }
-      );
-    }
-  }
-}
-function resolveDuckDBUrl(url) {
-  if (url === ":memory:") {
-    return url;
-  }
-  if (url.startsWith(":memory:")) {
-    const suffix = url.slice(":memory:".length);
-    const tempPath = join(tmpdir(), `duckdb-memory-${suffix}.db`);
-    return tempPath;
-  }
-  return url;
-}
-async function createDuckDBConnection(options) {
-  const {
-    url = ":memory:",
-    dataDir = "./data",
-    autoRegisterJSON = true
-  } = options;
-  const schemas = resolveSchemas(options.schemas) ?? {};
-  const resolvedUrl = resolveDuckDBUrl(url);
-  try {
-    const duckdbModule = "@duckdb/node-api";
-    const { DuckDBInstance } = await import(
-      /* @vite-ignore */
-      duckdbModule
-    );
-    const instance = await DuckDBInstance.create(resolvedUrl);
-    const connection = await instance.connect();
-    if (schemas && Object.keys(schemas).length > 0) {
-      await createTablesFromSchemas(connection, schemas);
-    }
-    if (autoRegisterJSON && dataDir) {
-      await registerJSONFiles(connection, dataDir);
-    }
-    return connection;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new DatabaseError(
-      `Failed to create DuckDB connection: ${errorMessage}`,
-      {
-        url,
-        originalError: errorMessage
-      }
-    );
-  }
-}
-async function registerJSONFiles(connection, dataDir) {
-  try {
-    const files = await readdir(dataDir);
-    const jsonFiles = files.filter(
-      (file) => extname(file).toLowerCase() === ".json"
-    );
-    for (const file of jsonFiles) {
-      const filePath = join(dataDir, file);
-      const tableName = basename(file, ".json");
-      await connection.run(
-        `CREATE OR REPLACE VIEW ${tableName} AS SELECT * FROM read_json('${filePath}', auto_detect=true, format='auto', timestampformat='iso', dateformat='iso')`
-      );
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw new DatabaseError(`Failed to register JSON files from ${dataDir}`, {
-        dataDir,
-        originalError: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-}
-function convertBigInts(obj) {
-  if (obj === null || obj === void 0) return obj;
-  if (typeof obj === "bigint") return Number(obj);
-  if (typeof obj === "object" && !Array.isArray(obj) && "micros" in obj && Object.keys(obj).length === 1 && (typeof obj.micros === "number" || typeof obj.micros === "bigint")) {
-    const micros = typeof obj.micros === "bigint" ? Number(obj.micros) : obj.micros;
-    const milliseconds = micros / 1e3;
-    return new Date(milliseconds);
-  }
-  if (Array.isArray(obj)) return obj.map(convertBigInts);
-  if (typeof obj === "object") {
-    const result = {};
-    for (const key in obj) {
-      result[key] = convertBigInts(obj[key]);
-    }
-    return result;
-  }
-  return obj;
-}
-async function getDatabase(options = {}) {
-  const connection = await createDuckDBConnection(options);
-  const writeStrategy = options.writeStrategy || "none";
-  const dataDir = options.dataDir || "./data";
-  const url = resolveDuckDBUrl(options.url || ":memory:");
-  const insert = async (table2, data) => {
-    const records = Array.isArray(data) ? data : [data];
-    if (records.length === 0) {
-      return { operation: "insert", affected: 0 };
-    }
-    const keys = Object.keys(records[0]);
-    const values = [];
-    let paramIdx = 1;
-    const placeholders = records.map((record) => {
-      const rowPlaceholders = keys.map((key) => {
-        const value = record[key];
-        if (value === null || value === void 0) {
-          return "NULL";
-        } else if (value === "" && typeof value === "string") {
-          values.push(value);
-          return `CAST($${paramIdx++} AS TEXT)`;
-        } else if (value instanceof Date) {
-          values.push(value.toISOString());
-          return `$${paramIdx++}`;
-        } else if (Array.isArray(value)) {
-          values.push(JSON.stringify(value));
-          return `CAST($${paramIdx++} AS JSON)`;
-        } else if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype) {
-          values.push(JSON.stringify(value));
-          return `CAST($${paramIdx++} AS JSON)`;
-        } else {
-          values.push(value);
-          return `$${paramIdx++}`;
-        }
-      });
-      return `(${rowPlaceholders.join(", ")})`;
-    }).join(", ");
-    const sql = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES ${placeholders}`;
-    try {
-      await connection.run(sql, values);
-      const affected = records.length;
-      if (writeStrategy === "immediate") {
-        await exportTableToJSON(connection, table2, dataDir);
-      }
-      return { operation: "insert", affected };
-    } 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, "duckdb");
-    const sql = `SELECT * FROM ${table2} ${whereClause} LIMIT 1`;
-    try {
-      const reader = await connection.runAndReadAll(sql, values);
-      const rows = reader.getRowObjects();
-      return rows.length > 0 ? convertBigInts(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, "duckdb");
-    const sql = `SELECT * FROM ${table2} ${whereClause}`;
-    try {
-      const reader = await connection.runAndReadAll(sql, values);
-      return convertBigInts(reader.getRowObjects());
-    } 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 keys = Object.keys(data);
-    const setClause = keys.map((key, idx) => `${key} = $${idx + 1}`).join(", ");
-    const { sql: whereClause, values: whereValues } = buildWhere(
-      where,
-      keys.length + 1,
-      "duckdb"
-    );
-    const sql = `UPDATE ${table2} SET ${setClause} ${whereClause}`;
-    const values = [...Object.values(data), ...whereValues];
-    try {
-      await connection.run(sql, values);
-      if (writeStrategy === "immediate") {
-        await exportTableToJSON(connection, table2, dataDir);
-      }
-      return { operation: "update", affected: 1 };
-    } catch (e) {
-      throw new DatabaseError("Failed to update records in table", {
-        table: table2,
-        sql,
-        values,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const buildDuckDBValueExpression = (value, values, paramIdx) => {
-    if (value === null || value === void 0) {
-      return "NULL";
-    }
-    if (value === "" && typeof value === "string") {
-      values.push(value);
-      return `CAST($${paramIdx.value++} AS TEXT)`;
-    }
-    if (value instanceof Date) {
-      values.push(value.toISOString());
-      return `$${paramIdx.value++}`;
-    }
-    if (Array.isArray(value)) {
-      values.push(JSON.stringify(value));
-      return `CAST($${paramIdx.value++} AS JSON)`;
-    }
-    if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype) {
-      values.push(JSON.stringify(value));
-      return `CAST($${paramIdx.value++} AS JSON)`;
-    }
-    values.push(value);
-    return `$${paramIdx.value++}`;
-  };
-  const executeNullAwareDuckDBUpsert = async (table2, conflictColumns, data) => {
-    const conflictWhere = Object.fromEntries(
-      conflictColumns.map((col) => [col, data[col]])
-    );
-    const existing = await get(table2, conflictWhere);
-    if (!existing) {
-      return insert(table2, data);
-    }
-    const keys = Object.keys(data);
-    const values = [];
-    const paramIdx = { value: 1 };
-    const assignments = keys.map((key) => {
-      const valueExpr = buildDuckDBValueExpression(data[key], values, paramIdx);
-      return `"${key}" = ${valueExpr}`;
-    });
-    const { sql: whereClause, values: whereValues } = buildWhere(
-      conflictWhere,
-      paramIdx.value,
-      "duckdb"
-    );
-    const sql = `UPDATE ${table2} SET ${assignments.join(", ")} ${whereClause}`;
-    try {
-      await connection.run(sql, [...values, ...whereValues]);
-      if (writeStrategy === "immediate") {
-        await exportTableToJSON(connection, table2, dataDir);
-      }
-      return { operation: "upsert", affected: 1 };
-    } catch (e) {
-      throw new DatabaseError("Failed to upsert record into table", {
-        table: table2,
-        sql,
-        values: [...values, ...whereValues],
-        conflictColumns,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const upsert = async (table2, conflictColumns, data, options2) => {
-    const missingColumns = conflictColumns.filter((col) => !(col in data));
-    if (missingColumns.length > 0) {
-      throw new DatabaseError("Conflict columns missing from data", {
-        table: table2,
-        conflictColumns,
-        missingColumns,
-        availableColumns: Object.keys(data),
-        hint: "All columns specified in ON CONFLICT must be present in the data being inserted. Undefined values should be replaced with null or an appropriate default."
-      });
-    }
-    if (!options2?.nullsDistinct && conflictColumns.some((col) => data[col] === null)) {
-      return executeNullAwareDuckDBUpsert(table2, conflictColumns, data);
-    }
-    const keys = Object.keys(data);
-    const dataValues = Object.values(data);
-    const placeholders = [];
-    const values = [];
-    let paramIdx = 1;
-    for (const value of dataValues) {
-      if (value === null || value === void 0) {
-        placeholders.push("NULL");
-      } else if (value === "" && typeof value === "string") {
-        placeholders.push(`CAST($${paramIdx} AS TEXT)`);
-        values.push(value);
-        paramIdx++;
-      } else if (value instanceof Date) {
-        placeholders.push(`$${paramIdx}`);
-        values.push(value.toISOString());
-        paramIdx++;
-      } else if (Array.isArray(value)) {
-        placeholders.push(`CAST($${paramIdx} AS JSON)`);
-        values.push(JSON.stringify(value));
-        paramIdx++;
-      } else if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype) {
-        placeholders.push(`CAST($${paramIdx} AS JSON)`);
-        values.push(JSON.stringify(value));
-        paramIdx++;
-      } else {
-        placeholders.push(`$${paramIdx}`);
-        values.push(value);
-        paramIdx++;
-      }
-    }
-    const updateSetParts = [];
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const value = dataValues[i];
-      if (value === null || value === void 0) {
-        updateSetParts.push(`${key} = NULL`);
-      } else if (value === "" && typeof value === "string") {
-        updateSetParts.push(`${key} = CAST($${paramIdx} AS TEXT)`);
-        values.push(value);
-        paramIdx++;
-      } else if (value instanceof Date) {
-        updateSetParts.push(`${key} = $${paramIdx}`);
-        values.push(value.toISOString());
-        paramIdx++;
-      } else if (Array.isArray(value)) {
-        updateSetParts.push(`${key} = CAST($${paramIdx} AS JSON)`);
-        values.push(JSON.stringify(value));
-        paramIdx++;
-      } else if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype) {
-        updateSetParts.push(`${key} = CAST($${paramIdx} AS JSON)`);
-        values.push(JSON.stringify(value));
-        paramIdx++;
-      } else {
-        updateSetParts.push(`${key} = $${paramIdx}`);
-        values.push(value);
-        paramIdx++;
-      }
-    }
-    const conflict = conflictColumns.map((col) => `"${col}"`).join(", ");
-    const quotedKeys = keys.map((key) => `"${key}"`).join(", ");
-    const quotedUpdateSetParts = keys.map((key, i) => {
-      const part = updateSetParts[i];
-      const valueExpr = part.substring(part.indexOf("=") + 1).trim();
-      return `"${key}" = ${valueExpr}`;
-    });
-    const sql = `INSERT INTO ${table2} (${quotedKeys}) VALUES (${placeholders.join(", ")}) ON CONFLICT(${conflict}) DO UPDATE SET ${quotedUpdateSetParts.join(", ")}`;
-    try {
-      await connection.run(sql, values);
-      if (writeStrategy === "immediate") {
-        await exportTableToJSON(connection, table2, dataDir);
-      }
-      return { operation: "upsert", affected: 1 };
-    } catch (e) {
-      throw new DatabaseError("Failed to upsert record into table", {
-        table: table2,
-        sql,
-        values,
-        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, "duckdb");
-    const sql = `DELETE FROM ${table2} ${whereClause}`;
-    try {
-      await connection.run(sql, values);
-      if (writeStrategy === "immediate") {
-        await exportTableToJSON(connection, table2, dataDir);
-      }
-      return { operation: "delete", affected: 1 };
-    } catch (e) {
-      throw new DatabaseError("Failed to delete records from table", {
-        table: table2,
-        sql,
-        values,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const count = async (table2, where) => {
-    validateTableName(table2);
-    try {
-      if (!where || Object.keys(where).length === 0) {
-        const result2 = await connection.runAndReadAll(
-          `SELECT COUNT(*) as count FROM ${table2}`
-        );
-        const rows2 = result2.getRowObjects();
-        return Number(rows2[0]?.count) || 0;
-      }
-      const { sql: whereClause, values } = buildWhere(where, 1, "duckdb");
-      const sql = `SELECT COUNT(*) as count FROM ${table2} ${whereClause}`;
-      const result = await connection.runAndReadAll(sql, values);
-      const rows = result.getRowObjects();
-      return Number(rows[0]?.count) || 0;
-    } catch (e) {
-      throw new DatabaseError("Failed to count records in table", {
-        table: table2,
-        where,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const tableExists = async (tableName) => {
-    try {
-      await connection.runAndReadAll(`SELECT * FROM ${tableName} LIMIT 1`);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-  const exportTableToJSON = async (connection2, table2, dataDir2) => {
-    const filePath = join(dataDir2, `${table2}.json`);
-    await connection2.run(
-      `COPY (SELECT * FROM ${table2}) TO '${filePath}' (FORMAT JSON, ARRAY true)`
-    );
-  };
-  const exportTable = async (table2) => {
-    if (writeStrategy === "none") {
-      throw new DatabaseError(
-        "Cannot export table: write strategy is set to none",
-        { table: table2, writeStrategy }
-      );
-    }
-    await exportTableToJSON(connection, table2, dataDir);
-  };
-  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 += `$${i + 1}${strings[i + 1]}`;
-    }
-    return { sql, values };
-  };
-  const many = async (strings, ...vars) => {
-    const { sql, values } = parseTemplate(strings, ...vars);
-    try {
-      const reader = await connection.runAndReadAll(sql, values);
-      return convertBigInts(reader.getRowObjects());
-    } catch (e) {
-      throw new DatabaseError("Failed to execute many query", {
-        sql,
-        values,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const single = async (strings, ...vars) => {
-    const { sql, values } = parseTemplate(strings, ...vars);
-    try {
-      const reader = await connection.runAndReadAll(sql, values);
-      const rows = reader.getRowObjects();
-      return rows[0] ? convertBigInts(rows[0]) : null;
-    } catch (e) {
-      throw new DatabaseError("Failed to execute single query", {
-        sql,
-        values,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const pluck = async (strings, ...vars) => {
-    const { sql, values } = parseTemplate(strings, ...vars);
-    try {
-      const reader = await connection.runAndReadAll(sql, values);
-      const rows = reader.getRowObjects();
-      if (rows.length === 0) return null;
-      const firstRow = rows[0];
-      const firstKey = Object.keys(firstRow)[0];
-      return convertBigInts(firstRow[firstKey]);
-    } catch (e) {
-      throw new DatabaseError("Failed to execute pluck query", {
-        sql,
-        values,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const execute = async (strings, ...vars) => {
-    const { sql, values } = parseTemplate(strings, ...vars);
-    try {
-      await connection.run(sql, 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 reader = await connection.runAndReadAll(sql, args);
-      const rows = convertBigInts(reader.getRowObjects());
-      return {
-        command: sql.split(" ")[0].toUpperCase(),
-        rowCount: rows.length,
-        oid: null,
-        fields: rows.length > 0 ? Object.keys(rows[0]).map((name) => ({
-          name,
-          tableID: 0,
-          columnID: 0,
-          dataTypeID: 0,
-          dataTypeSize: -1,
-          dataTypeModifier: -1,
-          format: "text"
-        })) : [],
-        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 syncSchema = async (schema) => {
-    const statements = schema.trim().split(";").filter((stmt) => stmt.trim() !== "");
-    const createTableStatements = [];
-    const indexStatements = [];
-    for (const stmt of statements) {
-      const trimmed = stmt.trim();
-      if (!trimmed) continue;
-      if (trimmed.startsWith("CREATE INDEX") || trimmed.startsWith("CREATE UNIQUE INDEX")) {
-        indexStatements.push(trimmed);
-      } else if (trimmed.startsWith("CREATE TABLE")) {
-        createTableStatements.push(trimmed);
-      }
-    }
-    for (const ddl of createTableStatements) {
-      const { ddl: transformedDDL, indexes: remainingIndexes } = convertUniqueIndexesToInlineConstraints(ddl, indexStatements);
-      try {
-        await connection.run(transformedDDL);
-      } catch (e) {
-        console.error("Schema sync error (CREATE TABLE):", e);
-      }
-      for (const indexSQL of remainingIndexes) {
-        try {
-          await connection.run(indexSQL);
-        } catch (e) {
-          console.error("Schema sync error (CREATE INDEX):", e);
-        }
-      }
-    }
-  };
-  const initializeSchemas = async (options2) => {
-    const schemaManager = new DatabaseSchemaManager();
-    const currentDb = {
-      url,
-      client: connection,
-      query,
-      insert,
-      update,
-      upsert,
-      get,
-      list,
-      getOrInsert,
-      delete: deleteRecords,
-      count,
-      table,
-      tableExists,
-      many,
-      single,
-      pluck,
-      execute,
-      oo,
-      oO,
-      ox,
-      xx,
-      syncSchema
-    };
-    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
-          column_name,
-          data_type,
-          is_nullable,
-          column_default
-        FROM information_schema.columns
-        WHERE table_name = ${table2}
-        ORDER BY ordinal_position
-      `;
-      const pkRows = await many`
-        SELECT column_name
-        FROM duckdb_constraints() con
-        JOIN duckdb_columns() cols
-          ON con.table_oid = cols.table_oid
-        WHERE con.table_name = ${table2}
-          AND con.constraint_type = 'PRIMARY KEY'
-          AND cols.column_name = ANY(con.constraint_column_names)
-      `;
-      const pkColumns = new Set(pkRows.map((row) => row.column_name));
-      const columns = {};
-      for (const row of columnRows) {
-        const colName = row.column_name;
-        columns[colName] = {
-          type: row.data_type,
-          primaryKey: pkColumns.has(colName),
-          notNull: row.is_nullable === "NO",
-          defaultValue: row.column_default
-        };
-      }
-      const indexRows = await many`
-        SELECT
-          index_name,
-          sql
-        FROM duckdb_indexes()
-        WHERE table_name = ${table2}
-          AND NOT is_primary
-      `;
-      const indexes = [];
-      for (const row of indexRows) {
-        const indexName = row.index_name;
-        const indexDef = row.sql || "";
-        const colMatch = indexDef.match(/\(([^)]+)\)/);
-        const indexColumns = colMatch ? colMatch[1].split(",").map((col) => col.trim()) : [];
-        const isUnique = indexDef.toUpperCase().includes("UNIQUE");
-        indexes.push({
-          name: indexName,
-          columns: indexColumns,
-          unique: isUnique
-        });
-      }
-      const fkRows = await many`
-        SELECT
-          constraint_column_names,
-          constraint_column_indexes,
-          constraint_text
-        FROM duckdb_constraints()
-        WHERE table_name = ${table2}
-          AND constraint_type = 'FOREIGN KEY'
-      `;
-      const foreignKeys = [];
-      for (const fkRow of fkRows) {
-        const fkText = fkRow.constraint_text || "";
-        const referencesMatch = fkText.match(
-          /REFERENCES\s+(\w+)\s*\(([^)]+)\)/i
-        );
-        if (referencesMatch && Array.isArray(fkRow.constraint_column_names) && fkRow.constraint_column_names.length > 0) {
-          const columnName = fkRow.constraint_column_names[0];
-          const referencedTable = referencesMatch[1];
-          const referencedColumn = referencesMatch[2].trim();
-          const onDeleteMatch = fkText.match(/ON DELETE\s+(\w+)/i);
-          const onUpdateMatch = fkText.match(/ON UPDATE\s+(\w+)/i);
-          foreignKeys.push({
-            column: columnName,
-            referencesTable: referencedTable,
-            referencesColumn: referencedColumn,
-            onDelete: onDeleteMatch ? onDeleteMatch[1] : void 0,
-            onUpdate: onUpdateMatch ? onUpdateMatch[1] : void 0
-          });
-        }
-      }
-      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, "duckdb");
-        await connection.run(sql);
-      } 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 connection.run(sql);
-      } catch (e) {
-        throw new DatabaseError("Failed to create index on table", {
-          table: table2,
-          index: index.name,
-          originalError: formatDbError(e)
-        });
-      }
-    }
-  };
-  const transaction = async (callback) => {
-    try {
-      await connection.run("BEGIN TRANSACTION");
-      const txDb = {
-        url,
-        client: connection,
-        insert,
-        get,
-        list,
-        update,
-        upsert,
-        getOrInsert,
-        delete: deleteRecords,
-        count,
-        table,
-        many,
-        single,
-        pluck,
-        execute,
-        query,
-        oo,
-        oO,
-        ox,
-        xx,
-        tableExists,
-        syncSchema,
-        transaction
-      };
-      const result = await callback(txDb);
-      await connection.run("COMMIT");
-      return result;
-    } catch (error) {
-      await connection.run("ROLLBACK");
-      throw error;
-    }
-  };
-  const beginTransaction = async () => {
-    await connection.run("BEGIN TRANSACTION");
-    let active = true;
-    const commit = async () => {
-      if (!active) {
-        throw new DatabaseError("Transaction already ended", {});
-      }
-      await connection.run("COMMIT");
-      active = false;
-    };
-    const rollback = async () => {
-      if (!active) {
-        throw new DatabaseError("Transaction already ended", {});
-      }
-      await connection.run("ROLLBACK");
-      active = false;
-    };
-    const isActive = () => active;
-    const txHandle = {
-      url,
-      client: connection,
-      insert,
-      get,
-      list,
-      update,
-      upsert,
-      getOrInsert,
-      delete: deleteRecords,
-      count,
-      table,
-      many,
-      single,
-      pluck,
-      execute,
-      query,
-      oo,
-      oO,
-      ox,
-      xx,
-      tableExists,
-      syncSchema,
-      transaction,
-      commit,
-      rollback,
-      isActive
-    };
-    return txHandle;
-  };
-  return {
-    url,
-    requiresSchemaCheck: true,
-    client: connection,
-    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,
-    // DuckDB-specific export method
-    exportTable
-  };
-}
-export {
-  getDatabase
-};
-//# sourceMappingURL=duckdb-B6m78QdL.js.map