@hedystia/db 2.0.6 → 2.0.8

package/dist/core/repository.mjs

@@ -1,438 +1,442 @@
-import { QueryError } from "../errors.mjs";
-import { FileDriver } from "../drivers/file.mjs";
-import { compileBulkInsert, compileDelete, compileInsert, compileSelect, compileUpdate, compileWhere } from "../drivers/sql-compiler.mjs";
+import { __esmMin } from "../_virtual/_rolldown/runtime.mjs";
+import { QueryError, init_errors } from "../errors.mjs";
+import { FileDriver, init_file } from "../drivers/file.mjs";
+import { compileBulkInsert, compileDelete, compileInsert, compileSelect, compileUpdate, compileWhere, init_sql_compiler } from "../drivers/sql-compiler.mjs";
 //#region src/core/repository.ts
-/**
-* Repository implementation that provides CRUD operations for a table
-* @template T - The row type for this table
-*/
-var TableRepository = class {
-	tableName;
-	driver;
-	cache;
-	registry;
-	meta;
-	columnMap;
-	reverseColumnMap;
-	hasAliases;
-	tableCacheConfig;
-	jsonColumns;
-	jsonCodeKeys;
-	constructor(tableName, driver, cache, registry, tableCacheConfig) {
-		this.tableName = tableName;
-		this.driver = driver;
-		this.cache = cache;
-		this.registry = registry;
-		this.tableCacheConfig = tableCacheConfig;
-		const meta = registry.getTable(tableName);
-		if (!meta) throw new QueryError(`Table "${tableName}" is not registered`);
-		this.meta = meta;
-		this.columnMap = registry.getColumnMap(tableName);
-		this.reverseColumnMap = registry.getReverseColumnMap(tableName);
-		this.hasAliases = Object.entries(this.columnMap).some(([codeKey, dbName]) => codeKey !== dbName);
-		this.jsonColumns = new Set(meta.columns.filter((c) => c.type === "json" || c.type === "array").map((c) => c.name));
-		this.jsonCodeKeys = /* @__PURE__ */ new Set();
-		for (const col of meta.columns) if (col.type === "json" || col.type === "array") {
-			const codeKey = this.reverseColumnMap[col.name] ?? col.name;
-			this.jsonCodeKeys.add(codeKey);
+var TableRepository;
+var init_repository = __esmMin((() => {
+	init_file();
+	init_sql_compiler();
+	init_errors();
+	TableRepository = class {
+		tableName;
+		driver;
+		cache;
+		registry;
+		meta;
+		columnMap;
+		reverseColumnMap;
+		hasAliases;
+		tableCacheConfig;
+		jsonColumns;
+		jsonCodeKeys;
+		constructor(tableName, driver, cache, registry, tableCacheConfig) {
+			this.tableName = tableName;
+			this.driver = driver;
+			this.cache = cache;
+			this.registry = registry;
+			this.tableCacheConfig = tableCacheConfig;
+			const meta = registry.getTable(tableName);
+			if (!meta) throw new QueryError(`Table "${tableName}" is not registered`);
+			this.meta = meta;
+			this.columnMap = registry.getColumnMap(tableName);
+			this.reverseColumnMap = registry.getReverseColumnMap(tableName);
+			this.hasAliases = Object.entries(this.columnMap).some(([codeKey, dbName]) => codeKey !== dbName);
+			this.jsonColumns = new Set(meta.columns.filter((c) => c.type === "json" || c.type === "array").map((c) => c.name));
+			this.jsonCodeKeys = /* @__PURE__ */ new Set();
+			for (const col of meta.columns) if (col.type === "json" || col.type === "array") {
+				const codeKey = this.reverseColumnMap[col.name] ?? col.name;
+				this.jsonCodeKeys.add(codeKey);
+			}
 		}
-	}
-	/**
-	* Find all rows matching the query options
-	* @param {QueryOptions<T>} [options] - Query options
-	* @returns {Promise<T[]>} Array of matching rows
-	*/
-	async find(options) {
-		return this.cache.getOrSetWithTableConfig(this.tableName, "find", options, async () => {
-			const dbOptions = this.mapOptionsToDb(options);
-			let rows;
-			if (this.driver instanceof FileDriver) rows = this.mapRows(this.findFile(dbOptions));
-			else rows = this.mapRows(await this.findSQL(dbOptions));
-			if (options?.with) rows = await this.loadRelations(rows, options.with);
-			this.cacheEntities(rows);
-			return rows;
-		}, this.tableCacheConfig);
-	}
-	/**
-	* Find all rows matching the query options (alias for find)
-	* @param {QueryOptions<T>} [options] - Query options
-	* @returns {Promise<T[]>} Array of matching rows
-	*/
-	async findMany(options) {
-		return this.find(options);
-	}
-	/**
-	* Find the first row matching the query options
-	* @param {QueryOptions<T>} [options] - Query options
-	* @returns {Promise<T | null>} The first matching row or null
-	*/
-	async findFirst(options) {
-		return this.cache.getOrSetWithTableConfig(this.tableName, "findFirst", options, async () => {
-			const opts = {
-				...this.mapOptionsToDb(options),
-				take: 1
-			};
-			let rows;
-			if (this.driver instanceof FileDriver) rows = this.mapRows(this.findFile(opts));
-			else rows = this.mapRows(await this.findSQL(opts));
-			if (rows.length === 0) return null;
-			if (options?.with) rows = await this.loadRelations(rows, options.with);
-			const row = rows[0] ?? null;
-			if (row) this.cacheEntity(row);
-			return row;
-		}, this.tableCacheConfig);
-	}
-	/**
-	* Insert one or more rows
-	* @param {Partial<T> | Partial<T>[]} data - Data to insert
-	* @returns {Promise<T>} The inserted row
-	*/
-	async insert(data) {
-		const single = Array.isArray(data) ? data[0] : data;
-		if (!single) throw new QueryError("Insert data cannot be empty");
-		this.cache.invalidateTable(this.tableName);
-		const cleaned = this.toDbKeys(this.cleanData(single));
-		if (this.driver instanceof FileDriver) {
-			const id = this.driver.insertRow(this.tableName, cleaned);
-			const pk = this.registry.getPrimaryKey(this.tableName);
-			if (pk) cleaned[pk] = id;
-			const result = this.toCodeKeys(cleaned);
-			this.cacheEntity(result);
-			return result;
+		/**
+		* Find all rows matching the query options
+		* @param {QueryOptions<T>} [options] - Query options
+		* @returns {Promise<T[]>} Array of matching rows
+		*/
+		async find(options) {
+			return this.cache.getOrSetWithTableConfig(this.tableName, "find", options, async () => {
+				const dbOptions = this.mapOptionsToDb(options);
+				let rows;
+				if (this.driver instanceof FileDriver) rows = this.mapRows(this.findFile(dbOptions));
+				else rows = this.mapRows(await this.findSQL(dbOptions));
+				if (options?.with) rows = await this.loadRelations(rows, options.with);
+				this.cacheEntities(rows);
+				return rows;
+			}, this.tableCacheConfig);
 		}
-		const params = [];
-		const sql = compileInsert(this.tableName, cleaned, params);
-		const result = await this.driver.execute(sql, params);
-		const pk = this.registry.getPrimaryKey(this.tableName);
-		if (pk && result.insertId) cleaned[pk] = result.insertId;
-		const mapped = this.toCodeKeys(cleaned);
-		this.cacheEntity(mapped);
-		return mapped;
-	}
-	/**
-	* Insert multiple rows
-	* @param {Partial<T>[]} data - Array of data to insert
-	* @returns {Promise<T[]>} The inserted rows
-	*/
-	async insertMany(data) {
-		if (data.length === 0) return [];
-		this.cache.invalidateTable(this.tableName);
-		if (this.driver instanceof FileDriver) {
-			const results = [];
-			for (const item of data) results.push(await this.insert(item));
-			return results;
+		/**
+		* Find all rows matching the query options (alias for find)
+		* @param {QueryOptions<T>} [options] - Query options
+		* @returns {Promise<T[]>} Array of matching rows
+		*/
+		async findMany(options) {
+			return this.find(options);
 		}
-		const cleanedData = data.map((item) => this.toDbKeys(this.cleanData(item)));
-		const params = [];
-		const sql = compileBulkInsert(this.tableName, cleanedData, params);
-		const result = await this.driver.execute(sql, params);
-		const pk = this.registry.getPrimaryKey(this.tableName);
-		if (pk && result.insertId) for (let i = 0; i < cleanedData.length; i++) {
-			const row = cleanedData[i];
-			if (row) row[pk] = result.insertId + i;
+		/**
+		* Find the first row matching the query options
+		* @param {QueryOptions<T>} [options] - Query options
+		* @returns {Promise<T | null>} The first matching row or null
+		*/
+		async findFirst(options) {
+			return this.cache.getOrSetWithTableConfig(this.tableName, "findFirst", options, async () => {
+				const opts = {
+					...this.mapOptionsToDb(options),
+					take: 1
+				};
+				let rows;
+				if (this.driver instanceof FileDriver) rows = this.mapRows(this.findFile(opts));
+				else rows = this.mapRows(await this.findSQL(opts));
+				if (rows.length === 0) return null;
+				if (options?.with) rows = await this.loadRelations(rows, options.with);
+				const row = rows[0] ?? null;
+				if (row) this.cacheEntity(row);
+				return row;
+			}, this.tableCacheConfig);
 		}
-		const finalRows = this.mapRows(cleanedData);
-		this.cacheEntities(finalRows);
-		return finalRows;
-	}
-	/**
-	* Update rows matching the where clause
-	* @param {UpdateOptions<T>} options - Update options with where and data
-	* @returns {Promise<T[]>} The updated rows
-	*/
-	async update(options) {
-		if (!options.where || Object.keys(options.where).length === 0) throw new QueryError("Update requires a where clause");
-		this.cache.invalidateTable(this.tableName);
-		const cleaned = this.toDbKeys(this.cleanData(options.data));
-		const dbWhere = this.mapWhereToDb(options.where);
-		if (this.driver instanceof FileDriver) {
-			const filter = this.buildFileFilter(dbWhere);
-			this.driver.updateRows(this.tableName, filter, cleaned);
-			return this.find({ where: options.where });
+		/**
+		* Insert one or more rows
+		* @param {Partial<T> | Partial<T>[]} data - Data to insert
+		* @returns {Promise<T>} The inserted row
+		*/
+		async insert(data) {
+			const single = Array.isArray(data) ? data[0] : data;
+			if (!single) throw new QueryError("Insert data cannot be empty");
+			this.cache.invalidateTable(this.tableName);
+			const cleaned = this.toDbKeys(this.cleanData(single));
+			if (this.driver instanceof FileDriver) {
+				const id = this.driver.insertRow(this.tableName, cleaned);
+				const pk = this.registry.getPrimaryKey(this.tableName);
+				if (pk) cleaned[pk] = id;
+				const result = this.toCodeKeys(cleaned);
+				this.cacheEntity(result);
+				return result;
+			}
+			const params = [];
+			const sql = compileInsert(this.tableName, cleaned, params);
+			const result = await this.driver.execute(sql, params);
+			const pk = this.registry.getPrimaryKey(this.tableName);
+			if (pk && result.insertId) cleaned[pk] = result.insertId;
+			const mapped = this.toCodeKeys(cleaned);
+			this.cacheEntity(mapped);
+			return mapped;
 		}
-		const params = [];
-		const sql = compileUpdate(this.tableName, cleaned, dbWhere, params);
-		await this.driver.execute(sql, params);
-		return this.find({ where: options.where });
-	}
-	/**
-	* Delete rows matching the where clause
-	* @param {DeleteOptions<T>} options - Delete options with where clause
-	* @returns {Promise<number>} Number of deleted rows
-	*/
-	async delete(options) {
-		if (!options.where || Object.keys(options.where).length === 0) throw new QueryError("Delete requires a where clause");
-		this.cache.invalidateTable(this.tableName);
-		const dbWhere = this.mapWhereToDb(options.where);
-		if (this.driver instanceof FileDriver) {
-			const filter = this.buildFileFilter(dbWhere);
-			return this.driver.deleteRows(this.tableName, filter);
+		/**
+		* Insert multiple rows
+		* @param {Partial<T>[]} data - Array of data to insert
+		* @returns {Promise<T[]>} The inserted rows
+		*/
+		async insertMany(data) {
+			if (data.length === 0) return [];
+			this.cache.invalidateTable(this.tableName);
+			if (this.driver instanceof FileDriver) {
+				const results = [];
+				for (const item of data) results.push(await this.insert(item));
+				return results;
+			}
+			const cleanedData = data.map((item) => this.toDbKeys(this.cleanData(item)));
+			const params = [];
+			const sql = compileBulkInsert(this.tableName, cleanedData, params);
+			const result = await this.driver.execute(sql, params);
+			const pk = this.registry.getPrimaryKey(this.tableName);
+			if (pk && result.insertId) for (let i = 0; i < cleanedData.length; i++) {
+				const row = cleanedData[i];
+				if (row) row[pk] = result.insertId + i;
+			}
+			const finalRows = this.mapRows(cleanedData);
+			this.cacheEntities(finalRows);
+			return finalRows;
 		}
-		const params = [];
-		const sql = compileDelete(this.tableName, dbWhere, params);
-		return (await this.driver.execute(sql, params)).affectedRows;
-	}
-	/**
-	* Count rows matching the where clause
-	* @param {Pick<QueryOptions<T>, "where">} [options] - Count options
-	* @returns {Promise<number>} Row count
-	*/
-	async count(options) {
-		return this.cache.getOrSetWithTableConfig(this.tableName, "count", options, async () => {
-			const dbWhere = options?.where ? this.mapWhereToDb(options.where) : void 0;
+		/**
+		* Update rows matching the where clause
+		* @param {UpdateOptions<T>} options - Update options with where and data
+		* @returns {Promise<T[]>} The updated rows
+		*/
+		async update(options) {
+			if (!options.where || Object.keys(options.where).length === 0) throw new QueryError("Update requires a where clause");
+			this.cache.invalidateTable(this.tableName);
+			const cleaned = this.toDbKeys(this.cleanData(options.data));
+			const dbWhere = this.mapWhereToDb(options.where);
 			if (this.driver instanceof FileDriver) {
-				const filter = dbWhere ? this.buildFileFilter(dbWhere) : void 0;
-				return this.driver.countRows(this.tableName, filter);
+				const filter = this.buildFileFilter(dbWhere);
+				this.driver.updateRows(this.tableName, filter, cleaned);
+				return this.find({ where: options.where });
 			}
 			const params = [];
-			let sql = `SELECT COUNT(*) as count FROM \`${this.tableName}\``;
-			if (dbWhere && Object.keys(dbWhere).length > 0) sql += ` WHERE ${compileWhere(dbWhere, params)}`;
-			return (await this.driver.query(sql, params))[0]?.count ?? 0;
-		}, this.tableCacheConfig);
-	}
-	/**
-	* Check if any row exists matching the where clause
-	* @param {Pick<QueryOptions<T>, "where">} options - Exists options
-	* @returns {Promise<boolean>} Whether a matching row exists
-	*/
-	async exists(options) {
-		return await this.count(options) > 0;
-	}
-	/**
-	* Insert or update a row based on the where clause
-	* @param {object} options - Upsert options
-	* @param {WhereClause<T>} options.where - Condition to check
-	* @param {Partial<T>} options.create - Data to insert if not found
-	* @param {Partial<T>} options.update - Data to update if found
-	* @returns {Promise<T>} The upserted row
-	*/
-	async upsert(options) {
-		const existing = await this.findFirst({ where: options.where });
-		if (existing) return (await this.update({
-			where: options.where,
-			data: options.update
-		}))[0] ?? existing;
-		return this.insert(options.create);
-	}
-	/**
-	* Remove all rows from the table
-	*/
-	async truncate() {
-		this.cache.invalidateTable(this.tableName);
-		if (this.driver instanceof FileDriver) {
-			this.driver.truncateTable(this.tableName);
-			return;
+			const sql = compileUpdate(this.tableName, cleaned, dbWhere, params);
+			await this.driver.execute(sql, params);
+			return this.find({ where: options.where });
 		}
-		await this.driver.execute(`DELETE FROM \`${this.tableName}\``);
-	}
-	async findSQL(options) {
-		const params = [];
-		const sql = compileSelect(this.tableName, {
-			select: options?.select,
-			where: options?.where,
-			orderBy: options?.orderBy,
-			take: options?.take,
-			skip: options?.skip
-		}, params);
-		return this.driver.query(sql, params);
-	}
-	findFile(options) {
-		const fd = this.driver;
-		const filter = options?.where ? this.buildFileFilter(options.where) : void 0;
-		let rows = fd.findRows(this.tableName, filter);
-		if (options?.select) {
-			const selectSet = new Set(options.select);
-			rows = rows.map((row) => {
-				const filtered = {};
-				for (const key of selectSet) filtered[key] = row[key];
-				return filtered;
-			});
+		/**
+		* Delete rows matching the where clause
+		* @param {DeleteOptions<T>} options - Delete options with where clause
+		* @returns {Promise<number>} Number of deleted rows
+		*/
+		async delete(options) {
+			if (!options.where || Object.keys(options.where).length === 0) throw new QueryError("Delete requires a where clause");
+			this.cache.invalidateTable(this.tableName);
+			const dbWhere = this.mapWhereToDb(options.where);
+			if (this.driver instanceof FileDriver) {
+				const filter = this.buildFileFilter(dbWhere);
+				return this.driver.deleteRows(this.tableName, filter);
+			}
+			const params = [];
+			const sql = compileDelete(this.tableName, dbWhere, params);
+			return (await this.driver.execute(sql, params)).affectedRows;
 		}
-		if (options?.orderBy) {
-			const entries = Object.entries(options.orderBy);
-			rows.sort((a, b) => {
-				for (const [col, dir] of entries) {
-					const av = a[col];
-					const bv = b[col];
-					if (av < bv) return dir === "asc" ? -1 : 1;
-					if (av > bv) return dir === "asc" ? 1 : -1;
+		/**
+		* Count rows matching the where clause
+		* @param {Pick<QueryOptions<T>, "where">} [options] - Count options
+		* @returns {Promise<number>} Row count
+		*/
+		async count(options) {
+			return this.cache.getOrSetWithTableConfig(this.tableName, "count", options, async () => {
+				const dbWhere = options?.where ? this.mapWhereToDb(options.where) : void 0;
+				if (this.driver instanceof FileDriver) {
+					const filter = dbWhere ? this.buildFileFilter(dbWhere) : void 0;
+					return this.driver.countRows(this.tableName, filter);
 				}
-				return 0;
-			});
+				const params = [];
+				let sql = `SELECT COUNT(*) as count FROM \`${this.tableName}\``;
+				if (dbWhere && Object.keys(dbWhere).length > 0) sql += ` WHERE ${compileWhere(dbWhere, params)}`;
+				return (await this.driver.query(sql, params))[0]?.count ?? 0;
+			}, this.tableCacheConfig);
+		}
+		/**
+		* Check if any row exists matching the where clause
+		* @param {Pick<QueryOptions<T>, "where">} options - Exists options
+		* @returns {Promise<boolean>} Whether a matching row exists
+		*/
+		async exists(options) {
+			return await this.count(options) > 0;
+		}
+		/**
+		* Insert or update a row based on the where clause
+		* @param {object} options - Upsert options
+		* @param {WhereClause<T>} options.where - Condition to check
+		* @param {Partial<T>} options.create - Data to insert if not found
+		* @param {Partial<T>} options.update - Data to update if found
+		* @returns {Promise<T>} The upserted row
+		*/
+		async upsert(options) {
+			const existing = await this.findFirst({ where: options.where });
+			if (existing) return (await this.update({
+				where: options.where,
+				data: options.update
+			}))[0] ?? existing;
+			return this.insert(options.create);
 		}
-		if (options?.skip) rows = rows.slice(options.skip);
-		if (options?.take) rows = rows.slice(0, options.take);
-		return rows;
-	}
-	buildFileFilter(where) {
-		return (row) => this.matchWhere(row, where);
-	}
-	matchWhere(row, where) {
-		for (const [key, value] of Object.entries(where)) {
-			if (key === "OR" && Array.isArray(value)) {
-				if (!value.some((sub) => this.matchWhere(row, sub))) return false;
-				continue;
+		/**
+		* Remove all rows from the table
+		*/
+		async truncate() {
+			this.cache.invalidateTable(this.tableName);
+			if (this.driver instanceof FileDriver) {
+				this.driver.truncateTable(this.tableName);
+				return;
 			}
-			if (key === "AND" && Array.isArray(value)) {
-				if (!value.every((sub) => this.matchWhere(row, sub))) return false;
-				continue;
+			await this.driver.execute(`DELETE FROM \`${this.tableName}\``);
+		}
+		async findSQL(options) {
+			const params = [];
+			const sql = compileSelect(this.tableName, {
+				select: options?.select,
+				where: options?.where,
+				orderBy: options?.orderBy,
+				take: options?.take,
+				skip: options?.skip
+			}, params);
+			return this.driver.query(sql, params);
+		}
+		findFile(options) {
+			const fd = this.driver;
+			const filter = options?.where ? this.buildFileFilter(options.where) : void 0;
+			let rows = fd.findRows(this.tableName, filter);
+			if (options?.select) {
+				const selectSet = new Set(options.select);
+				rows = rows.map((row) => {
+					const filtered = {};
+					for (const key of selectSet) filtered[key] = row[key];
+					return filtered;
+				});
 			}
-			if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-				const cond = value;
-				const rowVal = row[key];
-				if (cond.eq !== void 0 && rowVal !== cond.eq) return false;
-				if (cond.neq !== void 0 && rowVal === cond.neq) return false;
-				if (cond.gt !== void 0 && !(rowVal > cond.gt)) return false;
-				if (cond.gte !== void 0 && !(rowVal >= cond.gte)) return false;
-				if (cond.lt !== void 0 && !(rowVal < cond.lt)) return false;
-				if (cond.lte !== void 0 && !(rowVal <= cond.lte)) return false;
-				if (cond.like !== void 0 && !String(rowVal).match(new RegExp(cond.like.replace(/%/g, ".*"), "i"))) return false;
-				if (cond.notLike !== void 0 && String(rowVal).match(new RegExp(cond.notLike.replace(/%/g, ".*"), "i"))) return false;
-				if (cond.in !== void 0 && !cond.in.includes(rowVal)) return false;
-				if (cond.notIn?.includes(rowVal)) return false;
-				if (cond.isNull === true && rowVal !== null && rowVal !== void 0) return false;
-				if (cond.isNull === false && (rowVal === null || rowVal === void 0)) return false;
-				if (cond.between !== void 0) {
-					if (rowVal < cond.between[0] || rowVal > cond.between[1]) return false;
-				}
-			} else if (row[key] !== value) return false;
+			if (options?.orderBy) {
+				const entries = Object.entries(options.orderBy);
+				rows.sort((a, b) => {
+					for (const [col, dir] of entries) {
+						const av = a[col];
+						const bv = b[col];
+						if (av < bv) return dir === "asc" ? -1 : 1;
+						if (av > bv) return dir === "asc" ? 1 : -1;
+					}
+					return 0;
+				});
+			}
+			if (options?.skip) rows = rows.slice(options.skip);
+			if (options?.take) rows = rows.slice(0, options.take);
+			return rows;
 		}
-		return true;
-	}
-	async loadRelations(rows, withOpts) {
-		if (rows.length === 0) return rows;
-		const relations = this.registry.getRelations(this.tableName);
-		for (const [relationName, opts] of Object.entries(withOpts)) {
-			if (!opts) continue;
-			const relation = relations.find((r) => r.relationName === relationName);
-			if (!relation) continue;
-			if (relation.from.table === this.tableName) {
-				const ids = rows.map((r) => r[relation.from.column]).filter((v) => v != null);
-				if (ids.length === 0) continue;
-				const uniqueIds = [...new Set(ids)];
-				const relatedOpts = typeof opts === "object" ? opts : {};
-				const related = await this.findRelated(relation.to.table, relation.to.column, uniqueIds, relatedOpts);
-				const relatedMap = /* @__PURE__ */ new Map();
-				for (const r of related) {
-					const key = r[relation.to.column];
-					if (!relatedMap.has(key)) relatedMap.set(key, []);
-					relatedMap.get(key).push(r);
-				}
-				for (const row of rows) {
-					const key = row[relation.from.column];
-					row[relationName] = relatedMap.get(key) ?? [];
+		buildFileFilter(where) {
+			return (row) => this.matchWhere(row, where);
+		}
+		matchWhere(row, where) {
+			for (const [key, value] of Object.entries(where)) {
+				if (key === "OR" && Array.isArray(value)) {
+					if (!value.some((sub) => this.matchWhere(row, sub))) return false;
+					continue;
 				}
-			} else {
-				const pk = this.registry.getPrimaryKey(this.tableName);
-				if (!pk) continue;
-				const ids = rows.map((r) => r[pk]).filter((v) => v != null);
-				if (ids.length === 0) continue;
-				const uniqueIds = [...new Set(ids)];
-				const relatedOpts = typeof opts === "object" ? opts : {};
-				const related = await this.findRelated(relation.to.table, relation.to.column, uniqueIds, relatedOpts);
-				const relatedMap = /* @__PURE__ */ new Map();
-				for (const r of related) {
-					const key = r[relation.to.column];
-					if (!relatedMap.has(key)) relatedMap.set(key, []);
-					relatedMap.get(key).push(r);
+				if (key === "AND" && Array.isArray(value)) {
+					if (!value.every((sub) => this.matchWhere(row, sub))) return false;
+					continue;
 				}
-				for (const row of rows) {
-					const key = row[pk];
-					row[relationName] = relatedMap.get(key) ?? [];
+				if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+					const cond = value;
+					const rowVal = row[key];
+					if (cond.eq !== void 0 && rowVal !== cond.eq) return false;
+					if (cond.neq !== void 0 && rowVal === cond.neq) return false;
+					if (cond.gt !== void 0 && !(rowVal > cond.gt)) return false;
+					if (cond.gte !== void 0 && !(rowVal >= cond.gte)) return false;
+					if (cond.lt !== void 0 && !(rowVal < cond.lt)) return false;
+					if (cond.lte !== void 0 && !(rowVal <= cond.lte)) return false;
+					if (cond.like !== void 0 && !String(rowVal).match(new RegExp(cond.like.replace(/%/g, ".*"), "i"))) return false;
+					if (cond.notLike !== void 0 && String(rowVal).match(new RegExp(cond.notLike.replace(/%/g, ".*"), "i"))) return false;
+					if (cond.in !== void 0 && !cond.in.includes(rowVal)) return false;
+					if (cond.notIn?.includes(rowVal)) return false;
+					if (cond.isNull === true && rowVal !== null && rowVal !== void 0) return false;
+					if (cond.isNull === false && (rowVal === null || rowVal === void 0)) return false;
+					if (cond.between !== void 0) {
+						if (rowVal < cond.between[0] || rowVal > cond.between[1]) return false;
+					}
+				} else if (row[key] !== value) return false;
+			}
+			return true;
+		}
+		async loadRelations(rows, withOpts) {
+			if (rows.length === 0) return rows;
+			const relations = this.registry.getRelations(this.tableName);
+			for (const [relationName, opts] of Object.entries(withOpts)) {
+				if (!opts) continue;
+				const relation = relations.find((r) => r.relationName === relationName);
+				if (!relation) continue;
+				if (relation.from.table === this.tableName) {
+					const ids = rows.map((r) => r[relation.from.column]).filter((v) => v != null);
+					if (ids.length === 0) continue;
+					const uniqueIds = [...new Set(ids)];
+					const relatedOpts = typeof opts === "object" ? opts : {};
+					const related = await this.findRelated(relation.to.table, relation.to.column, uniqueIds, relatedOpts);
+					const relatedMap = /* @__PURE__ */ new Map();
+					for (const r of related) {
+						const key = r[relation.to.column];
+						if (!relatedMap.has(key)) relatedMap.set(key, []);
+						relatedMap.get(key).push(r);
+					}
+					for (const row of rows) {
+						const key = row[relation.from.column];
+						row[relationName] = relatedMap.get(key) ?? [];
+					}
+				} else {
+					const pk = this.registry.getPrimaryKey(this.tableName);
+					if (!pk) continue;
+					const ids = rows.map((r) => r[pk]).filter((v) => v != null);
+					if (ids.length === 0) continue;
+					const uniqueIds = [...new Set(ids)];
+					const relatedOpts = typeof opts === "object" ? opts : {};
+					const related = await this.findRelated(relation.to.table, relation.to.column, uniqueIds, relatedOpts);
+					const relatedMap = /* @__PURE__ */ new Map();
+					for (const r of related) {
+						const key = r[relation.to.column];
+						if (!relatedMap.has(key)) relatedMap.set(key, []);
+						relatedMap.get(key).push(r);
+					}
+					for (const row of rows) {
+						const key = row[pk];
+						row[relationName] = relatedMap.get(key) ?? [];
+					}
 				}
 			}
+			return rows;
 		}
-		return rows;
-	}
-	async findRelated(tableName, column, ids, options) {
-		if (this.driver instanceof FileDriver) {
-			const fd = this.driver;
-			const filter = (row) => ids.includes(row[column]);
-			return fd.findRows(tableName, filter);
+		async findRelated(tableName, column, ids, options) {
+			if (this.driver instanceof FileDriver) {
+				const fd = this.driver;
+				const filter = (row) => ids.includes(row[column]);
+				return fd.findRows(tableName, filter);
+			}
+			const params = [];
+			const placeholders = ids.map(() => "?").join(", ");
+			params.push(...ids);
+			let sql = `SELECT * FROM \`${tableName}\` WHERE \`${column}\` IN (${placeholders})`;
+			if (options.orderBy) {
+				const orderParts = Object.entries(options.orderBy).map(([col, dir]) => `\`${col}\` ${dir.toUpperCase()}`);
+				if (orderParts.length > 0) sql += ` ORDER BY ${orderParts.join(", ")}`;
+			}
+			if (options.take) sql += ` LIMIT ${options.take}`;
+			return this.driver.query(sql, params);
 		}
-		const params = [];
-		const placeholders = ids.map(() => "?").join(", ");
-		params.push(...ids);
-		let sql = `SELECT * FROM \`${tableName}\` WHERE \`${column}\` IN (${placeholders})`;
-		if (options.orderBy) {
-			const orderParts = Object.entries(options.orderBy).map(([col, dir]) => `\`${col}\` ${dir.toUpperCase()}`);
-			if (orderParts.length > 0) sql += ` ORDER BY ${orderParts.join(", ")}`;
+		cleanData(data) {
+			const cleaned = {};
+			const dbColumnNames = new Set(this.meta.columns.map((c) => c.name));
+			const codeKeys = new Set(Object.keys(this.columnMap));
+			const shouldSerialize = !(this.driver instanceof FileDriver);
+			for (const [key, value] of Object.entries(data)) if (codeKeys.has(key) || dbColumnNames.has(key)) if (shouldSerialize && (this.jsonCodeKeys.has(key) || this.jsonColumns.has(key)) && value != null && typeof value === "object") cleaned[key] = JSON.stringify(value);
+			else cleaned[key] = value;
+			return cleaned;
 		}
-		if (options.take) sql += ` LIMIT ${options.take}`;
-		return this.driver.query(sql, params);
-	}
-	cleanData(data) {
-		const cleaned = {};
-		const dbColumnNames = new Set(this.meta.columns.map((c) => c.name));
-		const codeKeys = new Set(Object.keys(this.columnMap));
-		const shouldSerialize = !(this.driver instanceof FileDriver);
-		for (const [key, value] of Object.entries(data)) if (codeKeys.has(key) || dbColumnNames.has(key)) if (shouldSerialize && (this.jsonCodeKeys.has(key) || this.jsonColumns.has(key)) && value != null && typeof value === "object") cleaned[key] = JSON.stringify(value);
-		else cleaned[key] = value;
-		return cleaned;
-	}
-	cacheEntities(rows) {
-		const pk = this.registry.getPrimaryKey(this.tableName);
-		if (!pk) return;
-		for (const row of rows) if (row[pk] != null) this.cache.setEntity(this.tableName, row[pk], row);
-	}
-	cacheEntity(row) {
-		const pk = this.registry.getPrimaryKey(this.tableName);
-		if (!pk || row[pk] == null) return;
-		this.cache.setEntity(this.tableName, row[pk], row);
-	}
-	toDbKeys(data) {
-		if (!this.hasAliases) return data;
-		const result = {};
-		for (const [key, value] of Object.entries(data)) result[this.columnMap[key] ?? key] = value;
-		return result;
-	}
-	toCodeKeys(row) {
-		if (!this.hasAliases) return row;
-		const result = {};
-		for (const [key, value] of Object.entries(row)) result[this.reverseColumnMap[key] ?? key] = value;
-		return result;
-	}
-	mapWhereToDb(where) {
-		if (!this.hasAliases) return where;
-		const result = {};
-		for (const [key, value] of Object.entries(where)) if (key === "OR" || key === "AND") result[key] = value.map((sub) => this.mapWhereToDb(sub));
-		else result[this.columnMap[key] ?? key] = value;
-		return result;
-	}
-	mapSelectToDb(select) {
-		if (!this.hasAliases) return select;
-		return select.map((key) => this.columnMap[key] ?? key);
-	}
-	mapOrderByToDb(orderBy) {
-		if (!this.hasAliases) return orderBy;
-		const result = {};
-		for (const [key, value] of Object.entries(orderBy)) result[this.columnMap[key] ?? key] = value;
-		return result;
-	}
-	mapOptionsToDb(options) {
-		if (!options || !this.hasAliases) return options;
-		const mapped = { ...options };
-		if (options.where) mapped.where = this.mapWhereToDb(options.where);
-		if (options.select) mapped.select = this.mapSelectToDb(options.select);
-		if (options.orderBy) mapped.orderBy = this.mapOrderByToDb(options.orderBy);
-		return mapped;
-	}
-	mapRows(rows) {
-		const shouldDeserialize = this.jsonCodeKeys.size > 0 && !(this.driver instanceof FileDriver);
-		if (!this.hasAliases && !shouldDeserialize) return rows;
-		return rows.map((row) => {
-			const mapped = this.hasAliases ? this.toCodeKeys(row) : { ...row };
-			if (shouldDeserialize) for (const key of this.jsonCodeKeys) {
-				const val = mapped[key];
-				if (typeof val === "string") try {
-					mapped[key] = JSON.parse(val);
-				} catch {}
-			}
+		cacheEntities(rows) {
+			const pk = this.registry.getPrimaryKey(this.tableName);
+			if (!pk) return;
+			for (const row of rows) if (row[pk] != null) this.cache.setEntity(this.tableName, row[pk], row);
+		}
+		cacheEntity(row) {
+			const pk = this.registry.getPrimaryKey(this.tableName);
+			if (!pk || row[pk] == null) return;
+			this.cache.setEntity(this.tableName, row[pk], row);
+		}
+		toDbKeys(data) {
+			if (!this.hasAliases) return data;
+			const result = {};
+			for (const [key, value] of Object.entries(data)) result[this.columnMap[key] ?? key] = value;
+			return result;
+		}
+		toCodeKeys(row) {
+			if (!this.hasAliases) return row;
+			const result = {};
+			for (const [key, value] of Object.entries(row)) result[this.reverseColumnMap[key] ?? key] = value;
+			return result;
+		}
+		mapWhereToDb(where) {
+			if (!this.hasAliases) return where;
+			const result = {};
+			for (const [key, value] of Object.entries(where)) if (key === "OR" || key === "AND") result[key] = value.map((sub) => this.mapWhereToDb(sub));
+			else result[this.columnMap[key] ?? key] = value;
+			return result;
+		}
+		mapSelectToDb(select) {
+			if (!this.hasAliases) return select;
+			return select.map((key) => this.columnMap[key] ?? key);
+		}
+		mapOrderByToDb(orderBy) {
+			if (!this.hasAliases) return orderBy;
+			const result = {};
+			for (const [key, value] of Object.entries(orderBy)) result[this.columnMap[key] ?? key] = value;
+			return result;
+		}
+		mapOptionsToDb(options) {
+			if (!options || !this.hasAliases) return options;
+			const mapped = { ...options };
+			if (options.where) mapped.where = this.mapWhereToDb(options.where);
+			if (options.select) mapped.select = this.mapSelectToDb(options.select);
+			if (options.orderBy) mapped.orderBy = this.mapOrderByToDb(options.orderBy);
 			return mapped;
-		});
-	}
-};
+		}
+		mapRows(rows) {
+			const shouldDeserialize = this.jsonCodeKeys.size > 0 && !(this.driver instanceof FileDriver);
+			if (!this.hasAliases && !shouldDeserialize) return rows;
+			return rows.map((row) => {
+				const mapped = this.hasAliases ? this.toCodeKeys(row) : { ...row };
+				if (shouldDeserialize) for (const key of this.jsonCodeKeys) {
+					const val = mapped[key];
+					if (typeof val === "string") try {
+						mapped[key] = JSON.parse(val);
+					} catch {}
+				}
+				return mapped;
+			});
+		}
+	};
+}));
 //#endregion
-export { TableRepository };
+init_repository();
+export { TableRepository, init_repository };
 
 //# sourceMappingURL=repository.mjs.map