@happyvertical/sql 0.89.3 → 0.89.5

package/dist/chunks/sqlite-BPI6YDpW.js

@@ -1,1136 +0,0 @@
-import { b as wrapDatabaseError, d as validateIndexName, f as validateTableName, h as formatDbError, l as validateColumnName, m as buildWhere, o as generateAddColumnStatement, p as DatabaseSchemaManager, r as validateDatabaseCacheOptions, s as generateCreateIndexStatement, u as validateColumnNames, v as resolveInsertColumns } from "./connection-cache-Da5UcY5u.js";
-import { t as redactDatabaseUrl } from "./redact-database-url-CfMDvSdy.js";
-import { n as resolveSchemas, r as createTransactionLock } from "./types-uVFHgaSU.js";
-import { t as getCachedSqliteDatabase } from "./sqlite-connection-cache-DwlyWaqG.js";
-import { DatabaseError } from "@happyvertical/utils";
-//#region src/sqlite.ts
-/**
-* Connection cache for in-memory databases with memoryId
-* Enables sharing of :memory: databases across multiple getDatabase() calls
-*/
-var NULL_AWARE_UPSERT_MAX_ATTEMPTS = 8;
-var NULL_AWARE_UPSERT_BASE_DELAY_MS = 25;
-var nullAwareUpsertLocks = /* @__PURE__ */ new Map();
-function delay(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isRetriableSqliteTransactionError(error) {
-	const formatted = formatDbError(error).toLowerCase();
-	return formatted.includes("busy") || formatted.includes("locked") || formatted.includes("database is locked");
-}
-async function withNullAwareUpsertLock(lockKey, callback) {
-	const previous = nullAwareUpsertLocks.get(lockKey) ?? Promise.resolve();
-	let release = () => {};
-	const current = new Promise((resolve) => {
-		release = resolve;
-	});
-	const next = previous.catch(() => {}).then(() => current);
-	nullAwareUpsertLocks.set(lockKey, next);
-	await previous.catch(() => {});
-	try {
-		return await callback();
-	} finally {
-		release();
-		if (nullAwareUpsertLocks.get(lockKey) === next) nullAwareUpsertLocks.delete(lockKey);
-	}
-}
-/**
-* Generates a unique identifier for in-memory databases
-* @returns A unique database identifier string
-*/
-function generateDbId() {
-	return `memory-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-/**
-* Creates a LibSQL client using the default client implementation
-* Supports in-memory databases and remote LibSQL URLs
-*
-* @param options - SQLite connection options
-* @returns Promise resolving to a LibSQL client instance
-*/
-async function createLibSQLClient(options) {
-	const { url = ":memory:", authToken, encryptionKey } = options;
-	let libsqlUrl = url;
-	const remoteUrl = url.replace(/[\t\n\r]/g, "").trim();
-	const hasRemoteScheme = /^(?:https?|libsql):/i.test(remoteUrl);
-	if (hasRemoteScheme) {
-		libsqlUrl = remoteUrl;
-		let parsedRemoteUrl;
-		try {
-			parsedRemoteUrl = new URL(remoteUrl);
-		} catch {
-			const safeUrl = redactDatabaseUrl(remoteUrl);
-			throw new DatabaseError(`Invalid remote database URL: ${safeUrl}`, { url: safeUrl });
-		}
-		if (!/^(?:https?|libsql):\/\//i.test(remoteUrl) || !parsedRemoteUrl.host) {
-			const safeUrl = redactDatabaseUrl(remoteUrl);
-			throw new DatabaseError(`Invalid remote database URL: ${safeUrl}`, { url: safeUrl });
-		}
-	}
-	if (url !== ":memory:" && !hasRemoteScheme && !url.startsWith("file:")) {
-		const { resolve } = await import("node:path");
-		libsqlUrl = `file://${resolve(url)}`;
-	}
-	try {
-		const { createClient } = await import(
-			/* @vite-ignore */
-			"@libsql/client"
-);
-		return createClient({
-			url: libsqlUrl,
-			authToken,
-			encryptionKey
-		});
-	} catch (error) {
-		const errorMessage = redactDatabaseUrl(error instanceof Error ? error.message : String(error));
-		const safeUrl = redactDatabaseUrl(libsqlUrl);
-		if (errorMessage?.includes("URL_SCHEME_NOT_SUPPORTED")) throw new DatabaseError(`Unsupported URL scheme. Use ':memory:' for in-memory databases or 'libsql://' for remote LibSQL databases. URL: ${safeUrl}`, {
-			url: safeUrl,
-			originalError: errorMessage
-		});
-		throw new DatabaseError(`Failed to create LibSQL client: ${errorMessage}`, {
-			url: safeUrl,
-			originalError: errorMessage
-		});
-	}
-}
-function hasNativeSqliteCapabilities(options) {
-	return Boolean(options.capabilities?.notifications || options.capabilities?.vector);
-}
-/**
-* Creates tables from provided schema definitions
-*
-* @param client - LibSQL client
-* @param schemas - Schema definitions to create
-*/
-async function createTablesFromSchemas(client, schemas) {
-	for (const [tableName, schema] of Object.entries(schemas)) try {
-		if ((await client.execute({
-			sql: `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
-			args: [tableName]
-		})).rows.length > 0) {
-			console.log(`[sqlite] Table ${tableName} already exists, skipping`);
-			continue;
-		}
-		console.log(`[sqlite] Creating table ${tableName} from provided schema`);
-		await client.execute(schema.ddl);
-		if (schema.indexes && schema.indexes.length > 0) for (const indexSQL of schema.indexes) try {
-			await client.execute(indexSQL);
-		} catch (error) {
-			console.warn(`[sqlite] Failed to create index for ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		if (schema.triggers && schema.triggers.length > 0) for (const triggerSQL of schema.triggers) try {
-			await client.execute(triggerSQL);
-		} catch (error) {
-			console.warn(`[sqlite] Failed to create trigger for ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	} catch (error) {
-		console.error(`[sqlite] Error creating table ${tableName}:`, error instanceof Error ? error.message : String(error));
-		console.error(`[sqlite] DDL was:`, schema.ddl?.substring(0, 200) + "...");
-		throw new DatabaseError(`Failed to create table ${tableName} from schema: ${error instanceof Error ? error.message : String(error)}`, {
-			tableName,
-			schema,
-			originalError: error instanceof Error ? error.message : String(error)
-		});
-	}
-}
-/**
-* Creates a SQLite database adapter
-*
-* @param options - SQLite connection options
-* @returns Database interface for SQLite
-*/
-async function getDatabase(options = {}) {
-	validateDatabaseCacheOptions(options);
-	const url = options.url || ":memory:";
-	if (url === ":memory:" && !options.dbid && options.cache !== false) options.dbid = generateDbId();
-	if (hasNativeSqliteCapabilities(options)) return (await import("./sqlite-native-DBbBMvTD.js")).getNativeSqliteDatabase(options);
-	return getCachedSqliteDatabase("libsql", options, () => createDatabase(options, url));
-}
-async function createDatabase(options, url) {
-	return (async () => {
-		const client = await createLibSQLClient(options);
-		const connectionLock = createTransactionLock("sqlite", options.transactionQueueTimeout);
-		const resolvedSchemas = resolveSchemas(options.schemas);
-		if (resolvedSchemas && Object.keys(resolvedSchemas).length > 0) try {
-			await createTablesFromSchemas(client, resolvedSchemas);
-		} catch (error) {
-			try {
-				client.close();
-			} catch (cleanupError) {
-				throw new AggregateError([error, cleanupError], "LibSQL schema initialization and cleanup failed");
-			}
-			throw error;
-		}
-		/**
-		* Serializes a value for SQLite storage
-		* Converts objects and arrays to JSON strings
-		* Converts Dates to ISO strings
-		* Passes through primitives unchanged
-		*/
-		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;
-		};
-		/**
-		* Serializes all values in an object
-		*/
-		const serializeRecord = (record) => {
-			const serialized = {};
-			for (const [key, value] of Object.entries(record)) {
-				if (value === void 0) continue;
-				serialized[key] = serializeValue(value);
-			}
-			return serialized;
-		};
-		const hasNullConflictValue = (conflictColumns, data) => conflictColumns.some((col) => data[col] === null);
-		const buildNullAwareUpsertLockKey = (table, conflictColumns, data) => {
-			return `${url}:${table}:${conflictColumns.map((col) => `${col}:${JSON.stringify(data[col])}`).join("|")}`;
-		};
-		const validateUpsertConflictColumns = (table, conflictColumns, serializedData) => {
-			const missingColumns = conflictColumns.filter((col) => !(col in serializedData));
-			if (missingColumns.length > 0) throw new DatabaseError("Conflict columns missing from data", {
-				table,
-				conflictColumns,
-				missingColumns,
-				availableColumns: Object.keys(serializedData),
-				hint: "All columns specified in ON CONFLICT must be present in the data being inserted. Undefined values are filtered out during serialization - consider using null or an empty string instead."
-			});
-		};
-		const executeStandardUpsert = async (table, conflictColumns, serializedData) => {
-			const keys = Object.keys(serializedData);
-			const values = Object.values(serializedData);
-			const placeholders = keys.map(() => "?").join(", ");
-			const updateSet = keys.map((key) => `${key} = excluded.${key}`).join(", ");
-			const conflict = conflictColumns.join(", ");
-			const sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${conflict}) DO UPDATE SET ${updateSet}`;
-			return {
-				operation: "upsert",
-				affected: (await client.execute({
-					sql,
-					args: values
-				})).rowsAffected
-			};
-		};
-		const executeNullAwareUpsertAttempt = async (executor, table, conflictColumns, serializedData) => {
-			const keys = Object.keys(serializedData);
-			const values = Object.values(serializedData);
-			const updateSet = keys.map((key) => `${key} = ?`).join(", ");
-			const whereClause = conflictColumns.map((col) => `${col} IS ?`).join(" AND ");
-			const whereValues = conflictColumns.map((col) => serializedData[col]);
-			const updateSql = `UPDATE ${table} SET ${updateSet} WHERE ${whereClause}`;
-			const updateResult = await executor.execute({
-				sql: updateSql,
-				args: [...values, ...whereValues]
-			});
-			if ((updateResult.rowsAffected ?? 0) > 0) return {
-				operation: "upsert",
-				affected: updateResult.rowsAffected
-			};
-			const placeholders = keys.map(() => "?").join(", ");
-			const insertSql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
-			return {
-				operation: "upsert",
-				affected: (await executor.execute({
-					sql: insertSql,
-					args: values
-				})).rowsAffected
-			};
-		};
-		const executeNullAwareUpsertWithRetry = async (table, conflictColumns, serializedData) => {
-			if (url === ":memory:") return executeNullAwareUpsertAttempt(client, table, conflictColumns, serializedData);
-			let lastError;
-			for (let attempt = 0; attempt < NULL_AWARE_UPSERT_MAX_ATTEMPTS; attempt++) {
-				let transaction;
-				const releaseConnection = await connectionLock.acquire();
-				try {
-					transaction = await client.transaction("write");
-					const result = await executeNullAwareUpsertAttempt(transaction, table, conflictColumns, serializedData);
-					await transaction.commit();
-					return result;
-				} catch (error) {
-					lastError = error;
-					if (transaction && !transaction.closed) try {
-						await transaction.rollback();
-					} catch (_rollbackError) {}
-				} finally {
-					transaction?.close();
-					releaseConnection();
-				}
-				if (lastError && attempt < NULL_AWARE_UPSERT_MAX_ATTEMPTS - 1 && isRetriableSqliteTransactionError(lastError)) {
-					await delay(NULL_AWARE_UPSERT_BASE_DELAY_MS * 2 ** attempt);
-					continue;
-				}
-				break;
-			}
-			throw lastError;
-		};
-		/**
-		* Rejects hostile table/column identifiers before an upsert builds SQL.
-		*
-		* Called from the public entry points rather than from `executeUpsert`, so
-		* the failure reaches the caller naming the bad identifier instead of being
-		* flattened into the wrapper's generic "Failed to upsert record into table".
-		*
-		* Validates the keys of the already-serialized snapshot — the exact array
-		* the executors interpolate — not a fresh enumeration of the caller's
-		* `data`. Enumerating `data` again could disagree with the snapshot if it is
-		* a Proxy whose `ownKeys` trap returns different keys on successive reads.
-		*/
-		const validateUpsertIdentifiers = (table, conflictColumns, serializedData) => {
-			validateTableName(table);
-			validateColumnNames([...conflictColumns, ...Object.keys(serializedData)]);
-		};
-		const executeUpsert = async (table, conflictColumns, serializedData, options, acquireTransaction) => {
-			validateUpsertConflictColumns(table, conflictColumns, serializedData);
-			if (options?.nullsDistinct || !hasNullConflictValue(conflictColumns, serializedData)) return executeStandardUpsert(table, conflictColumns, serializedData);
-			if (!acquireTransaction) return executeNullAwareUpsertAttempt(client, table, conflictColumns, serializedData);
-			return withNullAwareUpsertLock(buildNullAwareUpsertLockKey(table, conflictColumns, serializedData), () => executeNullAwareUpsertWithRetry(table, conflictColumns, serializedData));
-		};
-		/**
-		* Inserts one or more records into a table
-		*
-		* @param table - Table name
-		* @param data - Single record or array of records to insert
-		* @returns Promise resolving to operation result
-		* @throws Error if the insert operation fails
-		*/
-		const insert = async (table, data) => {
-			validateTableName(table);
-			let sql;
-			let values;
-			if (Array.isArray(data)) {
-				if (data.length === 0) return {
-					operation: "insert",
-					affected: 0
-				};
-				const serializedRecords = data.map((record) => serializeRecord(record));
-				const keys = resolveInsertColumns(table, serializedRecords);
-				validateColumnNames(keys);
-				const placeholders = serializedRecords.map(() => `(${keys.map(() => "?").join(", ")})`).join(", ");
-				sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${placeholders}`;
-				values = serializedRecords.flatMap((record) => keys.map((key) => record[key]));
-			} else {
-				const serializedData = serializeRecord(data);
-				const keys = Object.keys(serializedData);
-				validateColumnNames(keys);
-				const placeholders = keys.map(() => "?").join(", ");
-				sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders})`;
-				values = Object.values(serializedData);
-			}
-			try {
-				return {
-					operation: "insert",
-					affected: (await client.execute({
-						sql,
-						args: values
-					})).rowsAffected
-				};
-			} catch (e) {
-				throw new DatabaseError("Failed to insert records into table", {
-					table,
-					sql,
-					values,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Retrieves a single record matching the where criteria
-		*
-		* @param table - Table name
-		* @param where - Criteria to match records
-		* @returns Promise resolving to matching record or null if not found
-		* @throws Error if the query fails
-		*/
-		const get = async (table, where) => {
-			validateTableName(table);
-			const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
-			if (!whereClause) throw new DatabaseError("GET requires at least one WHERE condition to prevent returning an arbitrary record", { table });
-			const sql = `SELECT * FROM ${table} ${whereClause}`;
-			try {
-				return (await client.execute({
-					sql,
-					args: values
-				})).rows[0] || null;
-			} catch (e) {
-				throw new DatabaseError("Failed to retrieve record from table", {
-					table,
-					sql,
-					values,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Retrieves multiple records matching the where criteria
-		*
-		* @param table - Table name
-		* @param where - Criteria to match records
-		* @returns Promise resolving to array of matching records
-		* @throws Error if the query fails
-		*/
-		const list = async (table, where) => {
-			validateTableName(table);
-			const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
-			const sql = `SELECT * FROM ${table} ${whereClause}`;
-			try {
-				return (await client.execute({
-					sql,
-					args: values
-				})).rows;
-			} catch (e) {
-				throw new DatabaseError("Failed to list records from table", {
-					table,
-					sql,
-					values,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Updates records matching the where criteria
-		*
-		* @param table - Table name
-		* @param where - Criteria to match records to update
-		* @param data - New data to set
-		* @returns Promise resolving to operation result
-		* @throws Error if the update operation fails
-		*/
-		const update = async (table, where, data) => {
-			validateTableName(table);
-			const serializedData = serializeRecord(data);
-			const keys = Object.keys(serializedData);
-			validateColumnNames(keys);
-			const values = Object.values(serializedData);
-			const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
-			const { sql: whereClause, values: whereValues } = buildWhere(where, values.length + 1, "sqlite");
-			if (!whereClause) throw new DatabaseError("UPDATE requires at least one WHERE condition to prevent accidental update of all records", { table });
-			const sql = `UPDATE ${table} SET ${setClause} ${whereClause}`;
-			try {
-				return {
-					operation: "update",
-					affected: (await client.execute({
-						sql,
-						args: [...values, ...whereValues]
-					})).rowsAffected
-				};
-			} catch (e) {
-				throw new DatabaseError("Failed to update records in table", {
-					table,
-					sql,
-					values: [...values, ...whereValues],
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Inserts a record or updates it if it already exists (UPSERT)
-		*
-		* @param table - Table name
-		* @param conflictColumns - Columns that define the uniqueness constraint
-		* @param data - Data to insert or update
-		* @returns Promise resolving to operation result
-		* @throws Error if the upsert operation fails
-		*/
-		const upsert = async (table, conflictColumns, data, options) => {
-			const serializedData = serializeRecord(data);
-			const conflictCols = [...conflictColumns];
-			validateUpsertIdentifiers(table, conflictCols, serializedData);
-			try {
-				return await executeUpsert(table, conflictCols, serializedData, options, 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,
-					values: data,
-					conflictColumns,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		let savepointSequence = 0;
-		const upsertInCurrentTransaction = async (table, conflictColumns, data, options) => {
-			const serializedData = serializeRecord(data);
-			const conflictCols = [...conflictColumns];
-			validateUpsertIdentifiers(table, conflictCols, serializedData);
-			try {
-				return await executeUpsert(table, conflictCols, serializedData, options, false);
-			} catch (e) {
-				if (e instanceof DatabaseError && e.message === "Conflict columns missing from data") throw e;
-				throw new DatabaseError("Failed to upsert record into table", {
-					table,
-					values: data,
-					conflictColumns,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Gets a record matching the where criteria or inserts it if not found
-		*
-		* @param table - Table name
-		* @param where - Criteria to match existing record
-		* @param data - Data to insert if no record found
-		* @returns Promise resolving to the record (either retrieved or newly inserted)
-		* @throws Error if the operation fails or if the record cannot be retrieved after insert
-		*/
-		const getOrInsert = async (table, where, data) => {
-			const result = await get(table, where);
-			if (result) return result;
-			await insert(table, data);
-			const inserted = await get(table, where);
-			if (!inserted) throw new DatabaseError("Failed to insert and retrieve record", {
-				table,
-				where,
-				data
-			});
-			return inserted;
-		};
-		/**
-		* Deletes records from a table matching the where criteria
-		*
-		* @param table - Table name
-		* @param where - Criteria to match records for deletion
-		* @returns Promise resolving to operation result with count of deleted rows
-		* @throws Error if the delete operation fails
-		*/
-		const deleteRecords = async (table, where) => {
-			validateTableName(table);
-			if (Object.keys(where).length === 0) throw new DatabaseError("DELETE requires at least one WHERE condition to prevent accidental deletion of all records", { table });
-			const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
-			try {
-				await client.execute({
-					sql: `DELETE FROM ${table} ${whereClause}`,
-					args: values
-				});
-				return {
-					operation: "delete",
-					affected: 1
-				};
-			} catch (e) {
-				throw new DatabaseError("Failed to delete records from table", {
-					table,
-					where,
-					originalError: e
-				});
-			}
-		};
-		/**
-		* Counts records in a table matching the where criteria
-		*
-		* @param table - Table name
-		* @param where - Criteria to match records (optional, counts all if omitted)
-		* @returns Promise resolving to count of matching records
-		* @throws Error if the count operation fails
-		*/
-		const count = async (table, where) => {
-			validateTableName(table);
-			try {
-				if (!where || Object.keys(where).length === 0) {
-					const result = await client.execute({
-						sql: `SELECT COUNT(*) as count FROM ${table}`,
-						args: []
-					});
-					return Number(result.rows[0]?.count) || 0;
-				}
-				const { sql: whereClause, values } = buildWhere(where, 1, "sqlite");
-				const result = await client.execute({
-					sql: `SELECT COUNT(*) as count FROM ${table} ${whereClause}`,
-					args: values
-				});
-				return Number(result.rows[0]?.count) || 0;
-			} catch (e) {
-				throw new DatabaseError("Failed to count records in table", {
-					table,
-					where,
-					originalError: e
-				});
-			}
-		};
-		/**
-		* Checks if a table exists in the database
-		*
-		* @param tableName - Name of the table to check
-		* @returns Promise resolving to boolean indicating if the table exists
-		*/
-		const tableExists = async (tableName) => {
-			return !!await pluck`SELECT name FROM sqlite_master WHERE type='table' AND name=${tableName}`;
-		};
-		/**
-		* Synchronizes database schema with provided SQL DDL
-		* Creates tables if they don't exist and adds missing columns
-		*
-		* @param schema - SQL schema definition with CREATE TABLE statements
-		* @returns Promise that resolves when schema is synchronized
-		*/
-		const syncSchema = async (schema) => {
-			console.log("[sqlite.syncSchema] Starting schema sync for dbid:", options.dbid);
-			console.log("[sqlite.syncSchema] Schema length:", schema.length, "chars");
-			const reservedKeywords = /* @__PURE__ */ new Set([
-				"references",
-				"order",
-				"group",
-				"table",
-				"index",
-				"select",
-				"from",
-				"where",
-				"join",
-				"left",
-				"right",
-				"inner",
-				"outer",
-				"on",
-				"as",
-				"and",
-				"or",
-				"not",
-				"like",
-				"in",
-				"between",
-				"case",
-				"when",
-				"then",
-				"else",
-				"end",
-				"union",
-				"distinct",
-				"having",
-				"limit",
-				"offset",
-				"default",
-				"check",
-				"unique",
-				"primary",
-				"foreign",
-				"key",
-				"constraint",
-				"cascade"
-			]);
-			let normalizedSchema = schema.replace(/\s+/g, " ").replace(/DEFAULT CAST\(([^)]+)\s+AS\s+\w+\)/gi, "DEFAULT $1").trim();
-			normalizedSchema = normalizedSchema.replace(/"(\w+)"/g, (match, identifier) => {
-				return reservedKeywords.has(identifier.toLowerCase()) ? match : identifier;
-			});
-			console.log("[sqlite.syncSchema] Normalized schema:", normalizedSchema);
-			const commands = normalizedSchema.split(";").map((cmd) => cmd.trim()).filter((cmd) => cmd.length > 0);
-			console.log("[sqlite.syncSchema] Found", commands.length, "commands to process");
-			for (const command of commands) try {
-				console.log("[sqlite.syncSchema] Executing:", `${command.substring(0, 50)}...`);
-				await client.execute(command);
-				console.log("[sqlite.syncSchema] Successfully executed command");
-			} catch (error) {
-				console.error("[sqlite.syncSchema] Failed to execute command:", command);
-				console.error("[sqlite.syncSchema] Error:", error);
-				throw error;
-			}
-		};
-		/**
-		* Executes a callback within a database transaction
-		* Automatically commits on success or rolls back on error
-		*
-		* @param callback - Function to execute within transaction
-		* @returns Promise resolving to callback result
-		*/
-		const transaction = async (callback) => connectionLock.run(async () => {
-			try {
-				await client.execute({
-					sql: "BEGIN TRANSACTION",
-					args: []
-				});
-				const result = await callback(createTransactionScope());
-				await client.execute({
-					sql: "COMMIT",
-					args: []
-				});
-				return result;
-			} catch (error) {
-				try {
-					await client.execute({
-						sql: "ROLLBACK",
-						args: []
-					});
-				} catch {}
-				throw error;
-			}
-		});
-		/**
-		* Builds the transaction-scoped interface handed to a transaction callback.
-		*
-		* The only difference from the top-level interface is `transaction`: this
-		* one re-enters the transaction already in progress under a savepoint
-		* instead of issuing a second BEGIN. SQLite shares one connection, so the
-		* old behaviour of re-exposing the top-level `transaction` sent a nested
-		* call into `BEGIN` on a connection that was already in a transaction; that
-		* throws, and the nested call's own ROLLBACK then discarded the *enclosing*
-		* transaction's work while later writes silently committed in autocommit.
-		*/
-		const createTransactionScope = () => {
-			return {
-				url,
-				client,
-				insert,
-				get,
-				list,
-				update,
-				upsert: upsertInCurrentTransaction,
-				getOrInsert,
-				delete: deleteRecords,
-				count,
-				table,
-				many,
-				single,
-				pluck,
-				execute,
-				query,
-				oo: many,
-				oO: single,
-				ox: pluck,
-				xx: execute,
-				tableExists,
-				syncSchema,
-				transaction: async (callback) => {
-					savepointSequence += 1;
-					const name = `hv_sp_${savepointSequence}`;
-					await client.execute({
-						sql: `SAVEPOINT ${name}`,
-						args: []
-					});
-					try {
-						const result = await callback(createTransactionScope());
-						await client.execute({
-							sql: `RELEASE SAVEPOINT ${name}`,
-							args: []
-						});
-						return result;
-					} catch (error) {
-						try {
-							await client.execute({
-								sql: `ROLLBACK TO SAVEPOINT ${name}`,
-								args: []
-							});
-							await client.execute({
-								sql: `RELEASE SAVEPOINT ${name}`,
-								args: []
-							});
-						} catch {}
-						throw error;
-					}
-				}
-			};
-		};
-		/**
-		* Begins a new transaction and returns a handle for manual control
-		*
-		* Unlike transaction(), this gives you explicit control over commit/rollback.
-		* Ideal for test isolation where you want to rollback after each test.
-		*
-		* @returns Promise resolving to a TransactionHandle
-		*/
-		const beginTransaction = async () => {
-			const releaseConnection = await connectionLock.acquire();
-			try {
-				await client.execute({
-					sql: "BEGIN TRANSACTION",
-					args: []
-				});
-			} catch (error) {
-				releaseConnection();
-				throw error;
-			}
-			let active = true;
-			const end = async (command) => {
-				if (!active) throw new DatabaseError("Transaction already ended", {});
-				try {
-					await client.execute({
-						sql: command,
-						args: []
-					});
-				} catch (error) {
-					try {
-						await client.execute({
-							sql: "ROLLBACK",
-							args: []
-						});
-					} catch {}
-					throw error;
-				} finally {
-					active = false;
-					releaseConnection();
-				}
-			};
-			const commit = () => end("COMMIT");
-			const rollback = () => end("ROLLBACK");
-			const isActive = () => active;
-			return {
-				...createTransactionScope(),
-				commit,
-				rollback,
-				isActive
-			};
-		};
-		/**
-		* Creates a table-specific interface for simplified table operations
-		*
-		* @param tableName - Table name
-		* @returns TableInterface for the specified table
-		*/
-		const table = (tableName) => ({
-			insert: (data) => insert(tableName, data),
-			get: (where) => get(tableName, where),
-			list: (where) => list(tableName, where)
-		});
-		/**
-		* Parses a tagged template literal into a SQL query and values
-		*
-		* @param strings - Template strings
-		* @param vars - Variables to interpolate into the query
-		* @returns Object with SQL query and values array
-		*/
-		const parseTemplate = (strings, ...vars) => {
-			let sql = strings[0];
-			const values = [];
-			for (let i = 0; i < vars.length; i++) {
-				values.push(vars[i]);
-				sql += `?${strings[i + 1]}`;
-			}
-			return {
-				sql,
-				values
-			};
-		};
-		/**
-		* Executes a SQL query using template literals and returns a single value
-		*
-		* @param strings - Template strings
-		* @param vars - Variables to interpolate into the query
-		* @returns Promise resolving to a single value (first column of first row)
-		* @throws Error if the query fails
-		*/
-		const pluck = async (strings, ...vars) => {
-			const { sql, values } = parseTemplate(strings, ...vars);
-			try {
-				const result = await client.execute({
-					sql,
-					args: values
-				});
-				return result.rows[0]?.[Object.keys(result.rows[0])[0]] ?? null;
-			} catch (e) {
-				throw new DatabaseError("Failed to execute pluck query", {
-					sql,
-					values,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Executes a SQL query using template literals and returns a single row
-		*
-		* @param strings - Template strings
-		* @param vars - Variables to interpolate into the query
-		* @returns Promise resolving to a single result record or null
-		* @throws Error if the query fails
-		*/
-		const single = async (strings, ...vars) => {
-			const { sql, values } = parseTemplate(strings, ...vars);
-			try {
-				return (await client.execute({
-					sql,
-					args: values
-				})).rows[0] || null;
-			} catch (e) {
-				throw new DatabaseError("Failed to execute single query", {
-					sql,
-					values,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Executes a SQL query using template literals and returns multiple rows
-		*
-		* @param strings - Template strings
-		* @param vars - Variables to interpolate into the query
-		* @returns Promise resolving to array of result records
-		* @throws Error if the query fails
-		*/
-		const many = async (strings, ...vars) => {
-			const { sql, values } = parseTemplate(strings, ...vars);
-			try {
-				return (await client.execute({
-					sql,
-					args: values
-				})).rows;
-			} catch (e) {
-				throw new DatabaseError("Failed to execute many query", {
-					sql,
-					values,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Executes a SQL query using template literals without returning results
-		*
-		* @param strings - Template strings
-		* @param vars - Variables to interpolate into the query
-		* @returns Promise that resolves when the query completes
-		* @throws Error if the query fails
-		*/
-		const execute = async (strings, ...vars) => {
-			const { sql, values } = parseTemplate(strings, ...vars);
-			try {
-				await client.execute({
-					sql,
-					args: values
-				});
-			} catch (e) {
-				throw new DatabaseError("Failed to execute query", {
-					sql,
-					values,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* Executes a raw SQL query with parameterized values
-		*
-		* @param str - SQL query string
-		* @param values - Variables to use as parameters
-		* @returns Promise resolving to query result with rows and metadata
-		* @throws Error if the query fails
-		*/
-		const query = async (str, ...values) => {
-			const sql = str;
-			const args = Array.isArray(values[0]) ? values[0] : values;
-			try {
-				const result = await client.execute({
-					sql,
-					args
-				});
-				return {
-					command: sql.split(" ")[0].toUpperCase(),
-					rowCount: result.rowsAffected ?? result.rows.length,
-					oid: null,
-					fields: Object.keys(result.rows[0] || {}).map((name) => ({
-						name,
-						tableID: 0,
-						columnID: 0,
-						dataTypeID: 0,
-						dataTypeSize: -1,
-						dataTypeModifier: -1,
-						format: "text"
-					})),
-					rows: result.rows
-				};
-			} catch (e) {
-				throw wrapDatabaseError("Failed to execute raw query", e, {
-					sql,
-					args
-				});
-			}
-		};
-		const oo = many;
-		const oO = single;
-		const ox = pluck;
-		const xx = execute;
-		/**
-		* Initialize database schemas from JSON manifest
-		* Supports dependency resolution and schema overrides
-		*
-		* @param options - Schema initialization options
-		* @returns Promise that resolves when schemas are initialized
-		*/
-		const initializeSchemas = async (options) => {
-			const schemaManager = new DatabaseSchemaManager();
-			const currentDb = {
-				url,
-				client,
-				query,
-				insert,
-				update,
-				upsert,
-				get,
-				list,
-				getOrInsert,
-				delete: deleteRecords,
-				count,
-				table,
-				tableExists,
-				many,
-				single,
-				pluck,
-				execute,
-				oo,
-				oO,
-				ox,
-				xx,
-				syncSchema,
-				transaction
-			};
-			await schemaManager.initializeSchemas(currentDb, options);
-		};
-		/**
-		* Retrieves the schema information for a table
-		*
-		* @param table - Table name
-		* @returns Promise resolving to table schema info or null if table doesn't exist
-		* @throws Error if the query fails
-		*/
-		const getTableSchema = async (table) => {
-			validateTableName(table);
-			try {
-				if (!await tableExists(table)) return null;
-				const columnRows = await many`SELECT * FROM pragma_table_info(${table})`;
-				const columns = {};
-				for (const row of columnRows) {
-					const colName = row.name;
-					columns[colName] = {
-						type: row.type,
-						primaryKey: row.pk === 1,
-						notNull: row.notnull === 1,
-						defaultValue: row.dflt_value
-					};
-				}
-				const indexRows = await many`
-        SELECT name, sql FROM sqlite_master
-        WHERE type = 'index'
-          AND tbl_name = ${table}
-          AND name NOT LIKE 'sqlite_%'
-      `;
-				const indexes = [];
-				for (const row of indexRows) {
-					const indexName = row.name;
-					const indexInfoRows = await many`SELECT * FROM pragma_index_info(${indexName})`;
-					const indexColumns = [];
-					for (const infoRow of indexInfoRows) indexColumns.push(infoRow.name);
-					const indexListRow = await single`SELECT * FROM pragma_index_list(${table}) WHERE name = ${indexName}`;
-					indexes.push({
-						name: indexName,
-						columns: indexColumns,
-						unique: indexListRow?.unique === 1
-					});
-				}
-				const fkRows = await many`SELECT * FROM pragma_foreign_key_list(${table})`;
-				const foreignKeys = [];
-				for (const fkRow of fkRows) foreignKeys.push({
-					column: fkRow.from,
-					referencesTable: fkRow.table,
-					referencesColumn: fkRow.to,
-					onDelete: fkRow.on_delete,
-					onUpdate: fkRow.on_update
-				});
-				return {
-					tableName: table,
-					columns,
-					indexes,
-					foreignKeys
-				};
-			} catch (e) {
-				throw new DatabaseError("Failed to retrieve table schema", {
-					table,
-					originalError: formatDbError(e)
-				});
-			}
-		};
-		/**
-		* ALTER TABLE operations for schema evolution
-		*/
-		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 (table, column) => {
-				validateTableName(table);
-				validateColumnName(column.name);
-				let sql;
-				try {
-					sql = generateAddColumnStatement(table, column, "sqlite");
-					await client.execute({
-						sql,
-						args: []
-					});
-				} catch (e) {
-					throw wrapDatabaseError("Failed to add column to table", e, {
-						table,
-						column: column.name,
-						...sql ? { sql } : {}
-					});
-				}
-			},
-			/**
-			* 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 (table, index) => {
-				validateTableName(table);
-				validateIndexName(index.name);
-				for (const col of index.columns) validateColumnName(col);
-				let sql;
-				try {
-					sql = generateCreateIndexStatement(table, index);
-					await client.execute({
-						sql,
-						args: []
-					});
-				} catch (e) {
-					throw wrapDatabaseError("Failed to create index on table", e, {
-						table,
-						index: index.name,
-						...sql ? { sql } : {}
-					});
-				}
-			}
-		};
-		let closed = false;
-		return {
-			url,
-			client,
-			query,
-			insert,
-			update,
-			upsert,
-			get,
-			list,
-			getOrInsert,
-			delete: deleteRecords,
-			count,
-			table,
-			tableExists,
-			many,
-			single,
-			pluck,
-			execute,
-			oo,
-			oO,
-			ox,
-			xx,
-			syncSchema,
-			initializeSchemas,
-			transaction,
-			beginTransaction,
-			getTableSchema,
-			alterTable,
-			close: async () => {
-				if (closed) return;
-				client.close();
-				closed = true;
-			}
-		};
-	})();
-}
-//#endregion
-export { getDatabase };
-
-//# sourceMappingURL=sqlite-BPI6YDpW.js.map