@happyvertical/sql 0.79.0 → 0.80.1

package/dist/chunks/sqlite-YgU9LCVy.js

@@ -0,0 +1,1045 @@
+import { n as buildWhere, r as formatDbError, t as DatabaseSchemaManager } from "./schema-manager-a8RlxIE2.js";
+import { a as validateTableName, i as validateIndexName, n as generateCreateIndexStatement, r as validateColumnName, t as generateAddColumnStatement } from "./alter-utils-K7tiuj5L.js";
+import { resolveSchemas } from "../index.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 memoryConnectionCache = /* @__PURE__ */ new Map();
+/**
+* Pending connection promises to handle concurrent getDatabase() calls
+* Prevents creating duplicate connections when parallel calls happen
+*/
+var pendingConnections = /* @__PURE__ */ new Map();
+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;
+	if (url !== ":memory:" && !url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("libsql://") && !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 = error instanceof Error ? error.message : String(error);
+		if (errorMessage?.includes("URL_SCHEME_NOT_SUPPORTED")) throw new DatabaseError(`Unsupported URL scheme. Use ':memory:' for in-memory databases or 'libsql://' for remote LibSQL databases. Original: ${url}, Converted: ${libsqlUrl}`, {
+			url: libsqlUrl,
+			originalError: errorMessage
+		});
+		throw new DatabaseError(`Failed to create LibSQL client: ${errorMessage}`, {
+			url: libsqlUrl,
+			originalError: errorMessage
+		});
+	}
+}
+function hasNativeSqliteCapabilities(options) {
+	return Boolean(options.capabilities?.notifications || options.capabilities?.vector);
+}
+/**
+* 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 = {}) {
+	const url = options.url || ":memory:";
+	if (url === ":memory:" && !options.dbid) options.dbid = generateDbId();
+	if (hasNativeSqliteCapabilities(options)) return (await import("./sqlite-native-BGtpx7Ro.js")).getNativeSqliteDatabase(options);
+	if (options.dbid) {
+		const cached = memoryConnectionCache.get(options.dbid);
+		if (cached) return cached;
+		const pending = pendingConnections.get(options.dbid);
+		if (pending) return pending;
+	}
+	const connectionPromise = (async () => {
+		const client = await createLibSQLClient(options);
+		const resolvedSchemas = resolveSchemas(options.schemas);
+		if (resolvedSchemas && Object.keys(resolvedSchemas).length > 0) await createTablesFromSchemas(client, resolvedSchemas);
+		/**
+		* 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) => {
+			const conflictValues = conflictColumns.map((col) => `${col}:${JSON.stringify(data[col])}`).join("|");
+			return `${url}:${table}:${conflictValues}`;
+		};
+		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;
+				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();
+				}
+				if (lastError && attempt < NULL_AWARE_UPSERT_MAX_ATTEMPTS - 1 && isRetriableSqliteTransactionError(lastError)) {
+					await delay(NULL_AWARE_UPSERT_BASE_DELAY_MS * 2 ** attempt);
+					continue;
+				}
+				break;
+			}
+			throw lastError;
+		};
+		const executeUpsert = async (table, conflictColumns, data, options, acquireTransaction) => {
+			const serializedData = serializeRecord(data);
+			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) => {
+			let sql;
+			let values;
+			if (Array.isArray(data)) {
+				const serializedRecords = data.map((record) => serializeRecord(record));
+				const keys = Object.keys(serializedRecords[0]);
+				const placeholders = serializedRecords.map(() => `(${keys.map(() => "?").join(", ")})`).join(", ");
+				sql = `INSERT INTO ${table} (${keys.join(", ")}) VALUES ${placeholders}`;
+				const flattenedValues = [];
+				for (const record of serializedRecords) flattenedValues.push(...Object.values(record));
+				values = flattenedValues;
+			} else {
+				const serializedData = serializeRecord(data);
+				const keys = Object.keys(serializedData);
+				const placeholders = keys.map(() => "?").join(", ");
+				sql = `INSERT INTO ${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) => {
+			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) => {
+			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) => {
+			const serializedData = serializeRecord(data);
+			const keys = Object.keys(serializedData);
+			const values = Object.values(serializedData);
+			const setClause = keys.map((key, i) => `${key} = $${i + 1}`).join(", ");
+			const { sql: whereClause, values: whereValues } = buildWhere(where, values.length + 1, "sqlite");
+			if (!whereClause) throw new DatabaseError("UPDATE requires at least one WHERE condition to prevent accidental update of all records", { table });
+			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) => {
+			try {
+				return await executeUpsert(table, conflictColumns, data, 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)
+				});
+			}
+		};
+		const upsertInCurrentTransaction = async (table, conflictColumns, data, options) => {
+			try {
+				return await executeUpsert(table, conflictColumns, data, 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 pluck`SELECT COUNT(*) FROM ${table}`;
+					return Number(result) || 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) => {
+			try {
+				await client.execute({
+					sql: "BEGIN TRANSACTION",
+					args: []
+				});
+				const result = await callback({
+					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
+				});
+				await client.execute({
+					sql: "COMMIT",
+					args: []
+				});
+				return result;
+			} catch (error) {
+				await client.execute({
+					sql: "ROLLBACK",
+					args: []
+				});
+				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 () => {
+			await client.execute({
+				sql: "BEGIN TRANSACTION",
+				args: []
+			});
+			let active = true;
+			const commit = async () => {
+				if (!active) throw new DatabaseError("Transaction already ended", {});
+				await client.execute({
+					sql: "COMMIT",
+					args: []
+				});
+				active = false;
+			};
+			const rollback = async () => {
+				if (!active) throw new DatabaseError("Transaction already ended", {});
+				await client.execute({
+					sql: "ROLLBACK",
+					args: []
+				});
+				active = false;
+			};
+			const isActive = () => active;
+			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,
+				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 new DatabaseError("Failed to execute raw query", {
+					sql,
+					args,
+					originalError: formatDbError(e)
+				});
+			}
+		};
+		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)
+				});
+			}
+		};
+		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: {
+				/**
+				* 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);
+					try {
+						const sql = generateAddColumnStatement(table, column, "sqlite");
+						await client.execute({
+							sql,
+							args: []
+						});
+					} catch (e) {
+						throw new DatabaseError("Failed to add column to table", {
+							table,
+							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 (table, index) => {
+					validateTableName(table);
+					validateIndexName(index.name);
+					for (const col of index.columns) validateColumnName(col);
+					try {
+						const sql = generateCreateIndexStatement(table, index);
+						await client.execute({
+							sql,
+							args: []
+						});
+					} catch (e) {
+						throw new DatabaseError("Failed to create index on table", {
+							table,
+							index: index.name,
+							originalError: formatDbError(e)
+						});
+					}
+				}
+			}
+		};
+	})();
+	if (options.dbid) pendingConnections.set(options.dbid, connectionPromise);
+	try {
+		const db = await connectionPromise;
+		if (options.dbid) memoryConnectionCache.set(options.dbid, db);
+		return db;
+	} finally {
+		if (options.dbid) pendingConnections.delete(options.dbid);
+	}
+}
+//#endregion
+export { getDatabase };
+
+//# sourceMappingURL=sqlite-YgU9LCVy.js.map