@happyvertical/sql 0.82.0 → 0.84.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as validateColumnName$1, c as validateTableName$1, d as formatDbError, f as parseConditionKey, h as unwrapRawKey, i as generateCreateIndexStatement, l as DatabaseSchemaManager, m as resolveInsertColumns, n as escapeStringLiteral, o as validateColumnNames, p as raw, r as generateAddColumnStatement, s as validateIndexName, t as escapeQuotedIdentifier, u as buildWhere } from "./chunks/alter-utils-F8JQn1LL.js";
+import { a as validateColumnName$1, c as validateTableName$1, d as formatDbError, f as parseConditionKey, h as unwrapRawKey, i as generateCreateIndexStatement, l as DatabaseSchemaManager, m as resolveInsertColumns, n as escapeStringLiteral, o as validateColumnNames, p as raw, r as generateAddColumnStatement, s as validateIndexName, t as escapeQuotedIdentifier, u as buildWhere } from "./chunks/alter-utils-DeDDAATm.js";
 import { t as convertUniqueIndexesToInlineConstraints } from "./chunks/duckdb-schema-utils-B-XBP8QF.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 { n as resolveSchemas, r as createTransactionLock, t as NestedTransactionError } from "./chunks/types-uVFHgaSU.js";
@@ -30,7 +30,7 @@ var VALID_BUCKET_UNITS = /* @__PURE__ */ new Set([
 	"year"
 ]);
 function validateSqlIdentifier(identifier) {
-	if (!/^[a-zA-Z0-9_.]+$/.test(identifier)) throw new Error(`Invalid SQL identifier: ${identifier}`);
+	if (typeof identifier !== "string" || !/^[a-zA-Z0-9_.]+$/.test(identifier)) throw new Error(`Invalid SQL identifier: ${identifier}`);
 	return identifier;
 }
 function normalizeAdapter(adapterType) {
@@ -347,6 +347,15 @@ async function createJSONConnection(options) {
 	if (!url) throw new DatabaseError("url is required for JSON adapter", { options });
 	const pendingJSONFiles = /* @__PURE__ */ new Map();
 	const inferredSchemaTables = /* @__PURE__ */ new Set();
+	const tableLoadErrors = [];
+	const reportLoadError = (info) => {
+		tableLoadErrors.push(info);
+		try {
+			options.onTableLoadError?.(info);
+		} catch (callbackError) {
+			console.error("[json-adapter] onTableLoadError callback threw:", callbackError);
+		}
+	};
 	try {
 		const { DuckDBInstance } = await import(
 			/* @vite-ignore */
@@ -356,11 +365,13 @@ async function createJSONConnection(options) {
 		try {
 			await mkdir(url, { recursive: true });
 		} catch (_error) {}
-		if (autoRegister) await loadJSONTables(connection, url, schemas, pendingJSONFiles, eagerLoadTables, inferredSchemaTables);
+		if (autoRegister) await loadJSONTables(connection, url, schemas, pendingJSONFiles, eagerLoadTables, inferredSchemaTables, reportLoadError);
 		return {
 			connection,
 			pendingJSONFiles,
-			inferredSchemaTables
+			inferredSchemaTables,
+			tableLoadErrors,
+			reportLoadError
 		};
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : String(error);
@@ -389,8 +400,9 @@ async function createJSONConnection(options) {
 * @param connection - DuckDB connection
 * @param tableName - Name of the table to load data into
 * @param filePath - Path to the JSON file
+* @param reportLoadError - Sink invoked when parsed records fail to insert (issue #1139)
 */
-async function loadJSONData(connection, tableName, filePath) {
+async function loadJSONData(connection, tableName, filePath, reportLoadError) {
 	let records;
 	try {
 		const { readFile } = await import("node:fs/promises");
@@ -406,6 +418,11 @@ async function loadJSONData(connection, tableName, filePath) {
 		if (inserted > 0) console.log(`[json-adapter] Loaded ${inserted} records into ${tableName} from JSON`);
 	} catch (error) {
 		console.error(`[json-adapter] Failed to load data for ${tableName}; the table will be empty:`, error);
+		reportLoadError?.({
+			table: tableName,
+			filePath,
+			error
+		});
 	}
 }
 /**
@@ -432,8 +449,9 @@ async function loadJSONData(connection, tableName, filePath) {
 * @param pendingJSONFiles - Map to store JSON files pending deferred loading
 * @param eagerLoadTables - Whether to eagerly create tables with inferred schemas
 * @param inferredSchemaTables - Set to track tables created with inferred schemas
+* @param reportLoadError - Sink for per-table data-load failures (issue #1139)
 */
-async function loadJSONTables(connection, dataDir, providedSchemas = {}, pendingJSONFiles = /* @__PURE__ */ new Map(), eagerLoadTables = true, inferredSchemaTables = /* @__PURE__ */ new Set()) {
+async function loadJSONTables(connection, dataDir, providedSchemas = {}, pendingJSONFiles = /* @__PURE__ */ new Map(), eagerLoadTables = true, inferredSchemaTables = /* @__PURE__ */ new Set(), reportLoadError) {
 	try {
 		const jsonFiles = (await readdir(dataDir)).filter((file) => extname(file).toLowerCase() === ".json");
 		for (const file of jsonFiles) {
@@ -443,7 +461,7 @@ async function loadJSONTables(connection, dataDir, providedSchemas = {}, pending
 			if (schema) {
 				console.log(`[json-adapter] Creating ${tableName} with provided schema definition`);
 				await createTableFromSchema(connection, tableName, schema);
-				await loadJSONData(connection, tableName, filePath);
+				await loadJSONData(connection, tableName, filePath, reportLoadError);
 			} else {
 				const schemaPath = join(dataDir, `${tableName}.schema.sql`);
 				const { readFile, access } = await import("node:fs/promises");
@@ -458,7 +476,7 @@ async function loadJSONTables(connection, dataDir, providedSchemas = {}, pending
 				if (schemaExists) try {
 					const schemaDDL = await readFile(schemaPath, "utf-8");
 					await connection.run(schemaDDL);
-					await loadJSONData(connection, tableName, filePath);
+					await loadJSONData(connection, tableName, filePath, reportLoadError);
 				} catch (error) {
 					console.warn(`[json-adapter] Could not load ${tableName} with schema file: ${error instanceof Error ? error.message : String(error)}`);
 				}
@@ -715,7 +733,7 @@ async function insertRecordsWithCast(connection, tableName, records) {
 * @throws DatabaseError if table name is invalid
 */
 function validateTableName(table) {
-	if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) throw new DatabaseError(`Invalid table name: ${table}`, { table });
+	if (typeof table !== "string" || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) throw new DatabaseError(`Invalid table name: ${table}`, { table });
 }
 /**
 * Creates a JSON database adapter using DuckDB in-memory engine
@@ -738,7 +756,7 @@ async function getDatabase$2(options) {
 	const pending = pendingConnections$1.get(cacheKey);
 	if (pending) return pending;
 	const connectionPromise = (async () => {
-		const { connection, pendingJSONFiles, inferredSchemaTables } = await createJSONConnection(options);
+		const { connection, pendingJSONFiles, inferredSchemaTables, tableLoadErrors, reportLoadError } = await createJSONConnection(options);
 		const writeStrategy = options.writeStrategy || "immediate";
 		const { url } = options;
 		const connectionLock = createTransactionLock("json", options.transactionQueueTimeout);
@@ -871,7 +889,10 @@ async function getDatabase$2(options) {
 			validateColumnNames(keys);
 			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 dataValues = keys.map((key) => {
+				const value = data[key];
+				return value instanceof Date ? value.toISOString() : value;
+			});
 			const sql = `UPDATE "${table}" SET ${setClause} ${whereClause}`;
 			const values = [...dataValues, ...whereValues];
 			try {
@@ -955,17 +976,19 @@ async function getDatabase$2(options) {
 				table,
 				writeStrategy
 			});
-			const missingColumns = conflictColumns.filter((col) => !(col in data));
+			const record = { ...data };
+			const conflictCols = conflictColumns.map((col) => String(col));
+			const missingColumns = conflictCols.filter((col) => !(col in record));
 			if (missingColumns.length > 0) throw new DatabaseError("Conflict columns missing from data", {
 				table,
-				conflictColumns,
+				conflictColumns: conflictCols,
 				missingColumns,
-				availableColumns: Object.keys(data),
+				availableColumns: Object.keys(record),
 				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 (!options?.nullsDistinct && conflictColumns.some((col) => data[col] === null)) return executeNullAwareJSONUpsert(table, conflictColumns, data);
-			const keys = Object.keys(data);
-			const dataValues = Object.values(data);
+			if (!options?.nullsDistinct && conflictCols.some((col) => record[col] === null)) return executeNullAwareJSONUpsert(table, conflictCols, record);
+			const keys = Object.keys(record);
+			const dataValues = Object.values(record);
 			const placeholders = [];
 			const values = [];
 			let paramIdx = 1;
@@ -1018,7 +1041,7 @@ async function getDatabase$2(options) {
 					paramIdx++;
 				}
 			}
-			const conflict = conflictColumns.map((col) => `"${escapeQuotedIdentifier(col)}"`).join(", ");
+			const conflict = conflictCols.map((col) => `"${escapeQuotedIdentifier(col)}"`).join(", ");
 			const quotedKeys = keys.map((key) => `"${escapeQuotedIdentifier(key)}"`).join(", ");
 			const quotedUpdateSetParts = keys.map((key, i) => {
 				const part = updateSetParts[i];
@@ -1039,14 +1062,14 @@ async function getDatabase$2(options) {
 					sql,
 					values,
 					valueTypes: values.map((v) => `${typeof v} (${v})`),
-					conflictColumns,
+					conflictColumns: conflictCols,
 					error: formatDbError(e)
 				});
 				throw new DatabaseError("Failed to upsert record into table", {
 					table,
 					sql,
 					values,
-					conflictColumns,
+					conflictColumns: conflictCols,
 					originalError: formatDbError(e)
 				});
 			}
@@ -1220,6 +1243,32 @@ async function getDatabase$2(options) {
 			await exportTableToJSON(connection, table, url);
 		};
 		/**
+		* Returns the table-load failures collected for this connection
+		*
+		* A JSON data file that parses but whose records cannot be inserted into a
+		* table created for it (a renamed/dropped column, a NOT NULL / PRIMARY KEY
+		* violation, or a file whose fields match no column) leaves that table
+		* present-but-empty and is logged to stderr; calling code otherwise cannot
+		* tell it apart from a legitimately empty one. This exposes those failures
+		* so a caller can detect and react to them (issue #1139).
+		*
+		* Scope: this covers loads into a table created from a provided schema, a
+		* `.schema.sql` file, or deferred `syncSchema()` / `execute()` DDL. A file
+		* with no schema at all is loaded by DuckDB's own inference; if that fails
+		* the table is simply not created, which already surfaces as an error when
+		* you query it, so it is not reported here.
+		*
+		* The list accumulates across the connection's lifetime — covering both
+		* connection-time and later deferred loads — and is append-only (a later
+		* successful reload of the same table does not remove an earlier failure).
+		* A fresh array is returned each call, so mutating it does not affect the
+		* adapter's state. Because connections are cached per URL, callers sharing a
+		* URL share this list.
+		*
+		* @returns Table-load failures, oldest first
+		*/
+		const getTableLoadErrors = () => [...tableLoadErrors];
+		/**
 		* Creates a table by inferring schema from a JSON file
 		*
 		* This utility is for users who want automatic schema inference from JSON.
@@ -1362,7 +1411,7 @@ async function getDatabase$2(options) {
 					const tableName = createTableMatch[1];
 					const pendingFile = pendingJSONFiles.get(tableName);
 					if (pendingFile) {
-						await loadJSONData(connection, tableName, pendingFile);
+						await loadJSONData(connection, tableName, pendingFile, reportLoadError);
 						pendingJSONFiles.delete(tableName);
 					} else if (writeStrategy !== "none") try {
 						const { access } = await import("node:fs/promises");
@@ -1466,7 +1515,7 @@ async function getDatabase$2(options) {
 					if (tableName) {
 						const pendingFile = pendingJSONFiles.get(tableName);
 						if (pendingFile) {
-							await loadJSONData(connection, tableName, pendingFile);
+							await loadJSONData(connection, tableName, pendingFile, reportLoadError);
 							pendingJSONFiles.delete(tableName);
 						} else if (writeStrategy !== "none") try {
 							const { access } = await import("node:fs/promises");
@@ -1658,7 +1707,8 @@ async function getDatabase$2(options) {
 			transaction,
 			beginTransaction,
 			exportTable,
-			inferSchemaFromJSON
+			inferSchemaFromJSON,
+			getTableLoadErrors
 		};
 	})();
 	pendingConnections$1.set(cacheKey, connectionPromise);
@@ -2287,8 +2337,7 @@ async function createDatabase(options, cacheKey) {
 			throw error;
 		}
 	};
-	const executePostgresUpsert = async (executor, table, conflictColumns, data, options, acquireTransaction) => {
-		const serializedData = serializeRecord(data);
+	const executePostgresUpsert = async (executor, table, conflictColumns, serializedData, options, acquireTransaction) => {
 		validateUpsertConflictColumns(table, conflictColumns, serializedData);
 		if (options?.nullsDistinct || !hasNullConflictValue(conflictColumns, serializedData)) return executeStandardPostgresUpsert(executor, table, conflictColumns, serializedData);
 		if (await hasNativeNullsNotDistinctIndex(table, conflictColumns)) return executeStandardPostgresUpsert(executor, table, conflictColumns, serializedData);
@@ -2505,9 +2554,11 @@ async function createDatabase(options, cacheKey) {
 		*/
 		const upsert = async (table, conflictColumns, data, options) => {
 			validateTableName$1(table);
-			validateColumnNames([...conflictColumns, ...Object.keys(data)]);
+			const serializedData = serializeRecord(data);
+			const conflictCols = [...conflictColumns];
+			validateColumnNames([...conflictCols, ...Object.keys(serializedData)]);
 			try {
-				return await executePostgresUpsert(executor, table, conflictColumns, data, options, !inTransaction);
+				return await executePostgresUpsert(executor, table, conflictCols, serializedData, options, !inTransaction);
 			} catch (e) {
 				if (e instanceof DatabaseError && e.message === "Conflict columns missing from data") throw e;
 				throw new DatabaseError("Failed to upsert record into table", {
@@ -3281,8 +3332,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-BoP0WIlT.js")).getDatabase(options);
-	if (options.type === "duckdb") return (await import("./chunks/duckdb-SVvTBGT0.js")).getDatabase(options);
+	if (options.type === "sqlite") return (await import("./chunks/sqlite-Crx5PQ3G.js")).getDatabase(options);
+	if (options.type === "duckdb") return (await import("./chunks/duckdb-jSSa2MbC.js")).getDatabase(options);
 	if (options.type === "json") return (await Promise.resolve().then(() => json_exports)).getDatabase(options);
 	throw new Error("Invalid database type");
 }
@@ -3332,7 +3383,7 @@ function escapeSqlValue(value) {
 * @throws Error if the column name contains invalid characters
 */
 function validateColumnName(column) {
-	if (!/^[a-zA-Z0-9_.]+$/.test(column)) throw new Error(`Invalid column name: ${column}`);
+	if (typeof column !== "string" || !/^[a-zA-Z0-9_.]+$/.test(column)) throw new Error(`Invalid column name: ${column}`);
 	return column;
 }
 var src_default = {