@toiroakr/lines-db 0.1.0

package/dist/index.js

@@ -0,0 +1,1181 @@
+import { createRequire } from "node:module";
+import { access, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, normalize, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/runtime.ts
+function detectRuntime() {
+	if (typeof globalThis !== "undefined" && "Bun" in globalThis && typeof globalThis.Bun !== "undefined") return "bun";
+	if (typeof globalThis !== "undefined" && "Deno" in globalThis && typeof globalThis.Deno !== "undefined") return "deno";
+	if (typeof process !== "undefined" && process.versions && process.versions.node) return "node";
+	return "unknown";
+}
+const RUNTIME = detectRuntime();
+
+//#endregion
+//#region src/sqlite-adapter.ts
+/**
+* Create a SQLite database instance based on the runtime environment
+*/
+function createDatabase(path = ":memory:") {
+	if (RUNTIME === "bun") return createBunDatabase(path);
+	else if (RUNTIME === "node" || RUNTIME === "deno") return createNodeDatabase(path);
+	else throw new Error(`Unsupported runtime: ${RUNTIME}`);
+}
+/**
+* Create a Bun SQLite database
+*/
+function createBunDatabase(path) {
+	const { Database } = __require("bun:sqlite");
+	const db = new Database(path);
+	return {
+		prepare(sql) {
+			const stmt = db.prepare(sql);
+			return {
+				run(...params) {
+					return stmt.run(...params);
+				},
+				get(...params) {
+					return stmt.get(...params);
+				},
+				all(...params) {
+					return stmt.all(...params);
+				}
+			};
+		},
+		exec(sql) {
+			db.exec(sql);
+		},
+		close() {
+			db.close();
+		}
+	};
+}
+/**
+* Create a Node.js SQLite database
+*/
+function createNodeDatabase(path) {
+	const { DatabaseSync } = __require("node:sqlite");
+	const db = new DatabaseSync(path);
+	return {
+		prepare(sql) {
+			const stmt = db.prepare(sql);
+			return {
+				run(...params) {
+					return stmt.run(...params);
+				},
+				get(...params) {
+					return stmt.get(...params);
+				},
+				all(...params) {
+					return stmt.all(...params);
+				}
+			};
+		},
+		exec(sql) {
+			db.exec(sql);
+		},
+		close() {
+			db.close();
+		}
+	};
+}
+
+//#endregion
+//#region src/jsonl-reader.ts
+var JsonlReader = class {
+	static overrides = null;
+	/**
+	* Temporarily override the data returned for specific JSONL files.
+	* Useful for scenarios like migration validation where in-memory data should be used.
+	*/
+	static async withOverrides(overrides, fn) {
+		const normalized = /* @__PURE__ */ new Map();
+		for (const [filePath, rows] of overrides) normalized.set(normalize(filePath), rows);
+		const previousOverrides = this.overrides;
+		this.overrides = normalized;
+		try {
+			return await fn();
+		} finally {
+			this.overrides = previousOverrides;
+		}
+	}
+	/**
+	* Read JSONL file and parse each line as JSON
+	*/
+	static async read(filePath) {
+		const overrideRows = this.overrides?.get(normalize(filePath));
+		if (overrideRows) return overrideRows.map((row) => JSON.parse(JSON.stringify(row)));
+		return (await readFile(filePath, "utf-8")).trim().split("\n").filter((line) => line.trim().length > 0).map((line) => {
+			try {
+				return JSON.parse(line);
+			} catch (error) {
+				throw new Error(`Failed to parse JSON line: ${line}`, { cause: error });
+			}
+		});
+	}
+	/**
+	* Infer schema from JSONL data
+	*/
+	static inferSchema(tableName, data) {
+		if (data.length === 0) throw new Error("Cannot infer schema from empty data");
+		const columnTypes = /* @__PURE__ */ new Map();
+		const booleanColumns = /* @__PURE__ */ new Set();
+		const nonBooleanColumns = /* @__PURE__ */ new Set();
+		for (const row of data) for (const [key, value] of Object.entries(row)) {
+			if (!columnTypes.has(key)) columnTypes.set(key, /* @__PURE__ */ new Set());
+			columnTypes.get(key).add(this.inferType(value));
+			if (typeof value === "boolean") booleanColumns.add(key);
+			else if (value !== null) nonBooleanColumns.add(key);
+		}
+		const columns = [];
+		for (const [columnName, types] of columnTypes.entries()) {
+			const typeArray = Array.from(types);
+			let sqlType = "TEXT";
+			if (typeArray.length === 1) sqlType = typeArray[0];
+			else if (typeArray.every((t) => t === "INTEGER" || t === "REAL")) sqlType = "REAL";
+			else if (!typeArray.includes("NULL")) sqlType = "TEXT";
+			else if (typeArray.length === 2 && typeArray.includes("NULL")) sqlType = typeArray.find((t) => t !== "NULL");
+			const isBooleanColumn = booleanColumns.has(columnName) && !nonBooleanColumns.has(columnName);
+			columns.push({
+				name: columnName,
+				type: sqlType,
+				notNull: !typeArray.includes("NULL"),
+				valueType: isBooleanColumn ? "boolean" : void 0
+			});
+		}
+		const idColumn = columns.find((col) => col.name === "id");
+		if (idColumn) idColumn.primaryKey = true;
+		return {
+			name: tableName,
+			columns
+		};
+	}
+	static inferType(value) {
+		if (value === null) return "NULL";
+		if (typeof value === "number") return Number.isInteger(value) ? "INTEGER" : "REAL";
+		if (typeof value === "string") return "TEXT";
+		if (typeof value === "boolean") return "INTEGER";
+		if (typeof value === "object") return "JSON";
+		return "TEXT";
+	}
+};
+
+//#endregion
+//#region src/jsonl-writer.ts
+var JsonlWriter = class {
+	/**
+	* Write data to JSONL file
+	*/
+	static async write(filePath, data) {
+		await writeFile(filePath, data.map((obj) => JSON.stringify(obj)).join("\n") + "\n", "utf-8");
+	}
+	/**
+	* Append data to JSONL file
+	*/
+	static async append(filePath, data) {
+		const { readFile: readFile$1, writeFile: writeFile$1 } = await import("node:fs/promises");
+		try {
+			const existing = await readFile$1(filePath, "utf-8");
+			const lines = data.map((obj) => JSON.stringify(obj)).join("\n");
+			await writeFile$1(filePath, existing.trim() + "\n" + lines + "\n", "utf-8");
+		} catch (error) {
+			if (error.code === "ENOENT") await this.write(filePath, data);
+			else throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/schema-loader.ts
+var SchemaLoader = class {
+	/**
+	* Load a validation schema file for a table
+	* Requires ${tableName}.schema.ts to exist alongside the JSONL file
+	*/
+	static async loadSchema(jsonlPath) {
+		const dir = dirname(jsonlPath);
+		const tableName = basename(jsonlPath, ".jsonl");
+		const schemaPath = join(dir, `${tableName}.schema.ts`);
+		try {
+			await access(schemaPath);
+		} catch (error) {
+			throw new Error(`Schema file not found for table '${tableName}'. Expected: ${schemaPath}`, { cause: error instanceof Error ? error : void 0 });
+		}
+		try {
+			const module = await import(`${pathToFileURL(schemaPath).href}?t=${Date.now()}`);
+			const schema = module.default || module.schema;
+			if (schema && this.isStandardSchema(schema)) return schema;
+			throw new Error(`Schema file ${schemaPath} does not export a valid StandardSchema`);
+		} catch (error) {
+			throw new Error(`Failed to load schema for table '${tableName}' from ${schemaPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : void 0 });
+		}
+	}
+	/**
+	* Check if an object implements the StandardSchema interface
+	*/
+	static isStandardSchema(obj) {
+		if (!obj || typeof obj !== "object") return false;
+		const standard = obj["~standard"];
+		if (!standard || typeof standard !== "object") return false;
+		const standardObj = standard;
+		return standardObj.version === 1 && typeof standardObj.vendor === "string" && typeof standardObj.validate === "function";
+	}
+};
+
+//#endregion
+//#region src/directory-scanner.ts
+var DirectoryScanner = class {
+	/**
+	* Scan directory for JSONL files and create table configurations
+	*/
+	static async scanDirectory(dataDir) {
+		const tables = /* @__PURE__ */ new Map();
+		try {
+			const files = await readdir(dataDir);
+			for (const file of files) if (extname(file) === ".jsonl") {
+				const tableName = basename(file, ".jsonl");
+				const jsonlPath = join(dataDir, file);
+				tables.set(tableName, {
+					jsonlPath,
+					autoInferSchema: true
+				});
+			}
+			if (tables.size === 0) console.warn(`Warning: No JSONL files found in directory: ${dataDir}`);
+			return tables;
+		} catch (error) {
+			throw new Error(`Failed to scan directory ${dataDir}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/schema.ts
+/**
+* Define a bidirectional schema with optional backward transformation
+*
+* @param schema - Standard Schema for validation
+* @param optionsOrBackward - Optional SchemaOptions object or backward transformation function (Output → Input)
+*                            Required when schema performs transformations
+*
+* @example
+* // No transformation - backward not needed
+* const schema = defineSchema(
+*   v.object({ id: v.number(), name: v.string() })
+* );
+*
+* @example
+* // With transformation - backward recommended (legacy)
+* const schema = defineSchema(
+*   v.pipe(v.string(), v.transform(Number)),
+*   (num) => String(num)  // backward: number → string
+* );
+*
+* @example
+* // With primary key and foreign key
+* const schema = defineSchema(
+*   v.object({ id: v.number(), customerId: v.number() }),
+*   {
+*     primaryKey: ['id'],
+*     foreignKeys: [
+*       { columns: ['customerId'], references: { table: 'users', columns: ['id'] } }
+*     ]
+*   }
+* );
+*/
+function defineSchema(schema, optionsOrBackward) {
+	const bidirectionalSchema = Object.create(schema);
+	if (optionsOrBackward) if (typeof optionsOrBackward === "function") bidirectionalSchema.backward = optionsOrBackward;
+	else {
+		if (optionsOrBackward.backward) bidirectionalSchema.backward = optionsOrBackward.backward;
+		if (optionsOrBackward.primaryKey) bidirectionalSchema.primaryKey = optionsOrBackward.primaryKey;
+		if (optionsOrBackward.foreignKeys) bidirectionalSchema.foreignKeys = optionsOrBackward.foreignKeys;
+		if (optionsOrBackward.indexes) bidirectionalSchema.indexes = optionsOrBackward.indexes;
+	}
+	Object.defineProperty(bidirectionalSchema, "~standard", {
+		value: schema["~standard"],
+		enumerable: true,
+		configurable: true
+	});
+	return bidirectionalSchema;
+}
+/**
+* Check if a schema has backward transformation
+*/
+function hasBackward(schema) {
+	return "backward" in schema && typeof schema.backward === "function";
+}
+
+//#endregion
+//#region src/database.ts
+var LinesDB = class LinesDB {
+	db;
+	config;
+	schemas = /* @__PURE__ */ new Map();
+	validationSchemas = /* @__PURE__ */ new Map();
+	tables = /* @__PURE__ */ new Map();
+	inTransaction = false;
+	constructor(config, dbPath) {
+		this.config = config;
+		this.db = createDatabase(dbPath ?? ":memory:");
+	}
+	static create(config, dbPath) {
+		return new LinesDB(config, dbPath);
+	}
+	/**
+	* Initialize database by loading all JSONL files
+	*/
+	async initialize() {
+		this.tables = await DirectoryScanner.scanDirectory(this.config.dataDir);
+		for (const [tableName, tableConfig] of this.tables) try {
+			await this.loadTable(tableName, tableConfig);
+		} catch (error) {
+			console.warn(`Warning: Failed to load table '${tableName}':`, error instanceof Error ? error.message : String(error));
+			this.tables.delete(tableName);
+		}
+	}
+	/**
+	* Load a single table from JSONL file
+	*/
+	async loadTable(tableName, config) {
+		const data = await JsonlReader.read(config.jsonlPath);
+		if (data.length === 0) {
+			console.warn(`Warning: Table ${tableName} has no data`);
+			return;
+		}
+		let validationSchema = config.validationSchema;
+		if (!validationSchema) try {
+			validationSchema = await SchemaLoader.loadSchema(config.jsonlPath);
+		} catch (error) {
+			console.log(`[LinesDB] No validation schema for table '${tableName}':`, error instanceof Error ? error.message : String(error));
+		}
+		console.log(`[LinesDB] Loaded validation schema for table '${tableName}':`, validationSchema ? "FOUND" : "NOT FOUND");
+		if (validationSchema) {
+			console.log(`[LinesDB] Schema type:`, typeof validationSchema);
+			console.log(`[LinesDB] Schema has '~standard':`, "~standard" in validationSchema);
+		}
+		this.validationSchemas.set(tableName, validationSchema);
+		let schema;
+		if (config.schema) schema = config.schema;
+		else if (config.autoInferSchema !== false) schema = JsonlReader.inferSchema(tableName, data);
+		else throw new Error(`No schema provided for table ${tableName} and autoInferSchema is disabled`);
+		if (validationSchema) {
+			const biSchema = validationSchema;
+			if (biSchema.primaryKey && !schema.columns.some((col) => col.primaryKey)) for (const pkColumn of biSchema.primaryKey) {
+				const col = schema.columns.find((c) => c.name === pkColumn);
+				if (col) col.primaryKey = true;
+			}
+			if (biSchema.foreignKeys) schema.foreignKeys = biSchema.foreignKeys;
+			if (biSchema.indexes) schema.indexes = biSchema.indexes;
+		}
+		this.schemas.set(tableName, schema);
+		this.createTable(schema);
+		const validationErrors = [];
+		for (let rowIndex = 0; rowIndex < data.length; rowIndex++) {
+			const row = data[rowIndex];
+			try {
+				this.validateData(tableName, row);
+			} catch (error) {
+				if (error instanceof Error && error.name === "ValidationError") validationErrors.push({
+					rowIndex,
+					rowData: row,
+					error
+				});
+				else throw error;
+			}
+		}
+		if (validationErrors.length > 0) {
+			const enhancedError = /* @__PURE__ */ new Error(`Validation failed for ${validationErrors.length} row(s) in table ${tableName}`);
+			enhancedError.name = "ValidationError";
+			enhancedError.validationErrors = validationErrors;
+			enhancedError.issues = validationErrors[0].error.issues;
+			throw enhancedError;
+		}
+		this.insertData(tableName, schema, data);
+	}
+	/**
+	* Create table in SQLite with constraints and indexes
+	*/
+	createTable(schema) {
+		this.db.exec("PRAGMA foreign_keys = ON");
+		const quotedTableName = this.quoteTableName(schema.name);
+		const columnDefs = schema.columns.map((col) => {
+			const sqlType = col.type === "JSON" ? "TEXT" : col.type;
+			const parts = [this.quoteIdentifier(col.name), sqlType];
+			if (col.primaryKey) parts.push("PRIMARY KEY");
+			if (col.notNull) parts.push("NOT NULL");
+			if (col.unique) parts.push("UNIQUE");
+			return parts.join(" ");
+		});
+		const foreignKeyDefs = [];
+		if (schema.foreignKeys && schema.foreignKeys.length > 0) for (const fk of schema.foreignKeys) {
+			const fkParts = [`FOREIGN KEY (${fk.columns.map((col) => this.quoteIdentifier(col)).join(", ")})`, `REFERENCES ${this.quoteTableName(fk.references.table)}(${fk.references.columns.map((col) => this.quoteIdentifier(col)).join(", ")})`];
+			if (fk.onDelete) fkParts.push(`ON DELETE ${fk.onDelete}`);
+			if (fk.onUpdate) fkParts.push(`ON UPDATE ${fk.onUpdate}`);
+			foreignKeyDefs.push(fkParts.join(" "));
+		}
+		const sql = `CREATE TABLE IF NOT EXISTS ${quotedTableName} (${[...columnDefs, ...foreignKeyDefs].join(", ")})`;
+		this.db.exec(sql);
+		if (schema.indexes && schema.indexes.length > 0) for (let i = 0; i < schema.indexes.length; i++) {
+			const index = schema.indexes[i];
+			const safeTableName = schema.name.replace(/[^a-zA-Z0-9]/g, "_");
+			const resolvedIndexName = index.name || `idx_${safeTableName}_${index.columns.join("_")}_${i}`;
+			const indexSql = `CREATE ${index.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${this.quoteIdentifier(resolvedIndexName)} ON ${quotedTableName} (${index.columns.map((col) => this.quoteIdentifier(col)).join(", ")})`;
+			this.db.exec(indexSql);
+		}
+	}
+	/**
+	* Quote table name to handle special characters in SQL
+	*/
+	quoteTableName(tableName) {
+		return this.quoteIdentifier(tableName);
+	}
+	/**
+	* Quote identifier for SQL statements, escaping embedded quotes
+	*/
+	quoteIdentifier(identifier) {
+		return `"${identifier.replace(/"/g, "\"\"")}"`;
+	}
+	/**
+	* Insert data into table
+	*/
+	insertData(tableName, schema, data) {
+		const columnNames = schema.columns.map((col) => col.name);
+		const quotedColumns = columnNames.map((name) => this.quoteIdentifier(name));
+		const placeholders = columnNames.map(() => "?").join(", ");
+		const sql = `INSERT INTO ${this.quoteTableName(tableName)} (${quotedColumns.join(", ")}) VALUES (${placeholders})`;
+		const stmt = this.db.prepare(sql);
+		for (const row of data) {
+			const values = columnNames.map((col) => this.normalizeValue(row[col]));
+			stmt.run(...values);
+		}
+	}
+	/**
+	* Execute a raw SQL query
+	*/
+	query(sql, params = []) {
+		return this.db.prepare(sql).all(...params);
+	}
+	/**
+	* Execute a SQL query that returns a single row
+	*/
+	queryOne(sql, params = []) {
+		const result = this.db.prepare(sql).get(...params);
+		return result === void 0 ? null : result;
+	}
+	/**
+	* Execute a SQL statement (INSERT, UPDATE, DELETE)
+	*/
+	execute(sql, params = []) {
+		return this.db.prepare(sql).run(...params);
+	}
+	/**
+	* Find rows by condition (supports OR/AND with arrays and function filters)
+	* If where is not provided, returns all rows
+	*/
+	find(tableName, where) {
+		if (where === void 0) return this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
+		if (Array.isArray(where) && where.length === 0) return [];
+		const { sql, values, functionFilters, hasOrWithFunctionFilters } = this.buildWhereClause(where);
+		let rows;
+		if (hasOrWithFunctionFilters) {
+			rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
+			return this.applyOrConditionWithFilters(rows, where);
+		}
+		if (sql) rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)} WHERE ${sql}`, values).map((row) => this.deserializeRow(tableName, row));
+		else rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
+		return this.applyFunctionFilters(rows, functionFilters);
+	}
+	/**
+	* Find a single row by condition (supports OR/AND with arrays and function filters)
+	*/
+	findOne(tableName, where) {
+		const { sql, values, functionFilters } = this.buildWhereClause(where);
+		let rows;
+		if (sql) rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)} WHERE ${sql}`, values).map((row) => this.deserializeRow(tableName, row));
+		else rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
+		const filtered = this.applyFunctionFilters(rows, functionFilters);
+		return filtered.length > 0 ? filtered[0] : null;
+	}
+	/**
+	* Deserialize JSON columns in a row
+	*/
+	deserializeRow(tableName, row) {
+		const schema = this.schemas.get(tableName);
+		if (!schema) return row;
+		const deserializedRow = { ...row };
+		for (const column of schema.columns) {
+			const colName = column.name;
+			if (!(colName in deserializedRow)) continue;
+			const value = deserializedRow[colName];
+			if (column.type === "JSON" && typeof value === "string") {
+				try {
+					deserializedRow[colName] = JSON.parse(value);
+				} catch (error) {
+					console.warn(`Failed to parse JSON column ${colName}:`, error);
+				}
+				continue;
+			}
+			if (column.valueType === "boolean") {
+				if (typeof value === "number") deserializedRow[colName] = value === 0 ? false : true;
+				else if (typeof value === "bigint") deserializedRow[colName] = value === 0n ? false : true;
+			}
+		}
+		return deserializedRow;
+	}
+	/**
+	* Validate data using StandardSchema
+	* Note: Only synchronous validation is supported
+	*/
+	validateData(tableName, data) {
+		const schema = this.validationSchemas.get(tableName);
+		console.log(`[LinesDB] validateData called for table '${tableName}', schema exists:`, !!schema);
+		if (!schema) {
+			console.log(`[LinesDB] No validation schema found for table '${tableName}', skipping validation`);
+			return;
+		}
+		console.log(`[LinesDB] Validating data:`, JSON.stringify(data));
+		const result = schema["~standard"].validate(data);
+		if (result instanceof Promise) throw new Error("Asynchronous validation is not supported. Please use synchronous validation schemas.");
+		if (result.issues && result.issues.length > 0) {
+			const errorMessage = `Validation failed for table '${tableName}':\n${result.issues.map((issue) => {
+				let pathStr = "root";
+				if (issue.path && issue.path.length > 0) pathStr = issue.path.map((segment) => {
+					if (typeof segment === "object" && segment !== null && "key" in segment) return String(segment.key);
+					return String(segment);
+				}).join(".");
+				return `  - ${pathStr}: ${issue.message}`;
+			}).join("\n")}`;
+			const error = new Error(errorMessage);
+			error.name = "ValidationError";
+			error.issues = result.issues;
+			throw error;
+		}
+	}
+	/**
+	* Insert a row into a table with validation
+	*/
+	insert(tableName, data) {
+		this.validateData(tableName, data);
+		if (!this.schemas.get(tableName)) throw new Error(`Table ${tableName} does not exist`);
+		const columnNames = Object.keys(data);
+		const quotedColumns = columnNames.map((col) => this.quoteIdentifier(col));
+		const placeholders = columnNames.map(() => "?").join(", ");
+		const sql = `INSERT INTO ${this.quoteTableName(tableName)} (${quotedColumns.join(", ")}) VALUES (${placeholders})`;
+		const values = Object.values(data).map((v) => this.normalizeValue(v));
+		const result = this.execute(sql, values);
+		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
+			console.error(`Failed to sync table ${tableName}:`, err);
+		});
+		return result;
+	}
+	/**
+	* Batch insert rows with validation per record.
+	*/
+	batchInsert(tableName, records) {
+		if (!this.schemas.get(tableName)) throw new Error(`Table ${tableName} does not exist`);
+		if (records.length === 0) return {
+			changes: 0,
+			lastInsertRowid: 0
+		};
+		let totalChanges = 0n;
+		let lastRowid = 0n;
+		for (const record of records) {
+			this.validateData(tableName, record);
+			const columnNames = Object.keys(record);
+			const quotedColumns = columnNames.map((col) => this.quoteIdentifier(col));
+			const placeholders = columnNames.map(() => "?").join(", ");
+			const sql = `INSERT INTO ${this.quoteTableName(tableName)} (${quotedColumns.join(", ")}) VALUES (${placeholders})`;
+			const values = columnNames.map((col) => this.normalizeValue(record[col]));
+			const result = this.execute(sql, values);
+			totalChanges += BigInt(result.changes);
+			lastRowid = BigInt(result.lastInsertRowid);
+		}
+		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
+			console.error(`Failed to sync table ${tableName}:`, err);
+		});
+		return {
+			changes: totalChanges,
+			lastInsertRowid: lastRowid
+		};
+	}
+	/**
+	* Update rows in a table with validation (supports OR/AND with arrays)
+	* Note: Function filters are not supported for update operations
+	* Note: By default, validation is enabled. For partial updates, existing data is fetched
+	* and merged before validation. Set options.validate = false to disable validation.
+	*/
+	update(tableName, data, where, options) {
+		if (!this.schemas.get(tableName)) throw new Error(`Table ${tableName} does not exist`);
+		const shouldValidate = options?.validate !== false;
+		const hasValidationSchema = this.validationSchemas.has(tableName);
+		if (shouldValidate && hasValidationSchema) {
+			const existingRows = this.find(tableName, where);
+			for (const existingRow of existingRows) {
+				const mergedData = {
+					...existingRow,
+					...data
+				};
+				this.validateData(tableName, mergedData);
+			}
+		}
+		const { sql: whereSql, values: whereValues, functionFilters } = this.buildWhereClause(where);
+		if (functionFilters.length > 0) throw new Error("Function filters are not supported in update operations");
+		const setClauses = Object.keys(data).map((key) => `${this.quoteIdentifier(key)} = ?`).join(", ");
+		const sql = `UPDATE ${this.quoteTableName(tableName)} SET ${setClauses} WHERE ${whereSql}`;
+		const values = [...Object.values(data).map((v) => this.normalizeValue(v)), ...whereValues];
+		const result = this.execute(sql, values);
+		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
+			console.error(`Failed to sync table ${tableName}:`, err);
+		});
+		return result;
+	}
+	/**
+	* Batch update rows with record-specific values and validation.
+	* Each record must include the primary key to identify the target row.
+	* Validation runs once per merged record unless explicitly disabled.
+	*/
+	batchUpdate(tableName, records, options) {
+		const schema = this.schemas.get(tableName);
+		if (!schema) throw new Error(`Table ${tableName} does not exist`);
+		if (records.length === 0) return {
+			changes: 0,
+			lastInsertRowid: 0
+		};
+		const pkColumn = schema.columns.find((col) => col.primaryKey);
+		if (!pkColumn) throw new Error(`Table ${tableName} does not have a primary key`);
+		const pkName = pkColumn.name;
+		const pkValues = [];
+		for (const record of records) {
+			const pkValue = record[pkName];
+			if (pkValue === void 0) throw new Error(`Record is missing primary key '${String(pkName)}': ${JSON.stringify(record)}`);
+			pkValues.push(pkValue);
+		}
+		const shouldValidate = options?.validate !== false;
+		const hasValidationSchema = this.validationSchemas.has(tableName);
+		if (shouldValidate && hasValidationSchema) {
+			const orCondition = pkValues.map((pkValue) => ({ [pkName]: pkValue }));
+			const existingRows = this.find(tableName, orCondition);
+			const existingRowsMap = /* @__PURE__ */ new Map();
+			for (const row of existingRows) {
+				const pkValue = row[pkName];
+				existingRowsMap.set(pkValue, row);
+			}
+			const validationErrors = [];
+			for (let i = 0; i < records.length; i++) {
+				const record = records[i];
+				const pkValue = record[pkName];
+				const existingRow = existingRowsMap.get(pkValue);
+				if (!existingRow) throw new Error(`No existing row found with ${String(pkName)}=${JSON.stringify(pkValue)}`);
+				const mergedData = {
+					...existingRow,
+					...record
+				};
+				try {
+					this.validateData(tableName, mergedData);
+				} catch (error) {
+					if (error instanceof Error && error.name === "ValidationError") validationErrors.push({
+						rowIndex: i,
+						rowData: mergedData,
+						pkValue,
+						error
+					});
+					else throw error;
+				}
+			}
+			if (validationErrors.length > 0) {
+				const enhancedError = /* @__PURE__ */ new Error(`Validation failed for ${validationErrors.length} row(s)`);
+				enhancedError.name = "ValidationError";
+				enhancedError.validationErrors = validationErrors;
+				enhancedError.issues = validationErrors[0].error.issues;
+				throw enhancedError;
+			}
+		}
+		let totalChanges = 0n;
+		let lastRowid = 0n;
+		for (const record of records) {
+			const pkValue = record[pkName];
+			const where = { [pkName]: pkValue };
+			const result = this.update(tableName, record, where, { validate: false });
+			totalChanges += BigInt(result.changes);
+			lastRowid = BigInt(result.lastInsertRowid);
+		}
+		return {
+			changes: totalChanges,
+			lastInsertRowid: lastRowid
+		};
+	}
+	/**
+	* Delete rows from a table (supports OR/AND with arrays)
+	* Note: Function filters are not supported for delete operations
+	*/
+	delete(tableName, where) {
+		if (!this.schemas.get(tableName)) throw new Error(`Table ${tableName} does not exist`);
+		const { sql: whereSql, values, functionFilters } = this.buildWhereClause(where);
+		if (functionFilters.length > 0) throw new Error("Function filters are not supported in delete operations");
+		const sql = `DELETE FROM ${this.quoteTableName(tableName)} WHERE ${whereSql}`;
+		const result = this.execute(sql, values);
+		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
+			console.error(`Failed to sync table ${tableName}:`, err);
+		});
+		return result;
+	}
+	/**
+	* Batch delete rows by primary key.
+	*/
+	batchDelete(tableName, records) {
+		const schema = this.schemas.get(tableName);
+		if (!schema) throw new Error(`Table ${tableName} does not exist`);
+		if (records.length === 0) return {
+			changes: 0,
+			lastInsertRowid: 0
+		};
+		const pkColumn = schema.columns.find((col) => col.primaryKey);
+		if (!pkColumn) throw new Error(`Table ${tableName} does not have a primary key`);
+		const pkName = pkColumn.name;
+		const pkValues = records.map((record, index) => {
+			const pkValue = record[pkName];
+			if (pkValue === void 0) throw new Error(`Record at index ${index} is missing primary key '${String(pkName)}'`);
+			return pkValue;
+		});
+		const placeholders = pkValues.map(() => "?").join(", ");
+		const sql = `DELETE FROM ${this.quoteTableName(tableName)} WHERE ${this.quoteIdentifier(pkName)} IN (${placeholders})`;
+		const values = pkValues.map((value) => this.normalizeValue(value));
+		const result = this.execute(sql, values);
+		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
+			console.error(`Failed to sync table ${tableName}:`, err);
+		});
+		return {
+			changes: BigInt(result.changes),
+			lastInsertRowid: BigInt(result.lastInsertRowid)
+		};
+	}
+	/**
+	* Normalize value for SQLite
+	*/
+	normalizeValue(value) {
+		if (value === null || value === void 0) return null;
+		if (typeof value === "boolean") return value ? 1 : 0;
+		if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") return value;
+		if (value instanceof Uint8Array) return value;
+		return JSON.stringify(value);
+	}
+	/**
+	* Build WHERE clause from condition (supports OR/AND with arrays and functions)
+	*/
+	buildWhereClause(condition) {
+		const values = [];
+		const functionFilters = [];
+		let hasOrWithFunctionFilters = false;
+		const buildCondition = (cond, isInOr = false) => {
+			if (Array.isArray(cond)) return cond.map((item) => {
+				const clause = Array.isArray(item) ? buildCondition(item, true) : buildCondition(item, true);
+				return clause ? `(${clause})` : "";
+			}).filter((clause) => clause !== "").join(" OR ");
+			const conditions = [];
+			let hasFunctionFilter = false;
+			for (const [key, value] of Object.entries(cond)) if (typeof value === "function") {
+				functionFilters.push({
+					key,
+					fn: value
+				});
+				hasFunctionFilter = true;
+			} else {
+				conditions.push(`${this.quoteIdentifier(key)} = ?`);
+				values.push(this.normalizeValue(value));
+			}
+			if (isInOr && hasFunctionFilter) hasOrWithFunctionFilters = true;
+			return conditions.join(" AND ");
+		};
+		return {
+			sql: buildCondition(condition),
+			values,
+			functionFilters,
+			hasOrWithFunctionFilters
+		};
+	}
+	/**
+	* Apply OR condition with function filters by evaluating each row against the condition
+	*/
+	applyOrConditionWithFilters(rows, condition) {
+		return rows.filter((row) => this.matchesOrCondition(row, condition));
+	}
+	/**
+	* Check if a row matches an OR/AND condition (recursively)
+	*/
+	matchesOrCondition(row, condition) {
+		if (Array.isArray(condition)) return condition.some((item) => this.matchesOrCondition(row, item));
+		return Object.entries(condition).every(([key, value]) => {
+			const rowValue = row[key];
+			if (typeof value === "function") return value(rowValue);
+			return rowValue === value;
+		});
+	}
+	/**
+	* Apply function filters to rows
+	*/
+	applyFunctionFilters(rows, functionFilters) {
+		if (functionFilters.length === 0) return rows;
+		return rows.filter((row) => {
+			return functionFilters.every(({ key, fn }) => {
+				const value = row[key];
+				return fn(value);
+			});
+		});
+	}
+	/**
+	* Get table schema
+	*/
+	getSchema(tableName) {
+		return this.schemas.get(tableName);
+	}
+	/**
+	* Get all table names
+	*/
+	getTableNames() {
+		return Array.from(this.schemas.keys());
+	}
+	/**
+	* Sync a specific table back to its JSONL file
+	* Uses backward transformation when available
+	*/
+	async syncTable(tableName) {
+		const tableConfig = this.tables.get(tableName);
+		if (!tableConfig) throw new Error(`Table ${tableName} not found`);
+		const deserializedRows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
+		const validationSchema = this.validationSchemas.get(tableName);
+		let finalRows = deserializedRows;
+		if (validationSchema && hasBackward(validationSchema)) {
+			const biSchema = validationSchema;
+			finalRows = deserializedRows.map((row) => biSchema.backward(row));
+		}
+		await JsonlWriter.write(tableConfig.jsonlPath, finalRows);
+	}
+	/**
+	* Sync database changes back to JSONL files
+	* Uses backward transformation when available
+	*/
+	async sync() {
+		for (const [tableName] of this.tables) await this.syncTable(tableName);
+	}
+	/**
+	* Execute a function within a transaction
+	* Automatically commits on success or rolls back on error
+	*/
+	async transaction(fn) {
+		if (this.inTransaction) throw new Error("Nested transactions are not supported");
+		this.db.exec("BEGIN TRANSACTION");
+		this.inTransaction = true;
+		try {
+			const result = await fn(this);
+			this.db.exec("COMMIT");
+			this.inTransaction = false;
+			await this.sync();
+			return result;
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			this.inTransaction = false;
+			throw error;
+		}
+	}
+	/**
+	* Close the database connection
+	*/
+	async close() {
+		try {
+			this.db.close();
+		} catch (_error) {}
+	}
+	/**
+	* Get the underlying SQLite database instance
+	*/
+	getDb() {
+		return this.db;
+	}
+};
+
+//#endregion
+//#region src/type-generator.ts
+var TypeGenerator = class {
+	dataDir;
+	projectRoot;
+	outputFile;
+	dataDirPath;
+	constructor(options) {
+		const envProjectRoot = process.env.LINES_DB_TEST_PROJECT_ROOT;
+		this.projectRoot = envProjectRoot !== void 0 ? envProjectRoot : options.projectRoot || process.cwd();
+		this.dataDir = options.dataDir;
+		this.dataDirPath = isAbsolute(this.dataDir) ? this.dataDir : join(this.projectRoot, this.dataDir);
+		this.outputFile = join(this.dataDirPath, "db.ts");
+	}
+	/**
+	* Generate types file from JSONL files and their optional schema files.
+	*/
+	async generate() {
+		const tables = await this.findTables();
+		if (tables.length === 0) throw new Error(`No JSONL files found in ${this.dataDirPath}. Place one or more *.jsonl files in the directory.`);
+		const content = this.generateTypeDeclarations(tables);
+		await mkdir(dirname(this.outputFile), { recursive: true });
+		await writeFile(this.outputFile, content, "utf-8");
+		console.log(`Generated types at ${this.outputFile}`);
+		return this.outputFile;
+	}
+	/**
+	* Find all *.jsonl files and check if they have corresponding *.schema.ts files
+	*/
+	async findTables() {
+		try {
+			const entries = await readdir(this.dataDirPath, { withFileTypes: true });
+			const tables = [];
+			for (const entry of entries) if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+				const tableName = basename(entry.name, ".jsonl");
+				const schemaFileName = `${tableName}.schema.ts`;
+				const schemaFilePath = join(this.dataDirPath, schemaFileName);
+				const hasSchema = entries.some((e) => e.isFile() && e.name === schemaFileName);
+				tables.push({
+					tableName,
+					schemaFile: hasSchema ? schemaFilePath : void 0
+				});
+			}
+			return tables;
+		} catch (error) {
+			if (error.code === "ENOENT") throw new Error(`Data directory not found: ${this.dataDirPath}. Set lines-db.dataDir to the correct location.`);
+			throw error;
+		}
+	}
+	/**
+	* Generate type declaration content
+	*/
+	generateTypeDeclarations(tables) {
+		const imports = [];
+		const tableEntries = [];
+		const usedAliases = /* @__PURE__ */ new Set();
+		for (const table of tables) {
+			const tableKey = this.formatTableKey(table.tableName);
+			if (table.schemaFile) {
+				const schemaIdentifier = this.createSchemaIdentifier(table.tableName, usedAliases);
+				usedAliases.add(schemaIdentifier);
+				let relativePath = relative(join(this.outputFile, ".."), table.schemaFile).replace(/\\/g, "/").replace(".ts", ".js");
+				if (!relativePath.startsWith(".")) relativePath = "./" + relativePath;
+				imports.push(`import { schema as ${schemaIdentifier} } from '${relativePath}';`);
+				tableEntries.push(`  ${tableKey}: InferOutput<typeof ${schemaIdentifier}>;`);
+			} else tableEntries.push(`  ${tableKey}: Record<string, unknown>;`);
+		}
+		return `// Auto-generated by lines-db
+// Do not edit this file manually
+
+${imports.length > 0 ? `${imports.join("\n")}\n` : ""}import type { DatabaseConfig${imports.length > 0 ? ", InferOutput" : ""} } from 'lines-db';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export type Tables = {
+${tableEntries.join("\n")}
+};
+
+export const config: DatabaseConfig<Tables> = {
+  dataDir: __dirname,
+};
+`;
+	}
+	createSchemaIdentifier(tableName, usedAliases) {
+		let base = sanitizeIdentifier(toCamelCase(tableName)) || "table";
+		if (!/^[A-Za-z_$]/.test(base)) base = `_${base}`;
+		let candidate = `${base}Schema`;
+		let suffix = 1;
+		while (usedAliases.has(candidate)) candidate = `${base}${++suffix}Schema`;
+		return candidate;
+	}
+	formatTableKey(tableName) {
+		if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(tableName)) return tableName;
+		return `'${tableName.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+	}
+};
+function toCamelCase(value) {
+	const parts = value.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.toLowerCase());
+	if (parts.length === 0) return value;
+	const [first, ...rest] = parts;
+	return first + rest.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function sanitizeIdentifier(value) {
+	return value.replace(/[^A-Za-z0-9_$]/g, "");
+}
+
+//#endregion
+//#region src/validator.ts
+var Validator = class {
+	path;
+	projectRoot;
+	constructor(options) {
+		this.path = options.path;
+		this.projectRoot = options.projectRoot || process.cwd();
+	}
+	/**
+	* Validate JSONL file(s)
+	*/
+	async validate() {
+		const fullPath = this.path.startsWith("/") ? this.path : join(this.projectRoot, this.path);
+		const stats = await stat(fullPath);
+		if (stats.isDirectory()) return this.validateDirectory(fullPath);
+		else if (stats.isFile() && fullPath.endsWith(".jsonl")) return this.validateFile(fullPath);
+		else throw new Error(`Invalid path: ${this.path}. Must be a directory or .jsonl file.`);
+	}
+	/**
+	* Validate all JSONL files in a directory
+	*/
+	async validateDirectory(dirPath) {
+		const jsonlFiles = (await readdir(dirPath, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => join(dirPath, entry.name));
+		if (jsonlFiles.length === 0) throw new Error(`No JSONL files found in directory: ${dirPath}`);
+		const allErrors = [];
+		for (const file of jsonlFiles) {
+			const result = await this.validateFile(file);
+			allErrors.push(...result.errors);
+		}
+		const fkErrors = await this.validateForeignKeys(dirPath, jsonlFiles);
+		allErrors.push(...fkErrors);
+		return {
+			valid: allErrors.length === 0,
+			errors: allErrors
+		};
+	}
+	/**
+	* Validate foreign key constraints across all tables
+	*/
+	async validateForeignKeys(dirPath, jsonlFiles) {
+		const errors = [];
+		const tableData = /* @__PURE__ */ new Map();
+		const tableSchemas = /* @__PURE__ */ new Map();
+		for (const file of jsonlFiles) {
+			const tableName = basename(file, ".jsonl");
+			const data = await JsonlReader.read(file);
+			const schema = await SchemaLoader.loadSchema(file);
+			tableData.set(tableName, data);
+			tableSchemas.set(tableName, schema);
+		}
+		for (const file of jsonlFiles) {
+			const tableName = basename(file, ".jsonl");
+			const schema = tableSchemas.get(tableName);
+			const data = tableData.get(tableName);
+			if (!schema || !data || !schema.foreignKeys) continue;
+			for (const fk of schema.foreignKeys) {
+				const referencedTable = fk.references.table;
+				const referencedData = tableData.get(referencedTable);
+				if (!referencedData) continue;
+				const referencedValues = /* @__PURE__ */ new Set();
+				for (const refRow of referencedData) {
+					const keyValues = fk.references.columns.map((col) => refRow[col]);
+					const compositeKey = JSON.stringify(keyValues);
+					referencedValues.add(compositeKey);
+				}
+				for (let i = 0; i < data.length; i++) {
+					const row = data[i];
+					const foreignKeyValues = fk.columns.map((col) => row[col]);
+					const compositeKey = JSON.stringify(foreignKeyValues);
+					if (!referencedValues.has(compositeKey)) errors.push({
+						file,
+						tableName,
+						rowIndex: i,
+						issues: [],
+						type: "foreignKey",
+						foreignKeyError: {
+							column: fk.columns.join(", "),
+							value: foreignKeyValues.length === 1 ? foreignKeyValues[0] : foreignKeyValues,
+							referencedTable,
+							referencedColumn: fk.references.columns.join(", ")
+						}
+					});
+				}
+			}
+		}
+		return errors;
+	}
+	/**
+	* Validate a single JSONL file
+	*/
+	async validateFile(filePath) {
+		const tableName = basename(filePath, ".jsonl");
+		const data = await JsonlReader.read(filePath);
+		const schema = await SchemaLoader.loadSchema(filePath);
+		const errors = [];
+		for (let i = 0; i < data.length; i++) {
+			const row = data[i];
+			const result = schema["~standard"].validate(row);
+			if (result instanceof Promise) throw new Error("Asynchronous validation is not supported.");
+			if (result.issues && result.issues.length > 0) errors.push({
+				file: filePath,
+				tableName,
+				rowIndex: i,
+				issues: result.issues,
+				type: "schema"
+			});
+		}
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+};
+
+//#endregion
+//#region src/jsonl-migration.ts
+/**
+* Validate a table by temporarily supplying in-memory rows while reusing the existing LinesDB validation pipeline.
+* If validation fails, the underlying LinesDB error is rethrown so callers can inspect validation details.
+*/
+async function ensureTableRowsValid(options) {
+	console.log("[ensureTableRowsValid] START");
+	console.log("[ensureTableRowsValid] dataDir:", options.dataDir);
+	console.log("[ensureTableRowsValid] tableName:", options.tableName);
+	console.log("[ensureTableRowsValid] rows count:", options.rows.length);
+	const tablePath = join(options.dataDir, `${options.tableName}.jsonl`);
+	const overrides = new Map([[tablePath, options.rows]]);
+	console.log("[ensureTableRowsValid] tablePath:", tablePath);
+	let capturedError = null;
+	const originalWarn = console.warn;
+	const warnMessages = [];
+	console.warn = (...args) => {
+		const message = args.join(" ");
+		console.log("[ensureTableRowsValid] Captured warn:", message);
+		warnMessages.push(message);
+		if (message.includes(`Failed to load table '${options.tableName}'`) && message.includes("Validation failed")) {
+			capturedError = new Error(message);
+			console.log("[ensureTableRowsValid] Captured validation error!");
+		}
+	};
+	try {
+		console.log("[ensureTableRowsValid] Calling JsonlReader.withOverrides");
+		await JsonlReader.withOverrides(overrides, async () => {
+			console.log("[ensureTableRowsValid] Inside withOverrides callback");
+			const db = LinesDB.create({ dataDir: options.dataDir });
+			console.log("[ensureTableRowsValid] LinesDB created");
+			try {
+				console.log("[ensureTableRowsValid] Calling db.initialize()");
+				await db.initialize();
+				console.log("[ensureTableRowsValid] db.initialize() completed");
+			} finally {
+				console.log("[ensureTableRowsValid] Calling db.close()");
+				await db.close();
+			}
+		});
+		console.log("[ensureTableRowsValid] withOverrides completed");
+	} finally {
+		console.warn = originalWarn;
+	}
+	console.log("[ensureTableRowsValid] Warnings captured:", warnMessages.length);
+	console.log("[ensureTableRowsValid] capturedError:", capturedError ? "YES" : "NO");
+	if (capturedError) {
+		console.log("[ensureTableRowsValid] Throwing captured error");
+		throw capturedError;
+	}
+	console.log("[ensureTableRowsValid] END (success)");
+}
+
+//#endregion
+export { DirectoryScanner, JsonlReader, JsonlWriter, LinesDB, RUNTIME, SchemaLoader, TypeGenerator, Validator, defineSchema, detectRuntime, ensureTableRowsValid, hasBackward };
+//# sourceMappingURL=index.js.map