@toiroakr/lines-db 0.8.0 → 0.9.1

package/dist/index.js

@@ -2,6 +2,7 @@ import { createRequire } from "node:module";
 import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, normalize, relative } from "node:path";
 import { pathToFileURL } from "node:url";
+import { styleText } from "node:util";
 
 //#region rolldown:runtime
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -385,13 +386,20 @@ var LinesDB = class LinesDB {
 		const loadedTables = /* @__PURE__ */ new Set();
 		const loadingTables = /* @__PURE__ */ new Set();
 		const attemptedTables = /* @__PURE__ */ new Set();
+		const allDeferredForeignKeys = [];
 		for (const tableNameToLoad of tablesToLoad) if (!attemptedTables.has(tableNameToLoad)) {
 			const tableTransform = tableNameToLoad === tableName ? transform : void 0;
-			const { errors, warnings, rowCounts: tableRowCounts } = await this.loadTableWithDependencies(tableNameToLoad, loadedTables, loadingTables, attemptedTables, detailedValidate, tableTransform);
+			const { errors, warnings, rowCounts: tableRowCounts, deferredForeignKeys } = await this.loadTableWithDependencies(tableNameToLoad, loadedTables, loadingTables, attemptedTables, detailedValidate, tableTransform);
 			allErrors.push(...errors);
 			allWarnings.push(...warnings);
+			allDeferredForeignKeys.push(...deferredForeignKeys);
 			for (const [k, v] of tableRowCounts) allRowCounts.set(k, v);
 		}
+		if (detailedValidate && allDeferredForeignKeys.length > 0) for (const { tableName: tName, foreignKey: fk, filePath } of allDeferredForeignKeys) {
+			if (!loadedTables.has(fk.references.table)) continue;
+			const deferredErrors = this.validateDeferredForeignKey(tName, fk, filePath);
+			allErrors.push(...deferredErrors);
+		}
 		const tableResults = tablesToLoad.map((name) => {
 			const tableErrors = allErrors.filter((e) => e.tableName === name);
 			const tableWarnings = allWarnings.filter((w) => w.includes(`'${name}'`));
@@ -417,10 +425,12 @@ var LinesDB = class LinesDB {
 		const errors = [];
 		const warnings = [];
 		const rowCounts = /* @__PURE__ */ new Map();
+		const deferredForeignKeys = [];
 		if (attemptedTables.has(tableName)) return {
 			errors,
 			warnings,
-			rowCounts
+			rowCounts,
+			deferredForeignKeys
 		};
 		attemptedTables.add(tableName);
 		if (loadingTables.has(tableName)) throw new Error(`Circular dependency detected for table '${tableName}'`);
@@ -444,23 +454,35 @@ var LinesDB = class LinesDB {
 					const depResult = await this.loadTableWithDependencies(referencedTable, loadedTables, loadingTables, attemptedTables, detailedValidate, void 0);
 					errors.push(...depResult.errors);
 					warnings.push(...depResult.warnings);
+					deferredForeignKeys.push(...depResult.deferredForeignKeys);
 					for (const [k, v] of depResult.rowCounts) rowCounts.set(k, v);
 				} else throw new Error(`Foreign key reference to non-existent table '${referencedTable}' in table '${tableName}'`);
 			}
 			const failedDependencies = /* @__PURE__ */ new Set();
+			const circularDependencies = /* @__PURE__ */ new Set();
 			if (foreignKeys && foreignKeys.length > 0) {
 				for (const fk of foreignKeys) {
 					const referencedTable = fk.references.table;
 					if (referencedTable === tableName) continue;
-					if (attemptedTables.has(referencedTable) && !loadedTables.has(referencedTable)) failedDependencies.add(referencedTable);
+					if (attemptedTables.has(referencedTable) && !loadedTables.has(referencedTable)) if (loadingTables.has(referencedTable)) circularDependencies.add(referencedTable);
+					else failedDependencies.add(referencedTable);
 				}
 				if (failedDependencies.size > 0) for (const dep of failedDependencies) warnings.push(`Skipping foreign key validation for table '${tableName}': referenced table '${dep}' has validation errors`);
 			}
-			const { loaded, rowCount, errors: loadErrors } = await this.loadTable(tableName, tableConfig, detailedValidate, transform, failedDependencies);
+			const allSkippedDependencies = new Set([...failedDependencies, ...circularDependencies]);
+			const { loaded, rowCount, errors: loadErrors } = await this.loadTable(tableName, tableConfig, detailedValidate, transform, allSkippedDependencies);
 			errors.push(...loadErrors);
 			rowCounts.set(tableName, rowCount);
-			if (loaded) loadedTables.add(tableName);
-			else {
+			if (loaded) {
+				loadedTables.add(tableName);
+				if (foreignKeys && circularDependencies.size > 0) {
+					for (const fk of foreignKeys) if (circularDependencies.has(fk.references.table)) deferredForeignKeys.push({
+						tableName,
+						foreignKey: fk,
+						filePath: tableConfig.jsonlPath
+					});
+				}
+			} else {
 				warnings.push(`Table '${tableName}' was not loaded (no data or skipped)`);
 				this.tables.delete(tableName);
 			}
@@ -470,7 +492,8 @@ var LinesDB = class LinesDB {
 		return {
 			errors,
 			warnings,
-			rowCounts
+			rowCounts,
+			deferredForeignKeys
 		};
 	}
 	/**
@@ -716,6 +739,34 @@ var LinesDB = class LinesDB {
 		};
 	}
 	/**
+	* Validate a deferred foreign key constraint after all tables have been loaded.
+	* Used for circular dependency FK validation.
+	*/
+	validateDeferredForeignKey(tableName, fk, filePath) {
+		const errors = [];
+		const quotedTable = this.quoteTableName(tableName);
+		const quotedColumn = this.quoteIdentifier(fk.column);
+		const quotedRefTable = this.quoteTableName(fk.references.table);
+		const sql = `SELECT rowid - 1 as idx, ${quotedColumn} as val FROM ${quotedTable} WHERE ${quotedColumn} IS NOT NULL AND ${quotedColumn} NOT IN (SELECT ${this.quoteIdentifier(fk.references.column)} FROM ${quotedRefTable})`;
+		try {
+			const rows = this.query(sql);
+			for (const row of rows) errors.push({
+				file: filePath,
+				tableName,
+				rowIndex: row.idx,
+				issues: [],
+				type: "foreignKey",
+				foreignKeyError: {
+					column: fk.column,
+					value: row.val,
+					referencedTable: fk.references.table,
+					referencedColumn: fk.references.column
+				}
+			});
+		} catch (_) {}
+		return errors;
+	}
+	/**
 	* Execute a raw SQL query
 	*/
 	query(sql, params = []) {
@@ -1304,5 +1355,108 @@ async function ensureTableRowsValid(options) {
 }
 
 //#endregion
-export { DirectoryScanner, JsonlReader, JsonlWriter, LinesDB, RUNTIME, SCHEMA_EXTENSIONS, SchemaLoader, TypeGenerator, defineSchema, detectRuntime, ensureTableRowsValid, extractTableNameFromSchemaFile, findSchemaFile, hasBackward, isSchemaFile, rewriteExtensionForImport };
+//#region src/error-formatter.ts
+var ErrorFormatter = class {
+	verbose;
+	constructor(options = {}) {
+		this.verbose = options.verbose ?? false;
+	}
+	/**
+	* Format validation errors
+	*/
+	formatValidationErrors(errors) {
+		if (this.verbose) return this.formatValidationErrorsVerbose(errors);
+		return this.formatValidationErrorsCompact(errors);
+	}
+	/**
+	* Format foreign key error
+	*/
+	formatForeignKeyError(error) {
+		if (this.verbose) return this.formatForeignKeyErrorVerbose(error);
+		return this.formatForeignKeyErrorCompact(error);
+	}
+	/**
+	* Format compact (default) validation errors
+	*/
+	formatValidationErrorsCompact(errors) {
+		const lines = [];
+		for (const error of errors) for (const issue of error.issues) {
+			const fieldPath = this.getFieldPath(issue);
+			const line = `${error.file}:${error.rowIndex + 1} • ${fieldPath}: ${issue.message}`;
+			lines.push(line);
+		}
+		return lines.join("\n");
+	}
+	/**
+	* Format verbose validation errors
+	*/
+	formatValidationErrorsVerbose(errors) {
+		const blocks = [];
+		for (let i = 0; i < errors.length; i++) {
+			const error = errors[i];
+			const isLast = i === errors.length - 1;
+			const prefix = isLast ? "└─" : "├─";
+			const linePrefix = isLast ? "   " : "│  ";
+			const lines = [`${prefix} ${error.file}:${error.rowIndex + 1}`];
+			for (const issue of error.issues) {
+				const fieldPath = this.getFieldPath(issue);
+				lines.push(`${linePrefix}Field: ${fieldPath}`);
+				lines.push(`${linePrefix}Error: ${issue.message}`);
+			}
+			if (error.originalData !== void 0) lines.push(`${linePrefix}Original data: ${JSON.stringify(error.originalData)}`);
+			if (error.data !== void 0) {
+				const label = error.originalData !== void 0 ? "Transformed data" : "Data";
+				lines.push(`${linePrefix}${label}: ${JSON.stringify(error.data)}`);
+			}
+			blocks.push(lines.join("\n"));
+		}
+		return blocks.join("\n│\n");
+	}
+	/**
+	* Format compact foreign key error
+	*/
+	formatForeignKeyErrorCompact(error) {
+		return `${error.file}:${error.rowIndex + 1} • ${error.column}: Foreign key constraint failed - Referenced value ${JSON.stringify(error.value)} does not exist in ${error.referencedTable}(${error.referencedColumn})`;
+	}
+	/**
+	* Format verbose foreign key error
+	*/
+	formatForeignKeyErrorVerbose(error) {
+		const lines = [
+			`└─ ${error.file}:${error.rowIndex + 1}`,
+			`   Type: Foreign Key Violation`,
+			`   Field: ${error.column}`,
+			`   Value: ${JSON.stringify(error.value)}`,
+			`   References: ${error.referencedTable}(${error.referencedColumn})`,
+			`   Error: Referenced value does not exist in target table`
+		];
+		if (error.data !== void 0) lines.push(`   Data: ${JSON.stringify(error.data)}`);
+		return lines.join("\n");
+	}
+	/**
+	* Get field path from issue
+	*/
+	getFieldPath(issue) {
+		if (!issue.path || issue.path.length === 0) return "root";
+		return issue.path.map((segment) => {
+			if (typeof segment === "object" && segment !== null && "key" in segment) return String(segment.key);
+			return String(segment);
+		}).join(".");
+	}
+	/**
+	* Format error header with count
+	*/
+	formatErrorHeader(count, file) {
+		return styleText("red", `✗ Found ${count} error(s)${file ? ` in ${file}` : ""}`);
+	}
+	/**
+	* Format migration failure header
+	*/
+	formatMigrationFailureHeader() {
+		return styleText("red", "\n✗ Migration failed and was rolled back");
+	}
+};
+
+//#endregion
+export { DirectoryScanner, ErrorFormatter, JsonlReader, JsonlWriter, LinesDB, RUNTIME, SCHEMA_EXTENSIONS, SchemaLoader, TypeGenerator, defineSchema, detectRuntime, ensureTableRowsValid, extractTableNameFromSchemaFile, findSchemaFile, hasBackward, isSchemaFile, rewriteExtensionForImport };
 //# sourceMappingURL=index.js.map