@happyvertical/sql 0.79.0 → 0.80.1

package/dist/chunks/index-CzdYvRFp.js

@@ -1,3692 +0,0 @@
-import { DatabaseError, loadEnvConfig } from "@happyvertical/utils";
-import { r as redactDatabaseUrl } from "./postgres-cli-Cr6bBZ3q.js";
-import { mkdir, readdir } from "node:fs/promises";
-import { join, extname, basename } from "node:path";
-import { Pool } from "pg";
-function formatDbError(error) {
-  const dbError = error;
-  const parts = [];
-  if (dbError.message) parts.push(dbError.message);
-  if (dbError.code) parts.push(`code=${dbError.code}`);
-  if (dbError.detail) parts.push(`detail=${dbError.detail}`);
-  if (dbError.hint) parts.push(`hint=${dbError.hint}`);
-  if (dbError.severity) parts.push(`severity=${dbError.severity}`);
-  if (dbError.errno !== void 0) parts.push(`errno=${dbError.errno}`);
-  return parts.length > 0 ? parts.join(", ") : String(error);
-}
-const VALID_OPERATORS = {
-  "=": "=",
-  ">": ">",
-  ">=": ">=",
-  "<": "<",
-  "<=": "<=",
-  "!=": "!=",
-  like: "LIKE",
-  in: "IN",
-  "not in": "NOT IN"
-};
-function isSimpleSqlIdentifier(field) {
-  return /^[a-zA-Z0-9_.]+$/.test(field);
-}
-function parseConditionKey(fullKey) {
-  const trimmed = fullKey.trim();
-  const lower = trimmed.toLowerCase();
-  const operators = ["not in", "like", "in", "!=", ">=", "<=", ">", "<", "="];
-  for (const operator of operators) {
-    if (lower.endsWith(` ${operator}`)) {
-      return {
-        field: trimmed.slice(0, -(operator.length + 1)).trim(),
-        operator,
-        explicitOperator: true
-      };
-    }
-  }
-  return { field: trimmed, operator: "=", explicitOperator: false };
-}
-const buildCondition = (fullKey, value, currIndex, adapterType) => {
-  const { field, operator, explicitOperator } = parseConditionKey(fullKey);
-  if (!explicitOperator && !isSimpleSqlIdentifier(field)) {
-    throw new Error(`Invalid SQL identifier: ${field}`);
-  }
-  const sqlOperator = VALID_OPERATORS[operator] || "=";
-  const values = [];
-  let sql;
-  if (value === null) {
-    sql = `${field} IS ${sqlOperator === "=" ? "NULL" : "NOT NULL"}`;
-  } else if ((sqlOperator === "IN" || sqlOperator === "NOT IN") && Array.isArray(value)) {
-    if (value.length === 0) {
-      throw new Error(`${sqlOperator} requires at least one value`);
-    }
-    const placeholders = value.map(() => `$${currIndex.value++}`).join(", ");
-    sql = `${field} ${sqlOperator} (${placeholders})`;
-    values.push(...value);
-  } else if (value instanceof Date) {
-    const needsCast = adapterType === "duckdb" || adapterType === "json";
-    if (needsCast) {
-      sql = `${field} ${sqlOperator} CAST($${currIndex.value++} AS TIMESTAMP)`;
-    } else {
-      sql = `${field} ${sqlOperator} $${currIndex.value++}`;
-    }
-    values.push(value.toISOString());
-  } else {
-    sql = `${field} ${sqlOperator} $${currIndex.value++}`;
-    values.push(value);
-  }
-  return { sql, values };
-};
-const buildWhere = (where, startIndex = 1, adapterType) => {
-  let sql = "";
-  const values = [];
-  const currIndex = { value: startIndex };
-  if (Array.isArray(where)) {
-    if (where.length === 0) {
-      return { sql: "", values: [] };
-    }
-    const orGroups = [];
-    for (const andGroup of where) {
-      if (!Array.isArray(andGroup) || andGroup.length === 0) {
-        continue;
-      }
-      const andConditions = [];
-      for (const conditionObj of andGroup) {
-        for (const [fullKey, value] of Object.entries(conditionObj)) {
-          const result = buildCondition(fullKey, value, currIndex, adapterType);
-          andConditions.push(result.sql);
-          values.push(...result.values);
-        }
-      }
-      if (andConditions.length > 0) {
-        orGroups.push(`(${andConditions.join(" AND ")})`);
-      }
-    }
-    if (orGroups.length > 0) {
-      sql = `WHERE ${orGroups.join(" OR ")}`;
-    }
-    return { sql, values };
-  }
-  if (where && Object.keys(where).length > 0) {
-    sql = "WHERE ";
-    for (const [fullKey, value] of Object.entries(where)) {
-      const result = buildCondition(fullKey, value, currIndex, adapterType);
-      if (sql !== "WHERE ") {
-        sql += " AND ";
-      }
-      sql += result.sql;
-      values.push(...result.values);
-    }
-  }
-  return { sql, values };
-};
-const VALID_DIRECTIONS = /* @__PURE__ */ new Set(["ASC", "DESC"]);
-const VALID_BUCKET_UNITS = /* @__PURE__ */ new Set([
-  "minute",
-  "hour",
-  "day",
-  "week",
-  "month",
-  "quarter",
-  "year"
-]);
-function validateSqlIdentifier(identifier) {
-  if (!/^[a-zA-Z0-9_.]+$/.test(identifier)) {
-    throw new Error(`Invalid SQL identifier: ${identifier}`);
-  }
-  return identifier;
-}
-function normalizeAdapter(adapterType) {
-  return adapterType ?? "sqlite";
-}
-function placeholder(index2) {
-  return `$${index2}`;
-}
-function bucketExpr(adapterType, unit, column) {
-  if (!VALID_BUCKET_UNITS.has(unit)) {
-    throw new Error(`Invalid aggregate bucket unit: ${unit}`);
-  }
-  const col = validateSqlIdentifier(column);
-  const adapter = normalizeAdapter(adapterType);
-  if (adapter === "postgres" || adapter === "duckdb" || adapter === "json") {
-    return `date_trunc('${unit}', ${col})`;
-  }
-  switch (unit) {
-    case "minute":
-      return `strftime('%Y-%m-%d %H:%M:00', ${col})`;
-    case "hour":
-      return `strftime('%Y-%m-%d %H:00:00', ${col})`;
-    case "day":
-      return `strftime('%Y-%m-%d 00:00:00', ${col})`;
-    case "week":
-      return `strftime('%Y-%m-%d 00:00:00', date(${col}, printf('-%d days', (CAST(strftime('%w', ${col}) AS INTEGER) + 6) % 7)))`;
-    case "month":
-      return `strftime('%Y-%m-01 00:00:00', ${col})`;
-    case "quarter":
-      return `strftime('%Y-%m-%d 00:00:00', date(strftime('%Y-', ${col}) || printf('%02d', ((CAST(strftime('%m', ${col}) AS INTEGER) - 1) / 3) * 3 + 1) || '-01'))`;
-    case "year":
-      return `strftime('%Y-01-01 00:00:00', ${col})`;
-  }
-}
-function aggregateExpression(expr) {
-  const normalizedFn = String(expr.fn).toLowerCase();
-  const fn = validateSqlIdentifier(String(expr.fn)).toUpperCase();
-  if (normalizedFn === "count" && !expr.column) {
-    if (expr.distinct) {
-      throw new Error(`Aggregate ${expr.fn} with distinct requires a column`);
-    }
-    return "COUNT(*)";
-  }
-  if (!expr.column) {
-    throw new Error(`Aggregate ${expr.fn} requires a column`);
-  }
-  const col = validateSqlIdentifier(expr.column);
-  const distinct = expr.distinct ? "DISTINCT " : "";
-  return `${fn}(${distinct}${col})`;
-}
-function selectExpression(expr, adapterType) {
-  if ("column" in expr && !("fn" in expr) && !("bucket" in expr)) {
-    const column = validateSqlIdentifier(expr.column);
-    const alias2 = validateSqlIdentifier(expr.as ?? expr.column);
-    return { expression: column, alias: alias2, groupingCandidate: true };
-  }
-  if ("bucket" in expr) {
-    const expression2 = bucketExpr(adapterType, expr.bucket, expr.column);
-    const alias2 = validateSqlIdentifier(expr.as);
-    return { expression: expression2, alias: alias2, groupingCandidate: true };
-  }
-  const expression = aggregateExpression(expr);
-  const alias = validateSqlIdentifier(expr.as);
-  return { expression, alias, groupingCandidate: false };
-}
-function validateWhereShape(where) {
-  if (!where) return;
-  const validateKey = (key) => {
-    const { field } = parseConditionKey(key);
-    if (field) validateSqlIdentifier(field);
-  };
-  if (Array.isArray(where)) {
-    for (const andGroup of where) {
-      for (const condition of andGroup) {
-        for (const key of Object.keys(condition)) validateKey(key);
-      }
-    }
-    return;
-  }
-  for (const key of Object.keys(where)) validateKey(key);
-}
-function expandHavingKey(key, expressionByAlias) {
-  const parsed = parseConditionKey(key);
-  const expression = expressionByAlias.get(parsed.field) ?? validateSqlIdentifier(parsed.field);
-  return `${expression} ${parsed.operator}`;
-}
-function expandHaving(having, expressionByAlias) {
-  const expandCondition = (condition) => Object.fromEntries(
-    Object.entries(condition).map(([key, value]) => [
-      expandHavingKey(key, expressionByAlias),
-      value
-    ])
-  );
-  if (Array.isArray(having)) {
-    return having.map(
-      (andGroup) => andGroup.map(
-        (condition) => expandCondition(condition)
-      )
-    );
-  }
-  return expandCondition(having);
-}
-function buildHaving(having, expressionByAlias, startIndex, adapterType) {
-  if (!having) return { sql: "", values: [] };
-  const expanded = expandHaving(having, expressionByAlias);
-  const built = buildWhere(expanded, startIndex, adapterType);
-  return {
-    sql: built.sql ? built.sql.replace(/^WHERE/, "HAVING") : "",
-    values: built.values
-  };
-}
-function buildOrderBy(orderBy) {
-  if (!orderBy) return "";
-  const items = Array.isArray(orderBy) ? orderBy : [orderBy];
-  const parts = items.map((item) => {
-    const [field, direction = "ASC"] = item.trim().split(/\s+/);
-    const normalizedDirection = direction.toUpperCase();
-    if (!VALID_DIRECTIONS.has(normalizedDirection)) {
-      throw new Error(`Invalid aggregate order direction: ${direction}`);
-    }
-    const orderExpr = validateSqlIdentifier(field);
-    return `${orderExpr} ${normalizedDirection}`;
-  });
-  return `ORDER BY ${parts.join(", ")}`;
-}
-function buildAggregate(spec, startIndex = 1, adapterType) {
-  const from = validateSqlIdentifier(spec.from);
-  if (spec.select.length === 0) {
-    throw new Error(
-      "AggregateSpec.select must contain at least one expression"
-    );
-  }
-  validateWhereShape(spec.where);
-  const expressionByAlias = /* @__PURE__ */ new Map();
-  const groupingAliases = [];
-  const selectSql = spec.select.map((expr) => {
-    const selected = selectExpression(expr, adapterType);
-    expressionByAlias.set(selected.alias, selected.expression);
-    if (selected.groupingCandidate) {
-      groupingAliases.push(selected.alias);
-    }
-    return `${selected.expression} AS ${selected.alias}`;
-  });
-  const where = spec.where ? buildWhere(spec.where, startIndex, adapterType) : { sql: "", values: [] };
-  let nextParamIndex = startIndex + where.values.length;
-  const groupByItems = spec.groupBy ?? groupingAliases;
-  const groupBySql = groupByItems.length > 0 ? `GROUP BY ${groupByItems.map(
-    (item) => expressionByAlias.has(item) ? expressionByAlias.get(item) : validateSqlIdentifier(item)
-  ).join(", ")}` : "";
-  const having = buildHaving(
-    spec.having,
-    expressionByAlias,
-    nextParamIndex,
-    adapterType
-  );
-  nextParamIndex += having.values.length;
-  const orderBySql = buildOrderBy(spec.orderBy);
-  const pagingValues = [];
-  const pagingSql = [];
-  if (spec.limit !== void 0) {
-    pagingSql.push(`LIMIT ${placeholder(nextParamIndex++)}`);
-    pagingValues.push(spec.limit);
-  } else if (spec.offset !== void 0 && normalizeAdapter(adapterType) === "sqlite") {
-    pagingSql.push("LIMIT -1");
-  }
-  if (spec.offset !== void 0) {
-    pagingSql.push(`OFFSET ${placeholder(nextParamIndex++)}`);
-    pagingValues.push(spec.offset);
-  }
-  const sql = [
-    `SELECT ${selectSql.join(", ")}`,
-    `FROM ${from}`,
-    where.sql,
-    groupBySql,
-    having.sql,
-    orderBySql,
-    pagingSql.join(" ")
-  ].filter(Boolean).join(" ");
-  return {
-    sql,
-    values: [...where.values, ...having.values, ...pagingValues]
-  };
-}
-function parseIndexStatement(indexSQL) {
-  const trimmed = indexSQL.trim();
-  const match = trimmed.match(
-    /CREATE\s+(UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s+ON\s+(?:"?\w+"?)\s*\(([^)]+)\)/i
-  );
-  if (!match) {
-    return null;
-  }
-  const [, uniqueKeyword, name, columnsStr] = match;
-  const columns = columnsStr.split(",").map((col) => col.trim().replace(/^"|"$/g, ""));
-  return {
-    name,
-    columns,
-    unique: Boolean(uniqueKeyword),
-    sql: trimmed
-  };
-}
-function convertUniqueIndexesToInlineConstraints(ddl, indexes) {
-  if (!indexes || indexes.length === 0) {
-    return { ddl, indexes: [] };
-  }
-  const parsedIndexes = indexes.map(parseIndexStatement).filter((idx) => idx !== null);
-  const uniqueIndexes = parsedIndexes.filter((idx) => idx.unique);
-  const regularIndexes = parsedIndexes.filter((idx) => !idx.unique);
-  if (uniqueIndexes.length === 0) {
-    return { ddl, indexes };
-  }
-  const lines = ddl.split("\n");
-  let closingParenIndex = -1;
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const trimmed = lines[i].trim();
-    if (trimmed === ")" || trimmed.startsWith(");")) {
-      closingParenIndex = i;
-      break;
-    }
-  }
-  if (closingParenIndex === -1) {
-    console.warn(
-      "[duckdb-schema-utils] Could not find closing parenthesis in CREATE TABLE statement"
-    );
-    return { ddl, indexes };
-  }
-  const uniqueConstraints = uniqueIndexes.map((idx) => {
-    const columns = idx.columns.map((col) => `"${col}"`).join(", ");
-    return `  UNIQUE(${columns})`;
-  });
-  const modifiedLines = [...lines];
-  modifiedLines[closingParenIndex].trim();
-  if (closingParenIndex > 0) {
-    const prevLine = modifiedLines[closingParenIndex - 1].trim();
-    if (!prevLine.endsWith(",")) {
-      modifiedLines[closingParenIndex - 1] = modifiedLines[closingParenIndex - 1].replace(/\s*$/, ",");
-    }
-  }
-  const constraintLines = uniqueConstraints.map((constraint, idx) => {
-    return idx < uniqueConstraints.length - 1 ? `${constraint},` : constraint;
-  });
-  modifiedLines.splice(closingParenIndex, 0, ...constraintLines);
-  const transformedDDL = modifiedLines.join("\n");
-  const remainingIndexes = regularIndexes.map((idx) => idx.sql);
-  return {
-    ddl: transformedDDL,
-    indexes: remainingIndexes
-  };
-}
-async function runDoctor(options) {
-  assertPostgresAdapter(options.db);
-  const tables = await listPublicTables(options.db);
-  const issues = [];
-  for (const check of options.checks) {
-    const checkIssues = await check({ db: options.db, tables });
-    issues.push(...checkIssues);
-  }
-  return {
-    failures: issues.filter((issue) => issue.level === "fail"),
-    warnings: issues.filter((issue) => issue.level === "warn"),
-    issues
-  };
-}
-function assertPostgresAdapter(db) {
-  const url = String(db.url ?? "");
-  if (!url.startsWith("postgres://") && !url.startsWith("postgresql://")) {
-    throw new Error(
-      `runDoctor requires a Postgres database connection. Got URL: ${url ? redactDatabaseUrl(url) : "(empty)"}. The bundled check builders use Postgres-specific syntax (pg_tables, ::int/::text casts).`
-    );
-  }
-}
-function checkExpectedTables(expected) {
-  return async ({ tables }) => {
-    const issues = [];
-    for (const table of expected) {
-      if (!tables.has(table)) {
-        issues.push({
-          level: "warn",
-          message: `Missing expected table: ${table}`
-        });
-      }
-    }
-    return issues;
-  };
-}
-function checkUniqueColumn(spec) {
-  return async ({ db, tables }) => {
-    if (!tables.has(spec.table)) return [];
-    const result = await db.query(`
-      SELECT ${quoteIdentifier(spec.column)} AS value, count(*)::text AS count
-      FROM ${quoteIdentifier(spec.table)}
-      WHERE NULLIF(trim(${quoteIdentifier(spec.column)}::text), '') IS NOT NULL
-      GROUP BY ${quoteIdentifier(spec.column)}
-      HAVING count(*) > 1
-      ORDER BY count DESC, ${quoteIdentifier(spec.column)}
-    `);
-    return result.rows.map((row) => ({
-      level: "fail",
-      message: `Duplicate ${spec.label} "${String(row.value)}" in ${spec.table} (${countValueFromRow(
-        row.count
-      )} rows).`
-    }));
-  };
-}
-function checkRelationship(spec) {
-  return async ({ db, tables }) => {
-    if (!tables.has(spec.childTable) || !tables.has(spec.parentTable))
-      return [];
-    const parentColumn = spec.parentColumn ?? "id";
-    const result = await db.query(`
-      SELECT count(*)::text AS count
-      FROM ${quoteIdentifier(spec.childTable)} child
-      LEFT JOIN ${quoteIdentifier(spec.parentTable)} parent
-        ON parent.${quoteIdentifier(parentColumn)} = child.${quoteIdentifier(spec.childColumn)}
-      WHERE NULLIF(trim(child.${quoteIdentifier(spec.childColumn)}::text), '') IS NOT NULL
-        AND parent.${quoteIdentifier(parentColumn)} IS NULL
-    `);
-    const orphanCount = countValueFromRow(result.rows[0]?.count);
-    if (orphanCount === "0") return [];
-    return [
-      {
-        level: "fail",
-        message: `${spec.label}: ${orphanCount} orphaned row${orphanCount === "1" ? "" : "s"}.`
-      }
-    ];
-  };
-}
-async function listPublicTables(db) {
-  const result = await db.query(
-    "SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename"
-  );
-  return new Set(result.rows.map((row) => String(row.tablename ?? "")));
-}
-function quoteIdentifier(value) {
-  return `"${value.replace(/"/gu, '""')}"`;
-}
-function countValueFromRow(value) {
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "bigint") {
-    return String(value);
-  }
-  return "0";
-}
-class DatabaseSchemaManager {
-  static initializationLock = /* @__PURE__ */ new Map();
-  initializedSchemas = /* @__PURE__ */ new Set();
-  schemaVersions = /* @__PURE__ */ new Map();
-  /**
-   * Initializes database schemas from a JSON manifest with dependency resolution
-   *
-   * Schemas are topologically sorted by their declared dependencies and
-   * initialized in order. Supports legacy raw-SQL schemas via the `schema` option,
-   * JSON manifests via the `manifest` option, and schema overrides for extending
-   * base schemas.
-   *
-   * @param db - Database interface to execute DDL against
-   * @param options - Schema initialization options (manifest, overrides, force, debug)
-   * @returns Result with lists of initialized/skipped schemas, errors, and execution time
-   */
-  async initializeSchemas(db, options) {
-    const startTime = Date.now();
-    const result = {
-      initialized: [],
-      skipped: [],
-      errors: [],
-      executionTime: 0
-    };
-    try {
-      let schemas = {};
-      if (options.schema) {
-        console.log(
-          "[schema] Legacy SQL schema provided, converting to manifest format"
-        );
-        if (db.syncSchema) {
-          await db.syncSchema(options.schema);
-          result.initialized.push("legacy-sql");
-        }
-        result.executionTime = Date.now() - startTime;
-        return result;
-      }
-      if (options.manifest) {
-        schemas = { ...options.manifest.schemas };
-      }
-      if (options.overrides) {
-        schemas = { ...schemas, ...options.overrides };
-      }
-      if (Object.keys(schemas).length === 0) {
-        console.warn("[schema] No schemas provided for initialization");
-        result.executionTime = Date.now() - startTime;
-        return result;
-      }
-      const dependencyGraph = this.buildDependencyGraph(schemas);
-      const initializationOrder = this.resolveDependencies(dependencyGraph);
-      if (options.debug) {
-        console.log("[schema] Initialization order:", initializationOrder);
-      }
-      for (const schemaName of initializationOrder) {
-        const schema = schemas[schemaName];
-        if (!schema) continue;
-        try {
-          await this.initializeSchema(db, schemaName, schema, {
-            force: options.force,
-            debug: options.debug
-          });
-          result.initialized.push(schemaName);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          result.errors.push({ schema: schemaName, error: errorMessage });
-          if (options.debug) {
-            console.error(
-              `[schema] Failed to initialize ${schemaName}:`,
-              error
-            );
-          }
-        }
-      }
-      result.executionTime = Date.now() - startTime;
-      if (options.debug) {
-        console.log("[schema] Initialization complete:", result);
-      }
-      return result;
-    } catch (error) {
-      result.executionTime = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      result.errors.push({
-        schema: "dependency-resolution",
-        error: errorMessage
-      });
-      return result;
-    }
-  }
-  /**
-   * Initialize a single schema
-   */
-  async initializeSchema(db, schemaName, schema, options) {
-    const { tableName, version } = schema;
-    const lockKey = `${schemaName}:${tableName}`;
-    if (DatabaseSchemaManager.initializationLock.has(lockKey)) {
-      await DatabaseSchemaManager.initializationLock.get(lockKey);
-      return;
-    }
-    if (!options.force && this.isSchemaUpToDate(schemaName, version)) {
-      if (options.debug) {
-        console.log(`[schema] Skipping ${schemaName} - already up to date`);
-      }
-      return;
-    }
-    const initPromise = this.performSchemaInitialization(
-      db,
-      schemaName,
-      schema,
-      options
-    );
-    DatabaseSchemaManager.initializationLock.set(lockKey, initPromise);
-    try {
-      await initPromise;
-      this.markSchemaInitialized(schemaName, version);
-    } finally {
-      DatabaseSchemaManager.initializationLock.delete(lockKey);
-    }
-  }
-  /**
-   * Perform the actual schema initialization
-   */
-  async performSchemaInitialization(db, schemaName, schema, options) {
-    const { tableName, columns, indexes, triggers } = schema;
-    if (options.debug) {
-      console.log(`[schema] Initializing ${schemaName} (${tableName})`);
-    }
-    const tableExists2 = await db.tableExists(tableName);
-    if (!tableExists2) {
-      await this.createTable(db, schema);
-      for (const index2 of indexes) {
-        await this.createIndex(db, tableName, index2);
-      }
-      for (const trigger of triggers) {
-        await this.createTrigger(db, trigger);
-      }
-    } else if (options.force) {
-      await db.query(`DROP TABLE IF EXISTS ${tableName}`);
-      await this.createTable(db, schema);
-      for (const index2 of indexes) {
-        await this.createIndex(db, tableName, index2);
-      }
-      for (const trigger of triggers) {
-        await this.createTrigger(db, trigger);
-      }
-    } else {
-      await this.updateSchemaIfNeeded(db, schema);
-    }
-  }
-  /**
-   * Create table from schema definition
-   */
-  async createTable(db, schema) {
-    const { tableName, columns, foreignKeys } = schema;
-    const columnDefinitions = [];
-    for (const [columnName, columnDef] of Object.entries(columns)) {
-      let def = `${columnName} ${columnDef.type}`;
-      if (columnDef.primaryKey) def += " PRIMARY KEY";
-      if (columnDef.unique && !columnDef.primaryKey) def += " UNIQUE";
-      if (columnDef.notNull) def += " NOT NULL";
-      if (columnDef.defaultValue !== void 0) {
-        def += ` DEFAULT ${columnDef.defaultValue}`;
-      }
-      if (columnDef.check) def += ` CHECK (${columnDef.check})`;
-      columnDefinitions.push(def);
-    }
-    for (const fk of foreignKeys) {
-      let fkDef = `FOREIGN KEY (${fk.column}) REFERENCES ${fk.referencesTable}(${fk.referencesColumn})`;
-      if (fk.onDelete) fkDef += ` ON DELETE ${fk.onDelete}`;
-      if (fk.onUpdate) fkDef += ` ON UPDATE ${fk.onUpdate}`;
-      columnDefinitions.push(fkDef);
-    }
-    const createTableSQL = `CREATE TABLE ${tableName} (
-  ${columnDefinitions.join(",\n  ")}
-)`;
-    await db.query(createTableSQL);
-  }
-  /**
-   * Create index from definition
-   */
-  async createIndex(db, tableName, index2) {
-    const uniqueClause = index2.unique ? "UNIQUE " : "";
-    const whereClause = index2.where ? ` WHERE ${index2.where}` : "";
-    const createIndexSQL = `CREATE ${uniqueClause}INDEX ${index2.name} ON ${tableName} (${index2.columns.join(", ")})${whereClause}`;
-    await db.query(createIndexSQL);
-  }
-  /**
-   * Create trigger from definition
-   */
-  async createTrigger(db, trigger) {
-    const conditionClause = trigger.condition ? ` WHEN ${trigger.condition}` : "";
-    const createTriggerSQL = `CREATE TRIGGER ${trigger.name} ${trigger.when} ${trigger.event} ON ${trigger.table}${conditionClause} BEGIN ${trigger.body} END`;
-    await db.query(createTriggerSQL);
-  }
-  /**
-   * Update schema if changes are detected
-   */
-  async updateSchemaIfNeeded(_db, schema) {
-    console.log(
-      `[schema] Schema update logic not yet implemented for ${schema.tableName}`
-    );
-  }
-  /**
-   * Build dependency graph from schemas
-   */
-  buildDependencyGraph(schemas) {
-    const graph = /* @__PURE__ */ new Map();
-    for (const [schemaName, schema] of Object.entries(schemas)) {
-      const dependencies = schema.dependencies.filter(
-        (dep) => Object.values(schemas).some((s) => s.tableName === dep)
-      );
-      graph.set(
-        schemaName,
-        dependencies.map(
-          (dep) => Object.entries(schemas).find(
-            ([_, s]) => s.tableName === dep
-          )?.[0] || dep
-        )
-      );
-    }
-    return graph;
-  }
-  /**
-   * Resolve dependencies using topological sort
-   */
-  resolveDependencies(graph) {
-    const resolved = [];
-    const visited = /* @__PURE__ */ new Set();
-    const visiting = /* @__PURE__ */ new Set();
-    const visit = (node) => {
-      if (visiting.has(node)) {
-        throw new Error(`Circular dependency detected involving ${node}`);
-      }
-      if (visited.has(node)) return;
-      visiting.add(node);
-      const dependencies = graph.get(node) || [];
-      for (const dep of dependencies) {
-        if (graph.has(dep)) {
-          visit(dep);
-        }
-      }
-      visiting.delete(node);
-      visited.add(node);
-      resolved.push(node);
-    };
-    for (const node of graph.keys()) {
-      if (!visited.has(node)) {
-        visit(node);
-      }
-    }
-    return resolved;
-  }
-  /**
-   * Check if schema is up to date
-   */
-  isSchemaUpToDate(schemaName, version) {
-    return this.initializedSchemas.has(schemaName) && this.schemaVersions.get(schemaName) === version;
-  }
-  /**
-   * Mark schema as initialized
-   */
-  markSchemaInitialized(schemaName, version) {
-    this.initializedSchemas.add(schemaName);
-    this.schemaVersions.set(schemaName, version);
-  }
-  /**
-   * Reset initialization state (for testing)
-   */
-  reset() {
-    this.initializedSchemas.clear();
-    this.schemaVersions.clear();
-    DatabaseSchemaManager.initializationLock.clear();
-  }
-}
-function resolveSchemas(schemas) {
-  if (!schemas) return void 0;
-  if (typeof schemas === "function") return schemas();
-  return schemas;
-}
-globalThis.__haveSqlMemoryConnectionCache ??= /* @__PURE__ */ new Map();
-const memoryConnectionCache = globalThis.__haveSqlMemoryConnectionCache;
-globalThis.__haveSqlPendingConnections ??= /* @__PURE__ */ new Map();
-const pendingConnections$1 = globalThis.__haveSqlPendingConnections;
-function clearConnectionCache() {
-  memoryConnectionCache.clear();
-  pendingConnections$1.clear();
-}
-async function createJSONConnection(options) {
-  const { url, autoRegister = true, eagerLoadTables = true } = options;
-  const schemas = resolveSchemas(options.schemas) ?? {};
-  if (!url) {
-    throw new DatabaseError("url is required for JSON adapter", {
-      options
-    });
-  }
-  const pendingJSONFiles = /* @__PURE__ */ new Map();
-  const inferredSchemaTables = /* @__PURE__ */ new Set();
-  try {
-    const duckdbModule = "@duckdb/node-api";
-    const { DuckDBInstance } = await import(
-      /* @vite-ignore */
-      duckdbModule
-    );
-    const instance = await DuckDBInstance.create(":memory:");
-    const connection = await instance.connect();
-    try {
-      await mkdir(url, { recursive: true });
-    } catch (_error) {
-    }
-    if (autoRegister) {
-      await loadJSONTables(
-        connection,
-        url,
-        schemas,
-        pendingJSONFiles,
-        eagerLoadTables,
-        inferredSchemaTables
-      );
-    }
-    return { connection, pendingJSONFiles, inferredSchemaTables };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new DatabaseError(
-      `Failed to create JSON database connection: ${errorMessage}`,
-      {
-        url,
-        originalError: errorMessage
-      }
-    );
-  }
-}
-async function loadJSONData(connection, tableName, filePath) {
-  try {
-    const { readFile } = await import("node:fs/promises");
-    const jsonContent = await readFile(filePath, "utf-8");
-    const records = JSON.parse(jsonContent);
-    if (Array.isArray(records) && records.length > 0) {
-      await insertRecordsWithCast(connection, tableName, records);
-      console.log(
-        `[json-adapter] Loaded ${records.length} records into ${tableName} from JSON`
-      );
-    }
-  } catch (error) {
-    console.warn(
-      `[json-adapter] Could not load data for ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-async function loadJSONTables(connection, dataDir, providedSchemas = {}, pendingJSONFiles = /* @__PURE__ */ new Map(), eagerLoadTables = true, inferredSchemaTables = /* @__PURE__ */ new Set()) {
-  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");
-      const schema = providedSchemas[tableName];
-      if (schema) {
-        console.log(
-          `[json-adapter] Creating ${tableName} with provided schema definition`
-        );
-        await createTableFromSchema(connection, tableName, schema);
-        await loadJSONData(connection, tableName, filePath);
-      } else {
-        const schemaPath = join(dataDir, `${tableName}.schema.sql`);
-        const { readFile, access } = await import("node:fs/promises");
-        const { constants } = await import("node:fs");
-        let schemaExists = false;
-        try {
-          await access(schemaPath, constants.F_OK);
-          schemaExists = true;
-        } catch {
-          schemaExists = false;
-        }
-        if (schemaExists) {
-          try {
-            const schemaDDL = await readFile(schemaPath, "utf-8");
-            await connection.run(schemaDDL);
-            await loadJSONData(connection, tableName, filePath);
-          } catch (error) {
-            console.warn(
-              `[json-adapter] Could not load ${tableName} with schema file: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        } else {
-          if (eagerLoadTables) {
-            try {
-              await connection.run(
-                `CREATE TABLE IF NOT EXISTS "${tableName}" AS SELECT * FROM read_json_auto('${filePath}')`
-              );
-              inferredSchemaTables.add(tableName);
-              console.log(
-                `[json-adapter] Eagerly created ${tableName} with inferred schema (no UNIQUE constraints)`
-              );
-            } catch (error) {
-              console.warn(
-                `[json-adapter] Could not eagerly load ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-              );
-            }
-          } else {
-            console.log(
-              `[json-adapter] Deferring ${tableName} - will load after syncSchema() creates table`
-            );
-          }
-          pendingJSONFiles.set(tableName, filePath);
-        }
-      }
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      console.error("[json-adapter] Error loading JSON tables:", error);
-      throw new DatabaseError(`Failed to load JSON tables from ${dataDir}`, {
-        dataDir,
-        originalError: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0
-      });
-    }
-  }
-}
-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) && "hugeint" in obj && Object.keys(obj).length === 1) {
-    return String(obj.hugeint);
-  }
-  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 createTableFromSchema(connection, tableName, schema) {
-  const ddlLines = schema.ddl.split("\n");
-  const createTableEnd = ddlLines.findIndex((line) => {
-    const trimmed = line.trim();
-    return trimmed === ")" || trimmed.startsWith(");");
-  });
-  if (createTableEnd === -1) {
-    throw new DatabaseError("Invalid schema DDL - no closing parenthesis", {
-      tableName,
-      ddl: schema.ddl
-    });
-  }
-  let createTableSQL = ddlLines.slice(0, createTableEnd + 1).join("\n");
-  createTableSQL = createTableSQL.replace(
-    /\b(\w+)\s+(TEXT|VARCHAR)\s+DEFAULT\s+''/g,
-    "$1 $2 DEFAULT CAST('' AS $2)"
-  );
-  createTableSQL = createTableSQL.replace(
-    /\b(\w+)\s+(TEXT|VARCHAR)\s+DEFAULT\s+NULL/g,
-    "$1 $2 DEFAULT CAST(NULL AS $2)"
-  );
-  const transformed = convertUniqueIndexesToInlineConstraints(
-    createTableSQL,
-    schema.indexes
-  );
-  createTableSQL = transformed.ddl;
-  const indexesToCreate = transformed.indexes;
-  try {
-    await connection.run(createTableSQL);
-    let existingColumns = /* @__PURE__ */ new Set();
-    try {
-      const schemaInfo = await connection.runAndReadAll(
-        `DESCRIBE ${tableName}`
-      );
-      const columns = schemaInfo.getRowObjects();
-      existingColumns = new Set(
-        columns.map((col) => col.column_name.toLowerCase())
-      );
-      console.log(`[json-adapter] Created ${tableName} with schema:`, {
-        columns: columns.map((col) => ({
-          name: col.column_name,
-          type: col.column_type,
-          null: col.null
-        }))
-      });
-    } catch (error) {
-      console.warn(
-        `[json-adapter] Could not verify schema for ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    if (schema.fields && existingColumns.size > 0) {
-      const fieldEntries = schema.fields instanceof Map ? Array.from(schema.fields.entries()) : Object.entries(schema.fields);
-      for (const [fieldName, fieldDef] of fieldEntries) {
-        const columnName = fieldName.toLowerCase();
-        if (!existingColumns.has(columnName)) {
-          const sqlType = fieldDef?.type || "TEXT";
-          try {
-            await connection.run(
-              `ALTER TABLE ${tableName} ADD COLUMN "${fieldName}" ${sqlType}`
-            );
-            console.log(
-              `[json-adapter] Added missing column '${fieldName}' (${sqlType}) to ${tableName}`
-            );
-          } catch (alterError) {
-            console.warn(
-              `[json-adapter] Could not add column '${fieldName}' to ${tableName}: ${alterError instanceof Error ? alterError.message : String(alterError)}`
-            );
-          }
-        }
-      }
-    }
-    if (indexesToCreate && indexesToCreate.length > 0) {
-      for (const indexSQL of indexesToCreate) {
-        try {
-          await connection.run(indexSQL);
-        } catch (error) {
-          console.warn(
-            `[json-adapter] Failed to create index: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    }
-  } catch (error) {
-    throw new DatabaseError("Failed to create table from schema", {
-      tableName,
-      sql: createTableSQL,
-      originalError: error instanceof Error ? error.message : String(error)
-    });
-  }
-}
-async function insertRecordsWithCast(connection, tableName, records) {
-  if (records.length === 0) return;
-  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) {
-        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 `CAST($${paramIdx++} AS TIMESTAMP)`;
-      } 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 ${tableName} (${keys.join(", ")}) VALUES ${placeholders}`;
-  await connection.run(sql, values);
-}
-function validateTableName$1(table) {
-  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
-    throw new DatabaseError(`Invalid table name: ${table}`, { table });
-  }
-}
-async function getDatabase$2(options) {
-  const cacheKey = options.dbid || `json:${options.url}:${options.writeStrategy || "immediate"}:${options.autoRegister !== false}`;
-  if (options.clearCache) {
-    memoryConnectionCache.delete(cacheKey);
-    pendingConnections$1.delete(cacheKey);
-  }
-  const cached = memoryConnectionCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const pending = pendingConnections$1.get(cacheKey);
-  if (pending) {
-    return pending;
-  }
-  const connectionPromise = (async () => {
-    const { connection, pendingJSONFiles, inferredSchemaTables } = await createJSONConnection(options);
-    const writeStrategy = options.writeStrategy || "immediate";
-    const { url } = options;
-    const insert = async (table2, data) => {
-      validateTableName$1(table2);
-      if (writeStrategy === "none") {
-        throw new DatabaseError(
-          "Cannot insert: write strategy is set to none (read-only mode)",
-          { table: table2, writeStrategy }
-        );
-      }
-      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) {
-            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 `CAST($${paramIdx++} AS TIMESTAMP)`;
-          } 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, url);
-        }
-        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) => {
-      validateTableName$1(table2);
-      const { sql: whereClause, values } = buildWhere(where, 1, "json");
-      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) => {
-      validateTableName$1(table2);
-      const { sql: whereClause, values } = buildWhere(where, 1, "json");
-      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) => {
-      validateTableName$1(table2);
-      if (writeStrategy === "none") {
-        throw new DatabaseError(
-          "Cannot update: write strategy is set to none (read-only mode)",
-          { table: table2, writeStrategy }
-        );
-      }
-      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,
-        "json"
-      );
-      const dataValues = Object.values(data).map(
-        (value) => value instanceof Date ? value.toISOString() : value
-      );
-      const sql = `UPDATE "${table2}" SET ${setClause} ${whereClause}`;
-      const values = [...dataValues, ...whereValues];
-      try {
-        await connection.run(sql, values);
-        if (writeStrategy === "immediate") {
-          await exportTableToJSON(connection, table2, url);
-        }
-        return { operation: "update", affected: 1 };
-      } catch (e) {
-        throw new DatabaseError("Failed to update records in table", {
-          table: table2,
-          sql,
-          values,
-          originalError: formatDbError(e)
-        });
-      }
-    };
-    const buildJSONValueExpression = (value, values, paramIdx) => {
-      if (value === null) {
-        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 `CAST($${paramIdx.value++} AS TIMESTAMP)`;
-      }
-      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 executeNullAwareJSONUpsert = 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 = buildJSONValueExpression(data[key], values, paramIdx);
-        return `"${key}" = ${valueExpr}`;
-      });
-      const { sql: whereClause, values: whereValues } = buildWhere(
-        conflictWhere,
-        paramIdx.value,
-        "json"
-      );
-      const sql = `UPDATE "${table2}" SET ${assignments.join(", ")} ${whereClause}`;
-      try {
-        await connection.run(sql, [...values, ...whereValues]);
-        if (writeStrategy === "immediate") {
-          await exportTableToJSON(connection, table2, url);
-        }
-        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) => {
-      validateTableName$1(table2);
-      if (writeStrategy === "none") {
-        throw new DatabaseError(
-          "Cannot upsert: write strategy is set to none (read-only mode)",
-          { table: table2, writeStrategy }
-        );
-      }
-      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 executeNullAwareJSONUpsert(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) {
-          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(`CAST($${paramIdx} AS TIMESTAMP)`);
-          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) {
-          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} = CAST($${paramIdx} AS TIMESTAMP)`);
-          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, url);
-        }
-        return { operation: "upsert", affected: 1 };
-      } catch (e) {
-        console.error("UPSERT failed:", {
-          table: table2,
-          sql,
-          values,
-          valueTypes: values.map((v) => `${typeof v} (${v})`),
-          conflictColumns,
-          error: formatDbError(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$1(table2);
-      if (writeStrategy === "none") {
-        throw new DatabaseError(
-          "Cannot delete: write strategy is set to none (read-only mode)",
-          { table: table2, writeStrategy }
-        );
-      }
-      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, "json");
-      const sql = `DELETE FROM "${table2}" ${whereClause}`;
-      try {
-        await connection.run(sql, values);
-        if (writeStrategy === "immediate") {
-          await exportTableToJSON(connection, table2, url);
-        }
-        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$1(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, "json");
-        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 tableExists2 = async (tableName) => {
-      try {
-        await connection.runAndReadAll(`SELECT * FROM ${tableName} LIMIT 1`);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    const exportTableToJSON = async (connection2, table2, dataDir) => {
-      const filePath = join(dataDir, `${table2}.json`);
-      const schemaPath = join(dataDir, `${table2}.schema.sql`);
-      try {
-        const schemaResult = await connection2.runAndReadAll(
-          `SELECT sql FROM sqlite_master WHERE type='table' AND name='${table2}'`
-        );
-        const rows = schemaResult.getRowObjects();
-        if (rows.length > 0 && rows[0].sql) {
-          const { writeFile } = await import("node:fs/promises");
-          await writeFile(schemaPath, rows[0].sql, "utf-8");
-        }
-      } catch (error) {
-        console.warn(
-          `[json-adapter] Could not export schema for ${table2}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-      const columnsResult = await connection2.runAndReadAll(
-        `SELECT column_name, data_type FROM information_schema.columns WHERE table_name = '${table2}' ORDER BY ordinal_position`
-      );
-      const columnInfo = columnsResult.getRowObjects();
-      if (columnInfo.length === 0) {
-        await connection2.run(
-          `COPY (SELECT * FROM "${table2}") TO '${filePath}' (FORMAT JSON, ARRAY true)`
-        );
-        return;
-      }
-      const selectList = columnInfo.map(({ column_name, data_type }) => {
-        const upperType = data_type.toUpperCase();
-        if (upperType === "JSON" || upperType.startsWith("STRUCT")) {
-          return `"${column_name}"`;
-        }
-        if ([
-          "DOUBLE",
-          "REAL",
-          "FLOAT",
-          "INTEGER",
-          "BIGINT",
-          "SMALLINT",
-          "TINYINT",
-          "DECIMAL",
-          "NUMERIC",
-          "HUGEINT",
-          "UBIGINT",
-          "UINTEGER",
-          "USMALLINT",
-          "UTINYINT"
-        ].some((t) => upperType.includes(t))) {
-          return `"${column_name}"`;
-        }
-        if (upperType === "BOOLEAN" || upperType === "BOOL") {
-          return `"${column_name}"`;
-        }
-        return `CAST("${column_name}" AS TEXT) AS "${column_name}"`;
-      }).join(", ");
-      const sql = `COPY (SELECT ${selectList} FROM "${table2}") TO '${filePath}' (FORMAT JSON, ARRAY true)`;
-      await connection2.run(sql);
-    };
-    const exportTable = async (table2) => {
-      if (writeStrategy === "none") {
-        throw new DatabaseError(
-          "Cannot export table: write strategy is set to none (read-only mode)",
-          { table: table2, writeStrategy }
-        );
-      }
-      await exportTableToJSON(connection, table2, url);
-    };
-    const inferSchemaFromJSON = async (tableName, jsonPath) => {
-      validateTableName$1(tableName);
-      const filePath = jsonPath || join(url, `${tableName}.json`);
-      try {
-        const { access } = await import("node:fs/promises");
-        const { constants } = await import("node:fs");
-        await access(filePath, constants.F_OK);
-        console.log(
-          `[json-adapter] Inferring schema for ${tableName} from JSON file`
-        );
-        await connection.run(
-          `CREATE TABLE "${tableName}" AS SELECT * FROM read_json_auto('${filePath}')`
-        );
-        pendingJSONFiles.delete(tableName);
-        console.log(
-          `[json-adapter] Created ${tableName} with inferred schema (no UNIQUE constraints)`
-        );
-      } catch (error) {
-        throw new DatabaseError(
-          `Failed to infer schema from JSON for table ${tableName}`,
-          {
-            tableName,
-            jsonPath: filePath,
-            originalError: error instanceof Error ? error.message : String(error)
-          }
-        );
-      }
-    };
-    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);
-        const createTableMatch = sql.match(
-          /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?/i
-        );
-        if (createTableMatch) {
-          const tableName = createTableMatch[1];
-          const pendingFile = pendingJSONFiles.get(tableName);
-          if (pendingFile) {
-            await loadJSONData(connection, tableName, pendingFile);
-            pendingJSONFiles.delete(tableName);
-          } else if (writeStrategy !== "none") {
-            try {
-              const { access } = await import("node:fs/promises");
-              const jsonFilePath = join(url, `${tableName}.json`);
-              try {
-                await access(jsonFilePath);
-              } catch {
-                await exportTableToJSON(connection, tableName, url);
-              }
-            } catch (error) {
-              console.warn(
-                `[json-adapter] Could not export newly created table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-              );
-            }
-          }
-        }
-      } 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 syncSchema2 = async (schema) => {
-      const statements = schema.trim().split(";").filter((stmt) => stmt.trim() !== "");
-      const createTableStatements = [];
-      const indexStatements = [];
-      const otherStatements = [];
-      for (const stmt of statements) {
-        const trimmed = stmt.trim();
-        if (!trimmed) continue;
-        const upperTrimmed = trimmed.toUpperCase();
-        if (upperTrimmed.startsWith("CREATE TRIGGER")) {
-          console.warn(
-            "[json-adapter] Skipping trigger creation - timestamps managed at application level"
-          );
-          continue;
-        }
-        if (upperTrimmed.startsWith("CREATE INDEX") || upperTrimmed.startsWith("CREATE UNIQUE INDEX")) {
-          indexStatements.push(trimmed);
-        } else if (upperTrimmed.startsWith("CREATE TABLE")) {
-          createTableStatements.push(trimmed);
-        } else {
-          otherStatements.push(trimmed);
-        }
-      }
-      for (const ddl of createTableStatements) {
-        const { ddl: transformedDDL, indexes: remainingIndexes } = convertUniqueIndexesToInlineConstraints(ddl, indexStatements);
-        const createTableMatch = transformedDDL.match(
-          /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?/i
-        );
-        const tableName = createTableMatch ? createTableMatch[1] : null;
-        if (tableName && inferredSchemaTables.has(tableName)) {
-          try {
-            await connection.run(`DROP TABLE IF EXISTS "${tableName}"`);
-            inferredSchemaTables.delete(tableName);
-            console.log(
-              `[json-adapter] Dropped inferred-schema table ${tableName} for schema upgrade`
-            );
-          } catch (error) {
-            console.warn(
-              `[json-adapter] Could not drop inferred-schema table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        }
-        try {
-          await connection.run(transformedDDL);
-          if (tableName) {
-            const pendingFile = pendingJSONFiles.get(tableName);
-            if (pendingFile) {
-              await loadJSONData(connection, tableName, pendingFile);
-              pendingJSONFiles.delete(tableName);
-            } else if (writeStrategy !== "none") {
-              try {
-                const { access } = await import("node:fs/promises");
-                const jsonFilePath = join(url, `${tableName}.json`);
-                try {
-                  await access(jsonFilePath);
-                } catch {
-                  await exportTableToJSON(connection, tableName, url);
-                }
-              } catch (error) {
-                console.warn(
-                  `[json-adapter] Could not export newly created table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
-                );
-              }
-            }
-          }
-        } 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);
-          }
-        }
-      }
-      for (const stmt of otherStatements) {
-        try {
-          await connection.run(stmt);
-        } catch (e) {
-          console.error("Schema sync error:", 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: tableExists2,
-        many,
-        single,
-        pluck,
-        execute,
-        oo,
-        oO,
-        ox,
-        xx,
-        syncSchema: syncSchema2
-      };
-      await schemaManager.initializeSchemas(currentDb, options2);
-    };
-    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: tableExists2,
-          syncSchema: syncSchema2,
-          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: tableExists2,
-        syncSchema: syncSchema2,
-        transaction,
-        commit,
-        rollback,
-        isActive
-      };
-      return txHandle;
-    };
-    return {
-      url,
-      requiresSchemaCheck: true,
-      client: connection,
-      query,
-      insert,
-      update,
-      upsert,
-      get,
-      list,
-      getOrInsert,
-      delete: deleteRecords,
-      count,
-      table,
-      tableExists: tableExists2,
-      many,
-      single,
-      pluck,
-      execute,
-      oo,
-      oO,
-      ox,
-      xx,
-      syncSchema: syncSchema2,
-      initializeSchemas,
-      transaction,
-      beginTransaction,
-      // JSON-specific methods
-      exportTable,
-      inferSchemaFromJSON
-    };
-  })();
-  pendingConnections$1.set(cacheKey, connectionPromise);
-  try {
-    const db = await connectionPromise;
-    memoryConnectionCache.set(cacheKey, db);
-    return db;
-  } finally {
-    pendingConnections$1.delete(cacheKey);
-  }
-}
-const json = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  clearConnectionCache,
-  getDatabase: getDatabase$2
-}, Symbol.toStringTag, { value: "Module" }));
-function generateAddColumnStatement(table, column, _dialect) {
-  const parts = [column.name, column.type];
-  if (column.primaryKey) {
-    parts.push("PRIMARY KEY");
-  }
-  if (column.notNull) {
-    parts.push("NOT NULL");
-  }
-  if (column.unique) {
-    parts.push("UNIQUE");
-  }
-  if (column.defaultValue !== void 0) {
-    const defaultClause = generateDefaultClause(
-      column.type,
-      column.defaultValue
-    );
-    parts.push(`DEFAULT ${defaultClause}`);
-  }
-  if (column.check) {
-    parts.push(`CHECK (${column.check})`);
-  }
-  if (column.foreignKey) {
-    const fk = column.foreignKey;
-    const fkParts = [`REFERENCES ${fk.table}(${fk.column})`];
-    if (fk.onDelete) {
-      fkParts.push(`ON DELETE ${fk.onDelete}`);
-    }
-    if (fk.onUpdate) {
-      fkParts.push(`ON UPDATE ${fk.onUpdate}`);
-    }
-    parts.push(fkParts.join(" "));
-  }
-  const columnDef = parts.join(" ");
-  return `ALTER TABLE ${table} ADD COLUMN ${columnDef}`;
-}
-function generateDefaultClause(columnType, defaultValue) {
-  if (defaultValue === null) {
-    return "NULL";
-  }
-  const typeUpper = columnType.toUpperCase();
-  if (typeUpper.includes("TEXT") || typeUpper.includes("CHAR") || typeUpper.includes("VARCHAR") || typeUpper.includes("STRING")) {
-    if (defaultValue === "") {
-      return "''";
-    }
-    const escaped = String(defaultValue).replace(/'/g, "''");
-    return `'${escaped}'`;
-  }
-  if (typeUpper.includes("BOOL")) {
-    return defaultValue ? "true" : "false";
-  }
-  if (typeUpper.includes("INT") || typeUpper.includes("REAL") || typeUpper.includes("FLOAT") || typeUpper.includes("DOUBLE") || typeUpper.includes("NUMERIC") || typeUpper.includes("DECIMAL")) {
-    return String(defaultValue);
-  }
-  if (typeUpper.includes("JSON")) {
-    if (typeof defaultValue === "string") {
-      return `'${defaultValue.replace(/'/g, "''")}'`;
-    }
-    return `'${JSON.stringify(defaultValue).replace(/'/g, "''")}'`;
-  }
-  if (typeUpper.includes("DATE") || typeUpper.includes("TIME") || typeUpper.includes("TIMESTAMP")) {
-    if (defaultValue instanceof Date) {
-      return `'${defaultValue.toISOString()}'`;
-    }
-    return `'${String(defaultValue).replace(/'/g, "''")}'`;
-  }
-  if (typeof defaultValue === "string") {
-    return `'${defaultValue.replace(/'/g, "''")}'`;
-  }
-  return String(defaultValue);
-}
-function generateCreateIndexStatement(table, index2) {
-  const parts = ["CREATE"];
-  if (index2.unique) {
-    parts.push("UNIQUE");
-  }
-  parts.push("INDEX");
-  parts.push(index2.name);
-  parts.push(`ON ${table}`);
-  const columns = index2.columns.join(", ");
-  parts.push(`(${columns})`);
-  if (index2.where) {
-    parts.push(`WHERE ${index2.where}`);
-  }
-  return parts.join(" ");
-}
-function validateTableName(tableName) {
-  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName)) {
-    throw new Error(
-      `Invalid table name: ${tableName}. Table names must start with a letter or underscore and contain only alphanumeric characters and underscores.`
-    );
-  }
-}
-function validateColumnName$1(columnName) {
-  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(columnName)) {
-    throw new Error(
-      `Invalid column name: ${columnName}. Column names must start with a letter or underscore and contain only alphanumeric characters and underscores.`
-    );
-  }
-}
-function validateIndexName(indexName) {
-  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(indexName)) {
-    throw new Error(
-      `Invalid index name: ${indexName}. Index names must start with a letter or underscore and contain only alphanumeric characters and underscores.`
-    );
-  }
-}
-const connectionCache = /* @__PURE__ */ new Map();
-const pendingConnections = /* @__PURE__ */ new Map();
-function clearPostgresConnectionCache() {
-  connectionCache.clear();
-  pendingConnections.clear();
-}
-function vectorOperator(metric) {
-  switch (metric) {
-    case "cosine":
-      return "<=>";
-    case "l2":
-      return "<->";
-    case "ip":
-      return "<#>";
-    default:
-      return "<=>";
-  }
-}
-function getMaxPostgresParameterIndex(sql) {
-  let maxIndex = 0;
-  for (const match of sql.matchAll(/\$(\d+)/g)) {
-    const index2 = Number(match[1]);
-    if (Number.isSafeInteger(index2) && index2 > maxIndex) {
-      maxIndex = index2;
-    }
-  }
-  return maxIndex;
-}
-function usesSingleArrayParameter(sql) {
-  const identifier = String.raw`(?:"[^"]+"|[a-z_][\w$]*)`;
-  const qualifiedIdentifier = String.raw`${identifier}(?:\s*\.\s*${identifier})?`;
-  const arrayType = String.raw`${qualifiedIdentifier}(?:\s*\([^)]*\))?\s*\[\]`;
-  return new RegExp(String.raw`\$1\s*::\s*${arrayType}`, "i").test(sql) || new RegExp(
-    String.raw`\bCAST\s*\(\s*\$1\s+AS\s+${arrayType}\s*\)`,
-    "i"
-  ).test(sql) || /\b(?:ANY|ALL|SOME)\s*\(\s*\$1\s*\)/i.test(sql);
-}
-function normalizeRawQueryValues(sql, values) {
-  if (values.length !== 1 || !Array.isArray(values[0])) {
-    return values;
-  }
-  const valuesArray = values[0];
-  const maxParameterIndex = getMaxPostgresParameterIndex(sql);
-  if (maxParameterIndex === 1 && usesSingleArrayParameter(sql)) {
-    return values;
-  }
-  if (maxParameterIndex === 0 || maxParameterIndex === valuesArray.length) {
-    return valuesArray;
-  }
-  return values;
-}
-function rewriteQuestionMarkPlaceholders(sql) {
-  let output = "";
-  let count = 0;
-  let index2 = 0;
-  const copyQuoted = (quote, escaped = false) => {
-    output += quote;
-    index2 += 1;
-    while (index2 < sql.length) {
-      const char = sql[index2];
-      output += char;
-      index2 += 1;
-      if (escaped && char === "\\" && index2 < sql.length) {
-        output += sql[index2];
-        index2 += 1;
-        continue;
-      }
-      if (char === quote) {
-        if (sql[index2] === quote) {
-          output += sql[index2];
-          index2 += 1;
-          continue;
-        }
-        break;
-      }
-    }
-  };
-  const copyUntil = (end) => {
-    const endIndex = sql.indexOf(end, index2 + end.length);
-    if (endIndex === -1) {
-      output += sql.slice(index2);
-      index2 = sql.length;
-      return;
-    }
-    output += sql.slice(index2, endIndex + end.length);
-    index2 = endIndex + end.length;
-  };
-  while (index2 < sql.length) {
-    const char = sql[index2];
-    const next = sql[index2 + 1];
-    if ((char === "E" || char === "e") && next === "'") {
-      output += char;
-      index2 += 1;
-      copyQuoted("'", true);
-      continue;
-    }
-    if (char === "'") {
-      copyQuoted("'");
-      continue;
-    }
-    if (char === '"') {
-      copyQuoted('"');
-      continue;
-    }
-    if (char === "-" && next === "-") {
-      const endIndex = sql.indexOf("\n", index2 + 2);
-      if (endIndex === -1) {
-        output += sql.slice(index2);
-        index2 = sql.length;
-      } else {
-        output += sql.slice(index2, endIndex + 1);
-        index2 = endIndex + 1;
-      }
-      continue;
-    }
-    if (char === "/" && next === "*") {
-      copyUntil("*/");
-      continue;
-    }
-    if (char === "$") {
-      const tag = sql.slice(index2).match(/^\$[A-Za-z_][\w$]*\$|^\$\$/);
-      if (tag) {
-        copyUntil(tag[0]);
-        continue;
-      }
-    }
-    if (char === "?" && next !== "|" && next !== "&") {
-      count += 1;
-      output += `$${count}`;
-      index2 += 1;
-      continue;
-    }
-    output += char;
-    index2 += 1;
-  }
-  return { sql: output, count };
-}
-function usesSingleQuestionArrayParameter(sql) {
-  const identifier = String.raw`(?:"[^"]+"|[a-z_][\w$]*)`;
-  const qualifiedIdentifier = String.raw`${identifier}(?:\s*\.\s*${identifier})?`;
-  const arrayType = String.raw`${qualifiedIdentifier}(?:\s*\([^)]*\))?\s*\[\]`;
-  return new RegExp(String.raw`\?\s*::\s*${arrayType}`, "i").test(sql) || new RegExp(String.raw`\bCAST\s*\(\s*\?\s+AS\s+${arrayType}\s*\)`, "i").test(
-    sql
-  ) || /\b(?:ANY|ALL|SOME)\s*\(\s*\?\s*\)/i.test(sql);
-}
-function normalizeQuestionMarkQueryValues(sql, values, placeholderCount) {
-  if (values.length !== 1 || !Array.isArray(values[0])) {
-    return values;
-  }
-  if (placeholderCount === 1 && usesSingleQuestionArrayParameter(sql)) {
-    return values;
-  }
-  if (placeholderCount === values[0].length) {
-    return values[0];
-  }
-  return values;
-}
-function normalizePostgresRawQuery(sql, values) {
-  if (getMaxPostgresParameterIndex(sql) > 0) {
-    return { sql, values: normalizeRawQueryValues(sql, values) };
-  }
-  const rewritten = rewriteQuestionMarkPlaceholders(sql);
-  const placeholderCount = rewritten.count;
-  const queryValues = normalizeQuestionMarkQueryValues(
-    sql,
-    values,
-    placeholderCount
-  );
-  if (placeholderCount > 0 && placeholderCount === queryValues.length) {
-    return {
-      sql: rewritten.sql,
-      values: queryValues
-    };
-  }
-  return { sql, values: normalizeRawQueryValues(sql, values) };
-}
-function vectorOpsClass(metric) {
-  switch (metric) {
-    case "cosine":
-      return "vector_cosine_ops";
-    case "l2":
-      return "vector_l2_ops";
-    case "ip":
-      return "vector_ip_ops";
-    default:
-      return "vector_cosine_ops";
-  }
-}
-function toVectorLiteral(embedding) {
-  if (embedding.length === 0) {
-    throw new DatabaseError("Vector embedding must not be empty", {});
-  }
-  for (let i = 0; i < embedding.length; i++) {
-    if (!Number.isFinite(embedding[i])) {
-      throw new DatabaseError(
-        "Vector embedding contains invalid value (NaN or Infinity)",
-        { index: i, value: embedding[i] }
-      );
-    }
-  }
-  return `[${embedding.join(",")}]`;
-}
-function createVectorCapabilities(pool) {
-  return {
-    async ensureColumn(table, column, dimensions) {
-      if (!Number.isInteger(dimensions) || dimensions <= 0) {
-        throw new DatabaseError(
-          "Vector dimensions must be a positive integer",
-          { dimensions }
-        );
-      }
-      try {
-        await pool.query("CREATE EXTENSION IF NOT EXISTS vector");
-        await pool.query(
-          `ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" vector(${dimensions})`
-        );
-      } catch (e) {
-        throw new DatabaseError("Failed to ensure vector column", {
-          table,
-          column,
-          dimensions,
-          originalError: formatDbError(e)
-        });
-      }
-    },
-    async ensureIndex(table, column, options) {
-      const metric = options?.metric || "cosine";
-      const indexType = options?.type || "hnsw";
-      const opsClass = vectorOpsClass(metric);
-      const indexName = `idx_${table}_${column}_${metric}_${indexType}`;
-      try {
-        await pool.query(
-          `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${table}" USING ${indexType} ("${column}" ${opsClass})`
-        );
-      } catch (e) {
-        throw new DatabaseError("Failed to ensure vector index", {
-          table,
-          column,
-          indexName,
-          originalError: formatDbError(e)
-        });
-      }
-    },
-    async upsertVector(table, where, column, embedding) {
-      const keys = Object.keys(where);
-      const values = Object.values(where);
-      const conditions = keys.map((key, i) => `"${key}" IS NOT DISTINCT FROM $${i + 1}`).join(" AND ");
-      const vectorParam = `$${values.length + 1}`;
-      try {
-        await pool.query(
-          `UPDATE "${table}" SET "${column}" = ${vectorParam}::vector WHERE ${conditions}`,
-          [...values, toVectorLiteral(embedding)]
-        );
-      } catch (e) {
-        throw new DatabaseError("Failed to upsert vector", {
-          table,
-          column,
-          where,
-          originalError: formatDbError(e)
-        });
-      }
-    },
-    async search(table, column, embedding, options) {
-      const metric = options?.metric || "cosine";
-      const limit = options?.limit || 10;
-      const op = vectorOperator(metric);
-      const queryParams = [toVectorLiteral(embedding)];
-      let whereClause = `"${column}" IS NOT NULL`;
-      if (options?.where) {
-        whereClause += ` AND (${options.where})`;
-        if (options.params) {
-          queryParams.push(...options.params);
-        }
-      }
-      const limitParam = `$${queryParams.length + 1}`;
-      queryParams.push(limit);
-      const sql = `SELECT *, ("${column}" ${op} $1::vector) AS distance FROM "${table}" WHERE ${whereClause} ORDER BY "${column}" ${op} $1::vector LIMIT ${limitParam}`;
-      try {
-        const result = await pool.query(sql, queryParams);
-        return result.rows.map((row) => ({
-          ...row,
-          id: row.id,
-          distance: Number.parseFloat(row.distance)
-        }));
-      } catch (e) {
-        throw new DatabaseError("Failed to execute vector search", {
-          table,
-          column,
-          metric,
-          limit,
-          originalError: formatDbError(e)
-        });
-      }
-    }
-  };
-}
-async function getDatabase$1(options = {}) {
-  const envUrl = process.env.HAVE_SQL_URL || process.env.SQLOO_URL || null;
-  const envDatabase = process.env.HAVE_SQL_DATABASE || process.env.SQLOO_DATABASE || null;
-  const envHost = process.env.HAVE_SQL_HOST || process.env.SQLOO_HOST || "localhost";
-  const envUser = process.env.HAVE_SQL_USER || process.env.SQLOO_USER || "";
-  const envPortRaw = process.env.HAVE_SQL_PORT || process.env.SQLOO_PORT;
-  const envPort = envPortRaw ? Number(envPortRaw) || 5432 : 5432;
-  const derivedHost = options.host || envHost;
-  const derivedPort = options.port || envPort;
-  const derivedDatabase = options.database || envDatabase;
-  const derivedUser = options.user || envUser;
-  const cacheKey = options.dbid || options.url || (derivedDatabase ? `pg:${derivedUser ? `${derivedUser}@` : ""}${derivedHost}:${derivedPort}/${derivedDatabase}` : envUrl || null);
-  if (cacheKey) {
-    const cached = connectionCache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-    const pending = pendingConnections.get(cacheKey);
-    if (pending) return pending;
-  }
-  const connectionPromise = createDatabase(options, cacheKey);
-  if (cacheKey) {
-    pendingConnections.set(cacheKey, connectionPromise);
-    connectionPromise.finally(() => {
-      if (cacheKey) pendingConnections.delete(cacheKey);
-    });
-  }
-  return connectionPromise;
-}
-async function createDatabase(options, cacheKey) {
-  const config = loadEnvConfig(options, {
-    packageName: "sql",
-    schema: {
-      url: "string",
-      database: "string",
-      host: "string",
-      port: "number",
-      user: "string",
-      password: "string"
-    }
-  });
-  if (!config.url && !config.host && !config.database && !config.user) {
-    const legacyConfig = loadEnvConfig(
-      {},
-      {
-        prefix: "SQLOO",
-        schema: {
-          url: "string",
-          database: "string",
-          host: "string",
-          port: "number",
-          user: "string",
-          password: "string"
-        }
-      }
-    );
-    for (const [key, value] of Object.entries(legacyConfig)) {
-      if (config[key] === void 0 && value !== void 0) {
-        config[key] = value;
-      }
-    }
-  }
-  const { database, host = "localhost", user, password, port = 5432 } = config;
-  const url = config.url || `postgresql://${user}${password ? `:${password}` : ""}@${host}:${port}/${database || "postgres"}`;
-  const poolMax = options.max ?? 20;
-  const pool = new Pool(
-    config.url ? { connectionString: config.url, max: poolMax } : {
-      host,
-      user,
-      password,
-      port,
-      database,
-      max: poolMax
-    }
-  );
-  const originalEnd = pool.end.bind(pool);
-  const evictFromCache = () => {
-    for (const [key, cached] of connectionCache.entries()) {
-      if (cached.client === pool) {
-        connectionCache.delete(key);
-      }
-    }
-  };
-  pool.end = (callback) => {
-    evictFromCache();
-    if (callback) {
-      return originalEnd(callback);
-    }
-    return originalEnd();
-  };
-  const client = pool;
-  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;
-  };
-  let serverVersionNumPromise;
-  const nullsNotDistinctIndexCache = /* @__PURE__ */ new Map();
-  const hasNullConflictValue = (conflictColumns, data) => conflictColumns.some((col) => data[col] === null);
-  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 should be replaced with null or an appropriate default."
-      });
-    }
-  };
-  const getServerVersionNum = async () => {
-    serverVersionNumPromise ??= client.query("SHOW server_version_num").then((result) => Number(result.rows[0]?.server_version_num) || 0);
-    return serverVersionNumPromise;
-  };
-  const hasNativeNullsNotDistinctIndex = async (table2, conflictColumns) => {
-    const versionNum = await getServerVersionNum();
-    if (versionNum < 15e4) return false;
-    const cacheKey2 = `${table2}:${conflictColumns.join(",")}`;
-    let cached = nullsNotDistinctIndexCache.get(cacheKey2);
-    if (!cached) {
-      cached = client.query(
-        `
-            SELECT 1
-            FROM pg_index i
-            WHERE i.indrelid = to_regclass($1)
-              AND i.indisunique
-              AND i.indnullsnotdistinct
-              AND ARRAY(
-                SELECT a.attname::text
-                FROM unnest(i.indkey) WITH ORDINALITY AS cols(attnum, ord)
-                JOIN pg_attribute a
-                  ON a.attrelid = i.indrelid
-                 AND a.attnum = cols.attnum
-                ORDER BY cols.ord
-              ) = $2::text[]
-            LIMIT 1
-          `,
-        [table2, conflictColumns]
-      ).then((result) => result.rows.length > 0).catch(() => false);
-      nullsNotDistinctIndexCache.set(cacheKey2, cached);
-    }
-    return cached;
-  };
-  const buildPostgresUpsertParts = (conflictColumns, serializedData) => {
-    const keys = Object.keys(serializedData);
-    const values = Object.values(serializedData);
-    const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
-    const updateSet = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-    const conflict = conflictColumns.join(", ");
-    return { keys, values, placeholders, updateSet, conflict };
-  };
-  const executeStandardPostgresUpsert = async (executor, table2, conflictColumns, serializedData) => {
-    const { keys, values, placeholders, updateSet, conflict } = buildPostgresUpsertParts(conflictColumns, serializedData);
-    const sql = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${conflict}) DO UPDATE SET ${updateSet}`;
-    const result = await executor.query(sql, values);
-    return { operation: "upsert", affected: result.rowCount ?? 0 };
-  };
-  const executeNullAwarePostgresUpsert = async (executor, table2, conflictColumns, serializedData) => {
-    const { keys, values, placeholders } = buildPostgresUpsertParts(
-      conflictColumns,
-      serializedData
-    );
-    const lockKey = conflictColumns.map((col) => `${col}:${JSON.stringify(serializedData[col])}`).join("|");
-    await executor.query(
-      "SELECT pg_advisory_xact_lock(hashtext($1), hashtext($2))",
-      [`@happyvertical/sql.upsert:${table2}`, lockKey]
-    );
-    const updateSet = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-    const whereStart = values.length + 1;
-    const whereClause = conflictColumns.map((col, i) => `${col} IS NOT DISTINCT FROM $${whereStart + i}`).join(" AND ");
-    const whereValues = conflictColumns.map((col) => serializedData[col]);
-    const updateSql = `UPDATE ${table2} SET ${updateSet} WHERE ${whereClause}`;
-    const updateResult = await executor.query(updateSql, [
-      ...values,
-      ...whereValues
-    ]);
-    if ((updateResult.rowCount ?? 0) > 0) {
-      return { operation: "upsert", affected: updateResult.rowCount ?? 0 };
-    }
-    const insertSql = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES (${placeholders})`;
-    const insertResult = await executor.query(insertSql, values);
-    return { operation: "upsert", affected: insertResult.rowCount ?? 0 };
-  };
-  const executeNullAwarePostgresUpsertInTransaction = async (table2, conflictColumns, serializedData) => {
-    const txClient = await client.connect();
-    try {
-      await txClient.query("BEGIN");
-      const result = await executeNullAwarePostgresUpsert(
-        txClient,
-        table2,
-        conflictColumns,
-        serializedData
-      );
-      await txClient.query("COMMIT");
-      return result;
-    } catch (error) {
-      await txClient.query("ROLLBACK");
-      throw error;
-    } finally {
-      txClient.release();
-    }
-  };
-  const executePostgresUpsert = async (executor, table2, conflictColumns, data, options2, acquireTransaction) => {
-    const serializedData = serializeRecord(data);
-    validateUpsertConflictColumns(table2, conflictColumns, serializedData);
-    if (options2?.nullsDistinct || !hasNullConflictValue(conflictColumns, serializedData)) {
-      return executeStandardPostgresUpsert(
-        executor,
-        table2,
-        conflictColumns,
-        serializedData
-      );
-    }
-    if (await hasNativeNullsNotDistinctIndex(table2, conflictColumns)) {
-      return executeStandardPostgresUpsert(
-        executor,
-        table2,
-        conflictColumns,
-        serializedData
-      );
-    }
-    if (!acquireTransaction) {
-      return executeNullAwarePostgresUpsert(
-        executor,
-        table2,
-        conflictColumns,
-        serializedData
-      );
-    }
-    return executeNullAwarePostgresUpsertInTransaction(
-      table2,
-      conflictColumns,
-      serializedData
-    );
-  };
-  const insert = async (table2, data) => {
-    if (Array.isArray(data)) {
-      const serializedRecords = data.map((record) => serializeRecord(record));
-      const keys2 = Object.keys(serializedRecords[0]);
-      const placeholders2 = serializedRecords.map(
-        (_, i) => `(${keys2.map((_2, j) => `$${i * keys2.length + j + 1}`).join(", ")})`
-      ).join(", ");
-      const query3 = `INSERT INTO ${table2} (${keys2.join(
-        ", "
-      )}) VALUES ${placeholders2}`;
-      const values2 = serializedRecords.reduce(
-        (acc, row) => acc.concat(Object.values(row)),
-        []
-      );
-      const result2 = await client.query(query3, values2);
-      return { operation: "insert", affected: result2.rowCount ?? 0 };
-    }
-    const serializedData = serializeRecord(data);
-    const keys = Object.keys(serializedData);
-    const values = Object.values(serializedData);
-    const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
-    const query2 = `INSERT INTO ${table2} (${keys.join(
-      ", "
-    )}) VALUES (${placeholders})`;
-    const result = await client.query(query2, values);
-    return { operation: "insert", affected: result.rowCount ?? 0 };
-  };
-  const get = async (table2, where) => {
-    const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-    if (!whereClause) {
-      throw new DatabaseError(
-        "GET requires at least one WHERE condition to prevent returning an arbitrary record",
-        { table: table2 }
-      );
-    }
-    const query2 = `SELECT * FROM ${table2} ${whereClause}`;
-    try {
-      const result = await client.query(query2, values);
-      return result.rows[0] || null;
-    } catch (e) {
-      throw new DatabaseError("Failed to retrieve record from table", {
-        table: table2,
-        sql: query2,
-        values,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const list = async (table2, where) => {
-    const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-    const query2 = `SELECT * FROM ${table2} ${whereClause}`;
-    try {
-      const result = await client.query(query2, values);
-      return result.rows;
-    } catch (e) {
-      throw new DatabaseError("Failed to list records from table", {
-        table: table2,
-        sql: query2,
-        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,
-      "postgres"
-    );
-    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.query(sql, [...values, ...whereValues]);
-      return { operation: "update", affected: result.rowCount ?? 0 };
-    } 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 executePostgresUpsert(
-        client,
-        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 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, "postgres");
-    try {
-      const result = await client.query(
-        `DELETE FROM ${table2} ${whereClause}`,
-        values
-      );
-      return { operation: "delete", affected: result.rowCount ?? 0 };
-    } catch (e) {
-      throw new DatabaseError("Failed to delete records from table", {
-        table: table2,
-        where,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const count = async (table2, where) => {
-    validateTableName(table2);
-    try {
-      if (!where || Object.keys(where).length === 0) {
-        const result2 = await client.query(
-          `SELECT COUNT(*) as count FROM ${table2}`
-        );
-        return Number(result2.rows[0]?.count) || 0;
-      }
-      const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-      const result = await client.query(
-        `SELECT COUNT(*) as count FROM ${table2} ${whereClause}`,
-        values
-      );
-      return Number(result.rows[0]?.count) || 0;
-    } catch (e) {
-      throw new DatabaseError("Failed to count records in table", {
-        table: table2,
-        where,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const table = (tableName) => {
-    return {
-      insert: (data) => insert(tableName, data),
-      get: (data) => get(tableName, data),
-      list: (data) => list(tableName, data)
-    };
-  };
-  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 pluck = async (strings, ...vars) => {
-    const { sql, values } = parseTemplate(strings, ...vars);
-    try {
-      const result = await client.query(sql, values);
-      const firstRow = result.rows[0];
-      if (!firstRow) return null;
-      return Object.values(firstRow)[0];
-    } 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.query(sql, 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.query(sql, 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.query(sql, values);
-    } catch (e) {
-      throw new DatabaseError("Failed to execute query", {
-        sql,
-        values,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const query = async (sql, ...values) => {
-    const query2 = normalizePostgresRawQuery(sql, values);
-    try {
-      const result = await client.query(query2.sql, query2.values);
-      return {
-        rows: result.rows,
-        rowCount: result.rowCount ?? 0
-      };
-    } catch (e) {
-      throw new DatabaseError("Failed to execute raw query", {
-        sql: query2.sql,
-        values: query2.values,
-        originalError: formatDbError(e)
-      });
-    }
-  };
-  const acquireSession = async () => {
-    const sessionClient = await pool.connect();
-    let released = false;
-    let lost = false;
-    sessionClient.on("error", () => {
-      lost = true;
-    });
-    return {
-      query: async (sql, ...values) => {
-        if (released) {
-          throw new DatabaseError("Session has been released", {});
-        }
-        if (lost) {
-          throw new DatabaseError("Session connection was lost", {});
-        }
-        const normalized = normalizePostgresRawQuery(sql, values);
-        try {
-          const result = await sessionClient.query(
-            normalized.sql,
-            normalized.values
-          );
-          return {
-            rows: result.rows,
-            rowCount: result.rowCount ?? 0
-          };
-        } catch (e) {
-          throw new DatabaseError("Failed to execute session query", {
-            sql: normalized.sql,
-            values: normalized.values,
-            originalError: formatDbError(e)
-          });
-        }
-      },
-      isActive: () => !released && !lost,
-      release: async () => {
-        if (released) return;
-        released = true;
-        if (!lost) {
-          try {
-            await sessionClient.query("ROLLBACK");
-          } catch {
-          }
-          try {
-            await sessionClient.query("SELECT pg_advisory_unlock_all()");
-          } catch {
-          }
-        }
-        sessionClient.release(true);
-      }
-    };
-  };
-  const tableExists2 = async (tableName) => {
-    const result = await client.query(
-      `SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = $1 AND table_schema = 'public')`,
-      [tableName]
-    );
-    return result.rows[0].exists;
-  };
-  const syncSchema2 = async (schema) => {
-    const commands = schema.trim().split(";").filter((command) => command.trim() !== "");
-    const createIndexRegex = /CREATE (UNIQUE )?INDEX (IF NOT EXISTS )?"?(\w+)"? ON "?(\w+)"?\s*\(([^)]+)\)/i;
-    const indexNames = [];
-    for (const command of commands) {
-      const indexMatch = command.trim().match(createIndexRegex);
-      if (indexMatch) {
-        indexNames.push(indexMatch[3]);
-      }
-    }
-    const existingIndexes = /* @__PURE__ */ new Set();
-    if (indexNames.length > 0) {
-      const result = await client.query(
-        `SELECT indexname FROM pg_indexes
-         WHERE schemaname = 'public' AND indexname = ANY($1::text[])`,
-        [indexNames]
-      );
-      for (const row of result.rows) {
-        existingIndexes.add(row.indexname);
-      }
-    }
-    for (const command of commands) {
-      const trimmedCommand = command.trim();
-      const createTableRegex = /CREATE TABLE (IF NOT EXISTS )?"?(\w+)"? \(([\s\S]+)\)/i;
-      const tableMatch = trimmedCommand.match(createTableRegex);
-      if (tableMatch) {
-        const tableName = tableMatch[2];
-        const columns = tableMatch[3].trim().split(",\n");
-        const exists = await tableExists2(tableName);
-        if (!exists) {
-          await client.query(trimmedCommand);
-        } else {
-          for (const column of columns) {
-            const columnDef = column.trim();
-            const columnMatch = columnDef.match(/"?(\w+)"?\s+(\w+[^,]*)/);
-            if (columnMatch) {
-              const columnName = columnMatch[1];
-              if (columnName.toUpperCase() === "PRIMARY" || columnName.toUpperCase() === "FOREIGN" || columnName.toUpperCase() === "UNIQUE" || columnName.toUpperCase() === "CHECK" || columnName.toUpperCase() === "CONSTRAINT") {
-                continue;
-              }
-              try {
-                const columnExists = await client.query(
-                  `SELECT EXISTS (
-                    SELECT 1 FROM information_schema.columns
-                    WHERE table_name = $1
-                    AND column_name = $2
-                    AND table_schema = 'public'
-                  )`,
-                  [tableName, columnName]
-                );
-                if (!columnExists.rows[0].exists) {
-                  const alterCommand = `ALTER TABLE "${tableName}" ADD COLUMN ${columnDef}`;
-                  await client.query(alterCommand);
-                }
-              } catch (error) {
-                console.error(
-                  `Error adding column ${columnName} to ${tableName}:`,
-                  error
-                );
-              }
-            }
-          }
-        }
-        continue;
-      }
-      const indexMatch = trimmedCommand.match(createIndexRegex);
-      if (indexMatch) {
-        const indexName = indexMatch[3];
-        const indexTableName = indexMatch[4];
-        if (!existingIndexes.has(indexName)) {
-          try {
-            await client.query(trimmedCommand);
-            existingIndexes.add(indexName);
-          } catch (error) {
-            console.warn(
-              `Warning: Failed to create index ${indexName} on ${indexTableName}:`,
-              error instanceof Error ? error.message : String(error)
-            );
-          }
-        }
-        continue;
-      }
-      if (trimmedCommand.toUpperCase().startsWith("CREATE ") && !trimmedCommand.toUpperCase().includes("CREATE TABLE")) {
-        try {
-          await client.query(trimmedCommand);
-        } catch (error) {
-          console.warn(
-            `Warning: DDL statement may have failed:`,
-            error instanceof Error ? error.message : String(error)
-          );
-        }
-      }
-    }
-  };
-  const transaction = async (callback) => {
-    const txClient = await client.connect();
-    try {
-      await txClient.query("BEGIN");
-      const txDb = {
-        url,
-        client: txClient,
-        insert: async (table2, data) => {
-          if (Array.isArray(data)) {
-            const keys2 = Object.keys(data[0]);
-            const placeholders2 = data.map(
-              (_, i) => `(${keys2.map((_2, j) => `$${i * keys2.length + j + 1}`).join(", ")})`
-            ).join(", ");
-            const query3 = `INSERT INTO ${table2} (${keys2.join(", ")}) VALUES ${placeholders2}`;
-            const values2 = data.reduce(
-              (acc, row) => acc.concat(Object.values(row)),
-              []
-            );
-            const result3 = await txClient.query(query3, values2);
-            return { operation: "insert", affected: result3.rowCount ?? 0 };
-          }
-          const keys = Object.keys(data);
-          const values = Object.values(data);
-          const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
-          const query2 = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES (${placeholders})`;
-          const result2 = await txClient.query(query2, values);
-          return { operation: "insert", affected: result2.rowCount ?? 0 };
-        },
-        get: async (table2, where) => {
-          const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-          if (!whereClause) {
-            throw new DatabaseError(
-              "GET requires at least one WHERE condition to prevent returning an arbitrary record",
-              { table: table2 }
-            );
-          }
-          const query2 = `SELECT * FROM ${table2} ${whereClause}`;
-          const result2 = await txClient.query(query2, values);
-          return result2.rows[0] || null;
-        },
-        list: async (table2, where) => {
-          const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-          const query2 = `SELECT * FROM ${table2} ${whereClause}`;
-          const result2 = await txClient.query(query2, values);
-          return result2.rows;
-        },
-        update: async (table2, where, data) => {
-          const keys = Object.keys(data);
-          const values = Object.values(data);
-          const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-          const { sql: whereClause, values: whereValues } = buildWhere(
-            where,
-            values.length + 1,
-            "postgres"
-          );
-          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}`;
-          const result2 = await txClient.query(sql, [...values, ...whereValues]);
-          return { operation: "update", affected: result2.rowCount ?? 0 };
-        },
-        upsert: async (table2, conflictColumns, data, options2) => executePostgresUpsert(
-          txClient,
-          table2,
-          conflictColumns,
-          data,
-          options2,
-          false
-        ),
-        getOrInsert: async (table2, where, data) => {
-          const result2 = await txDb.get(table2, where);
-          if (result2) return result2;
-          await txDb.insert(table2, data);
-          const inserted = await txDb.get(table2, where);
-          if (!inserted) {
-            throw new DatabaseError("Failed to insert and retrieve record", {
-              table: table2,
-              where,
-              data
-            });
-          }
-          return inserted;
-        },
-        delete: 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, "postgres");
-          const result2 = await txClient.query(
-            `DELETE FROM ${table2} ${whereClause}`,
-            values
-          );
-          return { operation: "delete", affected: result2.rowCount ?? 0 };
-        },
-        count: async (table2, where) => {
-          validateTableName(table2);
-          if (!where || Object.keys(where).length === 0) {
-            const result3 = await txClient.query(
-              `SELECT COUNT(*) as count FROM ${table2}`
-            );
-            return Number(result3.rows[0]?.count) || 0;
-          }
-          const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-          const result2 = await txClient.query(
-            `SELECT COUNT(*) as count FROM ${table2} ${whereClause}`,
-            values
-          );
-          return Number(result2.rows[0]?.count) || 0;
-        },
-        table: (tableName) => ({
-          insert: (data) => txDb.insert(tableName, data),
-          get: (data) => txDb.get(tableName, data),
-          list: (data) => txDb.list(tableName, data)
-        }),
-        many: async (strings, ...vars) => {
-          const { sql, values } = parseTemplate(strings, ...vars);
-          const result2 = await txClient.query(sql, values);
-          return result2.rows;
-        },
-        single: async (strings, ...vars) => {
-          const { sql, values } = parseTemplate(strings, ...vars);
-          const result2 = await txClient.query(sql, values);
-          return result2.rows[0] || null;
-        },
-        pluck: async (strings, ...vars) => {
-          const { sql, values } = parseTemplate(strings, ...vars);
-          const result2 = await txClient.query(sql, values);
-          const firstRow = result2.rows[0];
-          if (!firstRow) return null;
-          return Object.values(firstRow)[0];
-        },
-        execute: async (strings, ...vars) => {
-          const { sql, values } = parseTemplate(strings, ...vars);
-          await txClient.query(sql, values);
-        },
-        query: async (sql, ...values) => {
-          const query2 = normalizePostgresRawQuery(sql, values);
-          const result2 = await txClient.query(query2.sql, query2.values);
-          return {
-            rows: result2.rows,
-            rowCount: result2.rowCount ?? 0
-          };
-        },
-        oo: async (strings, ...vars) => {
-          const { sql, values } = parseTemplate(strings, ...vars);
-          const result2 = await txClient.query(sql, values);
-          return result2.rows;
-        },
-        oO: async (strings, ...vars) => {
-          const { sql, values } = parseTemplate(strings, ...vars);
-          const result2 = await txClient.query(sql, values);
-          return result2.rows[0] || null;
-        },
-        ox: async (strings, ...vars) => {
-          const { sql, values } = parseTemplate(strings, ...vars);
-          const result2 = await txClient.query(sql, values);
-          const firstRow = result2.rows[0];
-          if (!firstRow) return null;
-          return Object.values(firstRow)[0];
-        },
-        xx: async (strings, ...vars) => {
-          const { sql, values } = parseTemplate(strings, ...vars);
-          await txClient.query(sql, values);
-        },
-        tableExists: tableExists2,
-        syncSchema: syncSchema2,
-        transaction
-      };
-      const result = await callback(txDb);
-      await txClient.query("COMMIT");
-      return result;
-    } catch (error) {
-      await txClient.query("ROLLBACK");
-      throw error;
-    } finally {
-      txClient.release();
-    }
-  };
-  const beginTransaction = async () => {
-    const txClient = await client.connect();
-    await txClient.query("BEGIN");
-    let active = true;
-    const commit = async () => {
-      if (!active) {
-        throw new DatabaseError("Transaction already ended", {});
-      }
-      await txClient.query("COMMIT");
-      active = false;
-      txClient.release();
-    };
-    const rollback = async () => {
-      if (!active) {
-        throw new DatabaseError("Transaction already ended", {});
-      }
-      await txClient.query("ROLLBACK");
-      active = false;
-      txClient.release();
-    };
-    const isActive = () => active;
-    const txHandle = {
-      url,
-      client: txClient,
-      insert: async (table2, data) => {
-        if (Array.isArray(data)) {
-          const keys2 = Object.keys(data[0]);
-          const placeholders2 = data.map(
-            (_, i) => `(${keys2.map((_2, j) => `$${i * keys2.length + j + 1}`).join(", ")})`
-          ).join(", ");
-          const query3 = `INSERT INTO ${table2} (${keys2.join(", ")}) VALUES ${placeholders2}`;
-          const values2 = data.reduce(
-            (acc, row) => acc.concat(Object.values(row)),
-            []
-          );
-          const result2 = await txClient.query(query3, values2);
-          return { operation: "insert", affected: result2.rowCount ?? 0 };
-        }
-        const keys = Object.keys(data);
-        const values = Object.values(data);
-        const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
-        const query2 = `INSERT INTO ${table2} (${keys.join(", ")}) VALUES (${placeholders})`;
-        const result = await txClient.query(query2, values);
-        return { operation: "insert", affected: result.rowCount ?? 0 };
-      },
-      get: async (table2, where) => {
-        const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-        if (!whereClause) {
-          throw new DatabaseError(
-            "GET requires at least one WHERE condition to prevent returning an arbitrary record",
-            { table: table2 }
-          );
-        }
-        const query2 = `SELECT * FROM ${table2} ${whereClause}`;
-        const result = await txClient.query(query2, values);
-        return result.rows[0] || null;
-      },
-      list: async (table2, where) => {
-        const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-        const query2 = `SELECT * FROM ${table2} ${whereClause}`;
-        const result = await txClient.query(query2, values);
-        return result.rows;
-      },
-      update: async (table2, where, data) => {
-        const keys = Object.keys(data);
-        const values = Object.values(data);
-        const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-        const { sql: whereClause, values: whereValues } = buildWhere(
-          where,
-          values.length + 1,
-          "postgres"
-        );
-        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}`;
-        const result = await txClient.query(sql, [...values, ...whereValues]);
-        return { operation: "update", affected: result.rowCount ?? 0 };
-      },
-      upsert: async (table2, conflictColumns, data, options2) => executePostgresUpsert(
-        txClient,
-        table2,
-        conflictColumns,
-        data,
-        options2,
-        false
-      ),
-      getOrInsert: async (table2, where, data) => {
-        const result = await txHandle.get(table2, where);
-        if (result) return result;
-        await txHandle.insert(table2, data);
-        const inserted = await txHandle.get(table2, where);
-        if (!inserted) {
-          throw new DatabaseError("Failed to insert and retrieve record", {
-            table: table2,
-            where,
-            data
-          });
-        }
-        return inserted;
-      },
-      delete: 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, "postgres");
-        const result = await txClient.query(
-          `DELETE FROM ${table2} ${whereClause}`,
-          values
-        );
-        return { operation: "delete", affected: result.rowCount ?? 0 };
-      },
-      count: async (table2, where) => {
-        validateTableName(table2);
-        if (!where || Object.keys(where).length === 0) {
-          const result2 = await txClient.query(
-            `SELECT COUNT(*) as count FROM ${table2}`
-          );
-          return Number(result2.rows[0]?.count) || 0;
-        }
-        const { sql: whereClause, values } = buildWhere(where, 1, "postgres");
-        const result = await txClient.query(
-          `SELECT COUNT(*) as count FROM ${table2} ${whereClause}`,
-          values
-        );
-        return Number(result.rows[0]?.count) || 0;
-      },
-      table: (tableName) => ({
-        insert: (data) => txHandle.insert(tableName, data),
-        get: (data) => txHandle.get(tableName, data),
-        list: (data) => txHandle.list(tableName, data)
-      }),
-      many: async (strings, ...vars) => {
-        const { sql, values } = parseTemplate(strings, ...vars);
-        const result = await txClient.query(sql, values);
-        return result.rows;
-      },
-      single: async (strings, ...vars) => {
-        const { sql, values } = parseTemplate(strings, ...vars);
-        const result = await txClient.query(sql, values);
-        return result.rows[0] || null;
-      },
-      pluck: async (strings, ...vars) => {
-        const { sql, values } = parseTemplate(strings, ...vars);
-        const result = await txClient.query(sql, values);
-        const firstRow = result.rows[0];
-        if (!firstRow) return null;
-        return Object.values(firstRow)[0];
-      },
-      execute: async (strings, ...vars) => {
-        const { sql, values } = parseTemplate(strings, ...vars);
-        await txClient.query(sql, values);
-      },
-      query: async (sql, ...values) => {
-        const query2 = normalizePostgresRawQuery(sql, values);
-        const result = await txClient.query(query2.sql, query2.values);
-        return {
-          rows: result.rows,
-          rowCount: result.rowCount ?? 0
-        };
-      },
-      oo: async (strings, ...vars) => {
-        const { sql, values } = parseTemplate(strings, ...vars);
-        const result = await txClient.query(sql, values);
-        return result.rows;
-      },
-      oO: async (strings, ...vars) => {
-        const { sql, values } = parseTemplate(strings, ...vars);
-        const result = await txClient.query(sql, values);
-        return result.rows[0] || null;
-      },
-      ox: async (strings, ...vars) => {
-        const { sql, values } = parseTemplate(strings, ...vars);
-        const result = await txClient.query(sql, values);
-        const firstRow = result.rows[0];
-        if (!firstRow) return null;
-        return Object.values(firstRow)[0];
-      },
-      xx: async (strings, ...vars) => {
-        const { sql, values } = parseTemplate(strings, ...vars);
-        await txClient.query(sql, values);
-      },
-      tableExists: tableExists2,
-      syncSchema: syncSchema2,
-      transaction,
-      commit,
-      rollback,
-      isActive
-    };
-    return txHandle;
-  };
-  const oo = many;
-  const oO = single;
-  const ox = pluck;
-  const xx = execute;
-  const initializeSchemas = async (options2) => {
-    const schemaManager = new DatabaseSchemaManager();
-    const currentDb = {
-      url,
-      client,
-      insert,
-      update,
-      upsert,
-      get,
-      getOrInsert,
-      delete: deleteRecords,
-      count,
-      list,
-      table,
-      many,
-      single,
-      pluck,
-      execute,
-      query,
-      oo,
-      oO,
-      ox,
-      xx,
-      tableExists: tableExists2,
-      syncSchema: syncSchema2,
-      transaction
-    };
-    await schemaManager.initializeSchemas(currentDb, options2);
-  };
-  const getTableSchema = async (table2) => {
-    validateTableName(table2);
-    try {
-      const exists = await tableExists2(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}
-          AND table_schema = 'public'
-        ORDER BY ordinal_position
-      `;
-      const pkRows = await many`
-        SELECT kcu.column_name
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu
-          ON tc.constraint_name = kcu.constraint_name
-          AND tc.table_schema = kcu.table_schema
-        WHERE tc.table_name = ${table2}
-          AND tc.table_schema = 'public'
-          AND tc.constraint_type = 'PRIMARY KEY'
-      `;
-      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
-          indexname,
-          indexdef
-        FROM pg_indexes
-        WHERE tablename = ${table2}
-          AND schemaname = 'public'
-          AND indexname NOT LIKE '%_pkey'
-      `;
-      const indexes = [];
-      for (const row of indexRows) {
-        const indexName = row.indexname;
-        const indexDef = row.indexdef;
-        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
-          kcu.column_name,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name,
-          rc.delete_rule,
-          rc.update_rule
-        FROM information_schema.table_constraints AS tc
-        JOIN information_schema.key_column_usage AS kcu
-          ON tc.constraint_name = kcu.constraint_name
-          AND tc.table_schema = kcu.table_schema
-        JOIN information_schema.constraint_column_usage AS ccu
-          ON ccu.constraint_name = tc.constraint_name
-          AND ccu.table_schema = tc.table_schema
-        JOIN information_schema.referential_constraints AS rc
-          ON rc.constraint_name = tc.constraint_name
-          AND rc.constraint_schema = tc.table_schema
-        WHERE tc.constraint_type = 'FOREIGN KEY'
-          AND tc.table_name = ${table2}
-          AND tc.table_schema = 'public'
-      `;
-      const foreignKeys = [];
-      for (const fkRow of fkRows) {
-        foreignKeys.push({
-          column: fkRow.column_name,
-          referencesTable: fkRow.foreign_table_name,
-          referencesColumn: fkRow.foreign_column_name,
-          onDelete: fkRow.delete_rule,
-          onUpdate: fkRow.update_rule
-        });
-      }
-      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$1(column.name);
-      try {
-        const sql = generateAddColumnStatement(table2, column, "postgres");
-        await client.query(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, index2) => {
-      validateTableName(table2);
-      validateIndexName(index2.name);
-      for (const col of index2.columns) {
-        validateColumnName$1(col);
-      }
-      try {
-        const sql = generateCreateIndexStatement(table2, index2);
-        await client.query(sql);
-      } catch (e) {
-        throw new DatabaseError("Failed to create index on table", {
-          table: table2,
-          index: index2.name,
-          originalError: formatDbError(e)
-        });
-      }
-    }
-  };
-  const db = {
-    url,
-    client,
-    insert,
-    update,
-    upsert,
-    get,
-    getOrInsert,
-    delete: deleteRecords,
-    count,
-    list,
-    table,
-    many,
-    single,
-    pluck,
-    execute,
-    query,
-    oo,
-    oO,
-    ox,
-    xx,
-    tableExists: tableExists2,
-    syncSchema: syncSchema2,
-    initializeSchemas,
-    transaction,
-    beginTransaction,
-    acquireSession,
-    getTableSchema,
-    alterTable,
-    vector: createVectorCapabilities(pool)
-  };
-  const finalCacheKey = cacheKey || url;
-  connectionCache.set(finalCacheKey, db);
-  return db;
-}
-const postgres = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  clearPostgresConnectionCache,
-  getDatabase: getDatabase$1
-}, Symbol.toStringTag, { value: "Module" }));
-function isDatabaseInstance(value) {
-  return value && typeof value === "object" && typeof value.client !== "undefined" && typeof value.insert === "function" && typeof value.get === "function" && typeof value.query === "function";
-}
-async function getDatabase(options = {}) {
-  if (isDatabaseInstance(options)) {
-    return options;
-  }
-  Object.assign(
-    options,
-    loadEnvConfig(options, {
-      packageName: "sql",
-      schema: {
-        type: "string",
-        url: "string",
-        host: "string",
-        port: "number",
-        database: "string",
-        user: "string",
-        password: "string"
-      }
-    })
-  );
-  if (!options.type && (options.url?.startsWith("file:") || options.url === ":memory:")) {
-    options.type = "sqlite";
-  }
-  if (options.type === "postgres") {
-    const postgres$1 = await Promise.resolve().then(() => postgres);
-    return postgres$1.getDatabase(options);
-  }
-  if (options.type === "sqlite") {
-    const sqlite = await import("./sqlite-CPCNeJIH.js");
-    return sqlite.getDatabase(options);
-  }
-  if (options.type === "duckdb") {
-    const duckdb = await import("./duckdb-B6m78QdL.js");
-    return duckdb.getDatabase(options);
-  }
-  if (options.type === "json") {
-    const json$1 = await Promise.resolve().then(() => json);
-    return json$1.getDatabase(options);
-  }
-  throw new Error("Invalid database type");
-}
-async function syncSchema(options) {
-  const { db, schema } = options;
-  if (!db || !schema) {
-    throw new Error("db and schema are required");
-  }
-  if (db.syncSchema) {
-    await db.syncSchema(schema);
-  } else {
-    throw new Error("Database adapter does not support schema synchronization");
-  }
-}
-async function tableExists(db, tableName) {
-  return db.tableExists(tableName);
-}
-function escapeSqlValue(value) {
-  if (value === null) {
-    return "NULL";
-  }
-  if (value instanceof Date) {
-    return `'${value.toISOString()}'`;
-  }
-  if (typeof value === "number") {
-    return value.toString();
-  }
-  if (typeof value === "boolean") {
-    return value ? "1" : "0";
-  }
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-function validateColumnName(column) {
-  if (!/^[a-zA-Z0-9_.]+$/.test(column)) {
-    throw new Error(`Invalid column name: ${column}`);
-  }
-  return column;
-}
-const index = {
-  getDatabase,
-  syncSchema,
-  tableExists,
-  buildWhere
-};
-const PACKAGE_VERSION_INITIALIZED = true;
-export {
-  DatabaseSchemaManager as D,
-  PACKAGE_VERSION_INITIALIZED as P,
-  validateIndexName as a,
-  validateColumnName$1 as b,
-  generateAddColumnStatement as c,
-  buildWhere as d,
-  convertUniqueIndexesToInlineConstraints as e,
-  formatDbError as f,
-  generateCreateIndexStatement as g,
-  bucketExpr as h,
-  buildAggregate as i,
-  checkExpectedTables as j,
-  checkRelationship as k,
-  checkUniqueColumn as l,
-  clearConnectionCache as m,
-  clearPostgresConnectionCache as n,
-  index as o,
-  escapeSqlValue as p,
-  getDatabase as q,
-  resolveSchemas as r,
-  runDoctor as s,
-  syncSchema as t,
-  tableExists as u,
-  validateTableName as v,
-  validateColumnName as w
-};
-//# sourceMappingURL=index-CzdYvRFp.js.map