@happyvertical/sql 0.74.8

package/dist/chunks/index-DL-5nB7l.js

@@ -0,0 +1,3468 @@
+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"
+};
+const buildCondition = (fullKey, value, currIndex, adapterType) => {
+  const [field, operator = "="] = fullKey.split(" ");
+  const sqlOperator = VALID_OPERATORS[operator] || "=";
+  const values = [];
+  let sql;
+  if (value === null) {
+    sql = `${field} IS ${sqlOperator === "=" ? "NULL" : "NOT NULL"}`;
+  } else if (sqlOperator === "IN" && Array.isArray(value)) {
+    const placeholders = value.map(() => `$${currIndex.value++}`).join(", ");
+    sql = `${field} IN (${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 };
+};
+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
+                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-DkCGjXmu.js");
+    return sqlite.getDatabase(options);
+  }
+  if (options.type === "duckdb") {
+    const duckdb = await import("./duckdb-Djx8WKZE.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,
+  checkExpectedTables as h,
+  checkRelationship as i,
+  checkUniqueColumn as j,
+  clearConnectionCache as k,
+  clearPostgresConnectionCache as l,
+  index as m,
+  escapeSqlValue as n,
+  getDatabase as o,
+  runDoctor as p,
+  validateColumnName as q,
+  resolveSchemas as r,
+  syncSchema as s,
+  tableExists as t,
+  validateTableName as v
+};
+//# sourceMappingURL=index-DL-5nB7l.js.map