@happyvertical/sql 0.89.2 → 0.89.4

package/dist/index.js

@@ -1,10 +1,10 @@
-import { _ as resolveInsertColumns, a as generateAddColumnStatement, c as validateColumnName$1, d as validateTableName$1, f as DatabaseSchemaManager, g as raw, h as parseConditionKey, i as escapeStringLiteral, l as validateColumnNames, m as formatDbError, n as validateDatabaseCacheOptions, o as generateCreateIndexStatement, p as buildWhere, r as escapeQuotedIdentifier, s as quotePostgresColumnName, t as ConnectionCache, u as validateIndexName, v as unwrapRawKey, y as wrapDatabaseError } from "./chunks/connection-cache-BU3GBQxu.js";
+import { _ as raw, a as escapeStringLiteral, b as wrapDatabaseError, c as quotePostgresColumnName, d as validateIndexName, f as validateTableName$1, g as parseConditionKey, h as formatDbError, i as escapeQuotedIdentifier, l as validateColumnName$1, m as buildWhere, n as enableCachedValidation, o as generateAddColumnStatement, p as DatabaseSchemaManager, r as validateDatabaseCacheOptions, s as generateCreateIndexStatement, t as ConnectionCache, u as validateColumnNames, v as resolveInsertColumns, y as unwrapRawKey } from "./chunks/connection-cache-Da5UcY5u.js";
 import { n as throwWithDuckDBCleanup, r as convertUniqueIndexesToInlineConstraints, t as createDuckDBResourceCloser } from "./chunks/duckdb-resources-Cci6Lo6H.js";
 import { a as dropPostgresDatabase, c as postgresEnvFromUrl, i as databaseNameFromUrl, l as redactDatabaseUrl, n as assertCanImportDatabase, o as dumpPostgresDatabase, r as createPostgresDatabase, s as isLocalDatabaseUrl, t as assertCanExportDatabase, u as restorePostgresDatabase } from "./chunks/postgres-cli-DzZcXSIG.js";
 import { t as redactDatabaseUrl$1 } from "./chunks/redact-database-url-CfMDvSdy.js";
-import { n as resolveSchemas, r as createTransactionLock, t as NestedTransactionError } from "./chunks/types-uVFHgaSU.js";
+import { i as createTransactionLock, n as resolveSchemas, t as NestedTransactionError } from "./chunks/types-CwWJ-yju.js";
 import { DatabaseError, loadEnvConfig } from "@happyvertical/utils";
-import { mkdir, readdir } from "node:fs/promises";
+import { mkdir, readdir, stat } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { webcrypto } from "node:crypto";
@@ -316,6 +316,130 @@ var json_exports = /* @__PURE__ */ __exportAll({
 */
 globalThis.__haveSqlJSONConnectionCache ??= new ConnectionCache();
 var memoryConnectionCache = globalThis.__haveSqlJSONConnectionCache;
+enableCachedValidation(memoryConnectionCache);
+var JSON_SOURCE_CACHE_STATE = Symbol.for("@happyvertical/sql/json-source-cache-state/v1");
+var SOURCE_SNAPSHOT_ATTEMPTS = 3;
+function isMissingPathError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function listJSONSourceFiles(dataDir) {
+	try {
+		return (await readdir(dataDir)).filter((file) => {
+			const lower = file.toLowerCase();
+			return lower.endsWith(".json") || lower.endsWith(".schema.sql");
+		}).sort();
+	} catch (error) {
+		if (isMissingPathError(error)) return null;
+		throw error;
+	}
+}
+/**
+* Captures the JSON adapter's file-backed inputs without reading their contents.
+* Directory membership plus nanosecond timestamps, size and inode detect edits,
+* replacements, additions and removals while keeping cache hits inexpensive.
+*/
+async function getJSONSourceFingerprint(dataDir) {
+	const statFiles = (files) => Promise.all(files.map(async (file) => {
+		const info = await stat(join(dataDir, file), { bigint: true });
+		return [
+			file,
+			info.size.toString(),
+			info.mtimeNs.toString(),
+			info.ctimeNs.toString(),
+			info.ino.toString()
+		];
+	}));
+	const sameFiles = (left, right) => right !== null && left.length === right.length && left.every((file, index) => file === right[index]);
+	for (let attempt = 0; attempt < SOURCE_SNAPSHOT_ATTEMPTS; attempt += 1) {
+		const filesBefore = await listJSONSourceFiles(dataDir);
+		if (filesBefore === null) return "directory:missing";
+		try {
+			const entriesBefore = await statFiles(filesBefore);
+			if (!sameFiles(filesBefore, await listJSONSourceFiles(dataDir))) continue;
+			const entriesAfter = await statFiles(filesBefore);
+			const filesAfter = await listJSONSourceFiles(dataDir);
+			const fingerprintAfter = JSON.stringify(entriesAfter);
+			if (sameFiles(filesBefore, filesAfter) && JSON.stringify(entriesBefore) === fingerprintAfter) return fingerprintAfter;
+		} catch (error) {
+			if (!isMissingPathError(error)) throw error;
+		}
+	}
+	throw new DatabaseError("JSON source files changed while checking connection cache freshness", { dataDir });
+}
+function getJSONSourceCacheState(db) {
+	return db[JSON_SOURCE_CACHE_STATE];
+}
+function setJSONSourceCacheState(db, state) {
+	Object.defineProperty(db, JSON_SOURCE_CACHE_STATE, {
+		configurable: false,
+		enumerable: false,
+		value: state,
+		writable: false
+	});
+}
+async function waitForJSONSourceWrites(state) {
+	while (state.activeWrites.size > 0) await Promise.allSettled([...state.activeWrites]);
+}
+async function isCachedJSONDatabaseFresh(db) {
+	const state = getJSONSourceCacheState(db);
+	if (!state) return false;
+	if (!state.trackExternalChanges) return true;
+	while (true) {
+		await waitForJSONSourceWrites(state);
+		const fingerprint = await getJSONSourceFingerprint(state.dataDir);
+		if (state.activeWrites.size === 0) return fingerprint === state.fingerprint;
+	}
+}
+async function trackJSONSourceWrite(db, table, write) {
+	const state = getJSONSourceCacheState(db);
+	if (!state) return write();
+	if (state.closing) throw new DatabaseError("JSON database connection is closing");
+	const previousWrite = state.sourceWriteTail;
+	let releaseWrite;
+	const currentWrite = new Promise((resolve) => {
+		releaseWrite = resolve;
+	});
+	state.sourceWriteTail = previousWrite.then(() => currentWrite, () => currentWrite);
+	const operation = (async () => {
+		await previousWrite.catch(() => {});
+		let succeeded = false;
+		let fingerprintBeforeWrite;
+		try {
+			if (state.trackExternalChanges) {
+				fingerprintBeforeWrite = await getJSONSourceFingerprint(state.dataDir);
+				if (fingerprintBeforeWrite !== state.fingerprint) {
+					state.fingerprint = void 0;
+					throw new DatabaseError("JSON source files changed externally before the adapter could persist its write; acquire a fresh database and retry", {
+						dataDir: state.dataDir,
+						table
+					});
+				}
+			}
+			const result = await write();
+			succeeded = true;
+			return result;
+		} finally {
+			if (succeeded && state.trackExternalChanges) try {
+				const fingerprintAfterWrite = await getJSONSourceFingerprint(state.dataDir);
+				const ownedFiles = /* @__PURE__ */ new Set([`${table}.json`, `${table}.schema.sql`]);
+				const excludeOwnedFiles = (fingerprint) => JSON.stringify(JSON.parse(fingerprint).filter(([file]) => !ownedFiles.has(file)));
+				state.fingerprint = fingerprintBeforeWrite !== void 0 && excludeOwnedFiles(fingerprintBeforeWrite) === excludeOwnedFiles(fingerprintAfterWrite) ? fingerprintAfterWrite : void 0;
+			} catch (error) {
+				state.fingerprint = void 0;
+				console.warn(`[json-adapter] Could not refresh source fingerprint: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			else if (!succeeded) state.fingerprint = void 0;
+			releaseWrite();
+		}
+	})();
+	const activeWrite = operation.then(() => void 0, () => void 0);
+	state.activeWrites.add(activeWrite);
+	try {
+		return await operation;
+	} finally {
+		state.activeWrites.delete(activeWrite);
+	}
+}
 /**
 * Clears and closes all cached connections.
 * Callers must await completion before opening a replacement connection.
@@ -746,13 +870,53 @@ function validateTableName(table) {
 */
 async function getDatabase$2(options) {
 	const cacheKey = options.dbid || `json:${options.url}:${options.writeStrategy || "immediate"}:${options.autoRegister !== false}`;
-	return memoryConnectionCache.getOrCreate(cacheKey, options, () => createJSONDatabase(options), closeJSONDatabase);
+	return memoryConnectionCache.getOrCreate(cacheKey, options, () => createTrackedJSONDatabase(options), closeJSONDatabase, isCachedJSONDatabaseFresh);
+}
+async function createTrackedJSONDatabase(options) {
+	const trackExternalChanges = options.autoRegister !== false;
+	const dataDir = options.url;
+	if (!trackExternalChanges || !dataDir) {
+		const db = await createJSONDatabase(options);
+		setJSONSourceCacheState(db, {
+			activeWrites: /* @__PURE__ */ new Set(),
+			closing: false,
+			dataDir: dataDir ?? "",
+			fingerprint: void 0,
+			sourceWriteTail: Promise.resolve(),
+			trackExternalChanges: false
+		});
+		return db;
+	}
+	for (let attempt = 0; attempt < SOURCE_SNAPSHOT_ATTEMPTS; attempt += 1) {
+		const before = await getJSONSourceFingerprint(dataDir);
+		const db = await createJSONDatabase(options);
+		try {
+			const after = await getJSONSourceFingerprint(dataDir);
+			if (before === after) {
+				setJSONSourceCacheState(db, {
+					activeWrites: /* @__PURE__ */ new Set(),
+					closing: false,
+					dataDir,
+					fingerprint: after,
+					sourceWriteTail: Promise.resolve(),
+					trackExternalChanges: true
+				});
+				return db;
+			}
+		} catch (error) {
+			await closeJSONDatabase(db);
+			throw error;
+		}
+		await closeJSONDatabase(db);
+	}
+	throw new DatabaseError("JSON source files did not remain stable while creating the database", { dataDir });
 }
 async function createJSONDatabase(options) {
 	return (async () => {
 		const { instance, connection, pendingJSONFiles, inferredSchemaTables, tableLoadErrors, reportLoadError } = await createJSONConnection(options);
 		const writeStrategy = options.writeStrategy || "immediate";
 		const { url } = options;
+		let db;
 		const connectionLock = createTransactionLock("json", options.transactionQueueTimeout);
 		/**
 		* Inserts one or more records into a table
@@ -803,7 +967,7 @@ async function createJSONDatabase(options) {
 			try {
 				await connection.run(sql, values);
 				const affected = records.length;
-				if (writeStrategy === "immediate") await exportTableToJSON(connection, table, url);
+				if (writeStrategy === "immediate") await persistTableToJSON(table);
 				return {
 					operation: "insert",
 					affected
@@ -891,7 +1055,7 @@ async function createJSONDatabase(options) {
 			const values = [...dataValues, ...whereValues];
 			try {
 				await connection.run(sql, values);
-				if (writeStrategy === "immediate") await exportTableToJSON(connection, table, url);
+				if (writeStrategy === "immediate") await persistTableToJSON(table);
 				return {
 					operation: "update",
 					affected: 1
@@ -940,7 +1104,7 @@ async function createJSONDatabase(options) {
 			const sql = `UPDATE "${table}" SET ${assignments.join(", ")} ${whereClause}`;
 			try {
 				await connection.run(sql, [...values, ...whereValues]);
-				if (writeStrategy === "immediate") await exportTableToJSON(connection, table, url);
+				if (writeStrategy === "immediate") await persistTableToJSON(table);
 				return {
 					operation: "upsert",
 					affected: 1
@@ -1045,7 +1209,7 @@ async function createJSONDatabase(options) {
 			const sql = `INSERT INTO "${table}" (${quotedKeys}) VALUES (${placeholders.join(", ")}) ON CONFLICT(${conflict}) DO UPDATE SET ${quotedUpdateSetParts.join(", ")}`;
 			try {
 				await connection.run(sql, values);
-				if (writeStrategy === "immediate") await exportTableToJSON(connection, table, url);
+				if (writeStrategy === "immediate") await persistTableToJSON(table);
 				return {
 					operation: "upsert",
 					affected: 1
@@ -1108,7 +1272,7 @@ async function createJSONDatabase(options) {
 			const sql = `DELETE FROM "${table}" ${whereClause}`;
 			try {
 				await connection.run(sql, values);
-				if (writeStrategy === "immediate") await exportTableToJSON(connection, table, url);
+				if (writeStrategy === "immediate") await persistTableToJSON(table);
 				return {
 					operation: "delete",
 					affected: 1
@@ -1221,6 +1385,7 @@ async function createJSONDatabase(options) {
 			}).join(", ")} FROM "${table}") TO '${filePath}' (FORMAT JSON, ARRAY true)`;
 			await connection.run(sql);
 		};
+		const persistTableToJSON = (table) => trackJSONSourceWrite(db, table, () => exportTableToJSON(connection, table, url));
 		/**
 		* Manual export method for 'manual' write strategy
 		*
@@ -1234,7 +1399,7 @@ async function createJSONDatabase(options) {
 				table,
 				writeStrategy
 			});
-			await exportTableToJSON(connection, table, url);
+			await persistTableToJSON(table);
 		};
 		/**
 		* Returns the table-load failures collected for this connection
@@ -1413,7 +1578,7 @@ async function createJSONDatabase(options) {
 						try {
 							await access(jsonFilePath);
 						} catch {
-							await exportTableToJSON(connection, tableName, url);
+							await persistTableToJSON(tableName);
 						}
 					} catch (error) {
 						console.warn(`[json-adapter] Could not export newly created table ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
@@ -1516,7 +1681,7 @@ async function createJSONDatabase(options) {
 							try {
 								await access(jsonFilePath);
 							} catch {
-								await exportTableToJSON(connection, tableName, url);
+								await persistTableToJSON(tableName);
 							}
 						} catch (error) {
 							console.warn(`[json-adapter] Could not export newly created table ${tableName}: ${error instanceof Error ? error.message : String(error)}`);
@@ -1673,7 +1838,7 @@ async function createJSONDatabase(options) {
 			};
 		};
 		const closeResources = createDuckDBResourceCloser(connection, instance);
-		const db = {
+		db = {
 			url,
 			requiresSchemaCheck: true,
 			client: connection,
@@ -1704,6 +1869,11 @@ async function createJSONDatabase(options) {
 			inferSchemaFromJSON,
 			getTableLoadErrors,
 			close: async () => {
+				const state = getJSONSourceCacheState(db);
+				if (state) {
+					state.closing = true;
+					await waitForJSONSourceWrites(state);
+				}
 				memoryConnectionCache.forget(db);
 				await closeResources();
 			}
@@ -3375,8 +3545,8 @@ async function getDatabase(options = {}) {
 	}));
 	if (!options.type && (options.url?.startsWith("file:") || options.url === ":memory:")) options.type = "sqlite";
 	if (options.type === "postgres") return (await Promise.resolve().then(() => postgres_exports)).getDatabase(options);
-	if (options.type === "sqlite") return (await import("./chunks/sqlite-D3sUjQ5Q.js")).getDatabase(options);
-	if (options.type === "duckdb") return (await import("./chunks/duckdb-hbOqNSuA.js")).getDatabase(options);
+	if (options.type === "sqlite") return (await import("./chunks/sqlite-Cz2NMiDs.js")).getDatabase(options);
+	if (options.type === "duckdb") return (await import("./chunks/duckdb-DfikVgov.js")).getDatabase(options);
 	if (options.type === "json") return (await Promise.resolve().then(() => json_exports)).getDatabase(options);
 	throw new Error("Invalid database type");
 }