@danceroutine/tango-orm 1.4.0 → 1.6.0

package/dist/query-CWZ1cfjo.js

@@ -1,856 +0,0 @@
-import { __export } from "./chunk-DLY2FNSh.js";
-import { SqlSafetyEngine } from "@danceroutine/tango-core";
-
-//#region src/query/domain/internal/InternalRelationKind.ts
-const InternalRelationKind = {
-	HAS_MANY: "hasMany",
-	BELONGS_TO: "belongsTo",
-	HAS_ONE: "hasOne",
-	MANY_TO_MANY: "manyToMany"
-};
-
-//#endregion
-//#region src/query/domain/internal/InternalDialect.ts
-const InternalDialect = {
-	POSTGRES: "postgres",
-	SQLITE: "sqlite"
-};
-
-//#endregion
-//#region src/query/domain/internal/InternalQNodeType.ts
-const InternalQNodeType = {
-	ATOM: "atom",
-	AND: "and",
-	OR: "or",
-	NOT: "not"
-};
-
-//#endregion
-//#region src/query/domain/internal/InternalLookupType.ts
-const InternalLookupType = {
-	EXACT: "exact",
-	LT: "lt",
-	LTE: "lte",
-	GT: "gt",
-	GTE: "gte",
-	IN: "in",
-	ISNULL: "isnull",
-	CONTAINS: "contains",
-	ICONTAINS: "icontains",
-	STARTSWITH: "startswith",
-	ISTARTSWITH: "istartswith",
-	ENDSWITH: "endswith",
-	IENDSWITH: "iendswith"
-};
-
-//#endregion
-//#region src/validation/OrmSqlSafetyAdapter.ts
-const ALLOWED_LOOKUPS = Object.values(InternalLookupType);
-var OrmSqlSafetyAdapter = class OrmSqlSafetyAdapter {
-	static BRAND = "tango.orm.orm_sql_safety_adapter";
-	__tangoBrand = OrmSqlSafetyAdapter.BRAND;
-	constructor(engine = new SqlSafetyEngine()) {
-		this.engine = engine;
-	}
-	validate(plan) {
-		switch (plan.kind) {
-			case "select": {
-				const meta = this.validateTableMeta(plan.meta, plan.relationNames ?? []);
-				return {
-					kind: "select",
-					meta,
-					selectFields: Object.fromEntries((plan.selectFields ?? []).map((field) => [field, `${meta.table}.${this.resolveColumn(meta, field)}`])),
-					filterKeys: Object.fromEntries((plan.filterKeys ?? []).map((rawKey) => [rawKey, this.validateFilterKey(meta, rawKey)])),
-					orderFields: Object.fromEntries((plan.orderFields ?? []).map((field) => [field, `${meta.table}.${this.resolveColumn(meta, field)}`])),
-					relations: Object.fromEntries((plan.relationNames ?? []).map((relationName) => [relationName, this.resolveRelation(meta, relationName)]))
-				};
-			}
-			case "insert": {
-				const meta = this.validateTableMeta(plan.meta);
-				return {
-					kind: "insert",
-					meta,
-					writeKeys: plan.writeKeys.map((key) => this.resolveColumn(meta, key))
-				};
-			}
-			case "update": {
-				const meta = this.validateTableMeta(plan.meta);
-				return {
-					kind: "update",
-					meta,
-					writeKeys: plan.writeKeys.map((key) => this.resolveColumn(meta, key))
-				};
-			}
-			case "delete": return {
-				kind: "delete",
-				meta: this.validateTableMeta(plan.meta)
-			};
-		}
-	}
-	validateTableMeta(meta, relationNames = []) {
-		const columnNames = Object.keys(meta.columns);
-		const validated = this.engine.validate({ identifiers: [
-			{
-				key: "table",
-				role: "table",
-				value: meta.table
-			},
-			{
-				key: "pk",
-				role: "primaryKey",
-				value: meta.pk,
-				allowlist: columnNames
-			},
-			...columnNames.map((column) => ({
-				key: `column:${column}`,
-				role: "column",
-				value: column
-			}))
-		] });
-		const validatedMeta = {
-			table: validated.identifiers.table.value,
-			pk: validated.identifiers.pk.value,
-			columns: Object.fromEntries(columnNames.map((column) => [validated.identifiers[`column:${column}`].value, meta.columns[column]]))
-		};
-		if (!(validatedMeta.pk in validatedMeta.columns)) throw new Error(`Unknown column '${validatedMeta.pk}' for table '${validatedMeta.table}'.`);
-		if (relationNames.length > 0) validatedMeta.relations = Object.fromEntries(relationNames.map((relationName) => [relationName, this.validateRelationMeta(validatedMeta, relationName, meta.relations)]));
-		return validatedMeta;
-	}
-	validateRelationMeta(meta, relationName, relations) {
-		const relation = relations?.[relationName];
-		if (!relation) throw new Error(`Unknown relation '${relationName}' for table '${meta.table}'.`);
-		if (!(relation.targetKey in relation.targetColumns)) throw new Error(`Unknown relation target key '${relation.targetKey}' for relation '${relationName}'.`);
-		const validated = this.engine.validate({ identifiers: [
-			{
-				key: "table",
-				role: "relationTable",
-				value: relation.table
-			},
-			{
-				key: "alias",
-				role: "alias",
-				value: relation.alias
-			},
-			{
-				key: "targetKey",
-				role: "relationTargetPrimaryKey",
-				value: relation.targetKey
-			},
-			...Object.keys(relation.targetColumns).map((column) => ({
-				key: `targetColumn:${column}`,
-				role: "column",
-				value: column
-			}))
-		] });
-		return {
-			...relation,
-			table: validated.identifiers.table.value,
-			alias: validated.identifiers.alias.value,
-			sourceKey: this.resolveColumn(meta, relation.sourceKey),
-			targetKey: validated.identifiers.targetKey.value,
-			targetColumns: Object.fromEntries(Object.keys(relation.targetColumns).map((column) => [validated.identifiers[`targetColumn:${column}`].value, relation.targetColumns[column]]))
-		};
-	}
-	validateFilterKey(meta, rawKey) {
-		const segments = rawKey.split("__");
-		if (segments.length > 2) throw new Error(`Invalid SQL lookup key: '${rawKey}'.`);
-		const field = segments[0];
-		const lookup = segments[1] ?? InternalLookupType.EXACT;
-		const validated = this.engine.validate({ lookupTokens: [{
-			key: rawKey,
-			lookup,
-			allowed: ALLOWED_LOOKUPS
-		}] });
-		return {
-			rawKey,
-			field,
-			lookup: validated.lookupTokens[rawKey].lookup,
-			qualifiedColumn: `${meta.table}.${this.resolveColumn(meta, field)}`
-		};
-	}
-	resolveColumn(meta, field) {
-		if (!(field in meta.columns)) throw new Error(`Unknown column '${field}' for table '${meta.table}'.`);
-		return field;
-	}
-	resolveRelation(meta, relationName) {
-		const relation = meta.relations?.[relationName];
-		if (!relation) throw new Error(`Unknown relation '${relationName}' for table '${meta.table}'.`);
-		return relation;
-	}
-};
-
-//#endregion
-//#region src/query/compiler/QueryCompiler.ts
-const sqlSafetyAdapter = new OrmSqlSafetyAdapter();
-var QueryCompiler = class QueryCompiler {
-	static BRAND = "tango.orm.query_compiler";
-	__tangoBrand = QueryCompiler.BRAND;
-	/**
-	* Build a compiler for the given repository metadata and SQL dialect.
-	*/
-	constructor(meta, dialect = InternalDialect.POSTGRES) {
-		this.meta = meta;
-		this.dialect = dialect;
-	}
-	/**
-	* Narrow an unknown value to `QueryCompiler`.
-	*/
-	static isQueryCompiler(value) {
-		return typeof value === "object" && value !== null && value.__tangoBrand === QueryCompiler.BRAND;
-	}
-	/**
-	* Compile a query state tree into a SQL statement and bound parameters.
-	*/
-	compile(state) {
-		const selectRelationNames = state.selectRelated ?? [];
-		const prefetchRelationNames = state.prefetchRelated ?? [];
-		const relationNames = [...new Set([...selectRelationNames, ...prefetchRelationNames])];
-		const validatedPlan = sqlSafetyAdapter.validate({
-			kind: "select",
-			meta: this.meta,
-			selectFields: state.select?.map(String),
-			filterKeys: this.collectStateFilterKeys(state),
-			orderFields: state.order?.map((order) => String(order.by)),
-			relationNames
-		});
-		const table = validatedPlan.meta.table;
-		const whereParts = [];
-		const params = [];
-		if (state.q) {
-			const result = this.compileQNode(state.q, params.length + 1, validatedPlan.filterKeys);
-			if (result.sql) {
-				whereParts.push(result.sql);
-				params.push(...result.params);
-			}
-		}
-		state.excludes?.forEach((exclude) => {
-			const result = this.compileQNode({
-				kind: InternalQNodeType.NOT,
-				node: exclude
-			}, params.length + 1, validatedPlan.filterKeys);
-			if (result.sql) {
-				whereParts.push(result.sql);
-				params.push(...result.params);
-			}
-		});
-		const baseSelect = state.select?.length ? state.select.map((field) => validatedPlan.selectFields[String(field)]).join(", ") : `${table}.*`;
-		const relationSelects = selectRelationNames.flatMap((relationName) => {
-			const relation = validatedPlan.relations[relationName];
-			return Object.keys(relation.targetColumns).map((column) => `${relation.alias}.${column} AS ${this.buildHydrationColumnAlias(relation.alias, column)}`);
-		});
-		const prefetchSourceSelects = state.select?.length && prefetchRelationNames.length ? prefetchRelationNames.map((relationName) => validatedPlan.relations[relationName]).filter((relation) => !state.select.map(String).includes(relation.sourceKey)).map((relation) => `${table}.${relation.sourceKey} AS ${this.buildPrefetchSourceAlias(relation.sourceKey)}`) : [];
-		const select = [
-			baseSelect,
-			...relationSelects,
-			...prefetchSourceSelects
-		].join(", ");
-		const joins = selectRelationNames.map((rel) => {
-			const relation = validatedPlan.relations[rel];
-			if (relation.kind !== InternalRelationKind.BELONGS_TO && relation.kind !== InternalRelationKind.HAS_ONE) throw new Error(`Relation '${rel}' cannot be loaded with selectRelated(...).`);
-			return `LEFT JOIN ${relation.table} ${relation.alias} ON ${relation.alias}.${relation.targetKey} = ${table}.${relation.sourceKey}`;
-		}).filter(Boolean).join(" ");
-		for (const rel of prefetchRelationNames) {
-			const relation = validatedPlan.relations[rel];
-			if (relation?.kind !== InternalRelationKind.HAS_MANY) throw new Error(`Relation '${rel}' cannot be loaded with prefetchRelated(...).`);
-		}
-		const whereSQL = whereParts.length ? ` WHERE ${whereParts.join(" AND ")}` : "";
-		const orderSQL = ` ORDER BY ${state.order?.length ? state.order.map((order) => `${validatedPlan.orderFields[String(order.by)]} ${order.dir.toUpperCase()}`).join(", ") : `${table}.${validatedPlan.meta.pk} ASC`}`;
-		const limitSQL = state.limit ? ` LIMIT ${state.limit}` : "";
-		const offsetSQL = state.offset ? ` OFFSET ${state.offset}` : "";
-		const sql = `SELECT ${select} FROM ${table}${joins ? ` ${joins}` : ""}${whereSQL}${orderSQL}${limitSQL}${offsetSQL}`;
-		return {
-			sql,
-			params,
-			hydrations: selectRelationNames.map((relationName) => {
-				const relation = validatedPlan.relations[relationName];
-				return {
-					relationName,
-					alias: relation.alias,
-					columns: Object.fromEntries(Object.keys(relation.targetColumns).map((column) => [column, this.buildHydrationColumnAlias(relation.alias, column)]))
-				};
-			}),
-			prefetches: prefetchRelationNames.map((relationName) => {
-				const relation = validatedPlan.relations[relationName];
-				const needsAlias = !!state.select?.length && !state.select.map(String).includes(relation.sourceKey);
-				return {
-					relationName,
-					sourceKey: relation.sourceKey,
-					sourceKeyAlias: needsAlias ? this.buildPrefetchSourceAlias(relation.sourceKey) : undefined,
-					table: relation.table,
-					targetKey: relation.targetKey,
-					targetColumns: relation.targetColumns
-				};
-			})
-		};
-	}
-	/**
-	* Compile the follow-up query used by `prefetchRelated(...)`.
-	*
-	* The base query cannot bind source values until after it has returned rows,
-	* but SQL rendering and validation still belong to the compiler.
-	*/
-	compilePrefetch(prefetch, sourceValues) {
-		const validatedPlan = sqlSafetyAdapter.validate({
-			kind: "select",
-			meta: this.meta,
-			relationNames: [prefetch.relationName]
-		});
-		const relation = validatedPlan.relations[prefetch.relationName];
-		const compiledTargetColumns = Object.keys(prefetch.targetColumns).sort();
-		const validatedTargetColumns = Object.keys(relation.targetColumns).sort();
-		const compiledMatchesValidated = prefetch.sourceKey === relation.sourceKey && prefetch.table === relation.table && prefetch.targetKey === relation.targetKey && compiledTargetColumns.length === validatedTargetColumns.length && compiledTargetColumns.every((column, index) => column === validatedTargetColumns[index] && prefetch.targetColumns[column] === relation.targetColumns[column]);
-		if (!compiledMatchesValidated) throw new Error(`Compiled prefetch metadata for relation '${prefetch.relationName}' failed validation.`);
-		const columns = Object.keys(relation.targetColumns);
-		const placeholders = this.dialect === InternalDialect.POSTGRES ? sourceValues.map((_, index) => `$${index + 1}`).join(", ") : sourceValues.map(() => "?").join(", ");
-		return {
-			sql: `SELECT ${columns.join(", ")} FROM ${relation.table} WHERE ${relation.targetKey} IN (${placeholders}) ORDER BY ${relation.targetKey} ASC`,
-			params: sourceValues,
-			targetKey: relation.targetKey,
-			targetColumns: relation.targetColumns
-		};
-	}
-	buildHydrationColumnAlias(alias, column) {
-		return this.assertInternalAliasDoesNotCollide(`__tango_hydrate_${alias}_${column}`);
-	}
-	buildPrefetchSourceAlias(sourceKey) {
-		return this.assertInternalAliasDoesNotCollide(`__tango_prefetch_${sourceKey}`);
-	}
-	assertInternalAliasDoesNotCollide(alias) {
-		if (alias in this.meta.columns) throw new Error(`Internal query alias '${alias}' collides with a field on table '${this.meta.table}'.`);
-		return alias;
-	}
-	compileQNode(node, paramIndex, filterKeys) {
-		switch (node.kind) {
-			case InternalQNodeType.ATOM: return this.compileAtom(node.where || {}, paramIndex, filterKeys);
-			case InternalQNodeType.AND: return this.compileAnd(node.nodes || [], paramIndex, filterKeys);
-			case InternalQNodeType.OR: return this.compileOr(node.nodes || [], paramIndex, filterKeys);
-			case InternalQNodeType.NOT: return this.compileNot(node.node, paramIndex, filterKeys);
-			default: return {
-				sql: "",
-				params: []
-			};
-		}
-	}
-	compileAtom(where, paramIndex, filterKeys) {
-		const entries = Object.entries(where).filter(([, value]) => value !== undefined);
-		const { parts, params } = entries.reduce((accumulator, [key, value]) => {
-			const descriptor = filterKeys[String(key)];
-			const idx = paramIndex + accumulator.params.length;
-			const clause = this.lookupToSQL(descriptor.qualifiedColumn, descriptor.lookup, value, idx);
-			accumulator.parts.push(clause.sql);
-			accumulator.params.push(...clause.params);
-			return accumulator;
-		}, {
-			parts: [],
-			params: []
-		});
-		return {
-			sql: parts.length ? `(${parts.join(" AND ")})` : "",
-			params
-		};
-	}
-	compileAnd(nodes, paramIndex, filterKeys) {
-		const { parts, params } = nodes.reduce((accumulator, node) => {
-			const result = this.compileQNode(node, paramIndex + accumulator.params.length, filterKeys);
-			if (result.sql) {
-				accumulator.parts.push(result.sql);
-				accumulator.params.push(...result.params);
-			}
-			return accumulator;
-		}, {
-			parts: [],
-			params: []
-		});
-		return {
-			sql: parts.length ? `(${parts.join(" AND ")})` : "",
-			params
-		};
-	}
-	compileOr(nodes, paramIndex, filterKeys) {
-		const { parts, params } = nodes.reduce((accumulator, node) => {
-			const result = this.compileQNode(node, paramIndex + accumulator.params.length, filterKeys);
-			if (result.sql) {
-				accumulator.parts.push(result.sql);
-				accumulator.params.push(...result.params);
-			}
-			return accumulator;
-		}, {
-			parts: [],
-			params: []
-		});
-		return {
-			sql: parts.length ? `(${parts.join(" OR ")})` : "",
-			params
-		};
-	}
-	compileNot(node, paramIndex, filterKeys) {
-		const result = this.compileQNode(node, paramIndex, filterKeys);
-		if (!result.sql) return {
-			sql: "",
-			params: []
-		};
-		return {
-			sql: `(NOT ${result.sql})`,
-			params: result.params
-		};
-	}
-	lookupToSQL(col, lookup, value, paramIndex) {
-		const placeholder = this.dialect === InternalDialect.POSTGRES ? `$${paramIndex}` : "?";
-		const normalized = this.normalizeParam(value);
-		switch (lookup) {
-			case InternalLookupType.EXACT:
-				if (value === null) return {
-					sql: `${col} IS NULL`,
-					params: []
-				};
-				return {
-					sql: `${col} = ${placeholder}`,
-					params: [normalized]
-				};
-			case InternalLookupType.LT: return {
-				sql: `${col} < ${placeholder}`,
-				params: [normalized]
-			};
-			case InternalLookupType.LTE: return {
-				sql: `${col} <= ${placeholder}`,
-				params: [normalized]
-			};
-			case InternalLookupType.GT: return {
-				sql: `${col} > ${placeholder}`,
-				params: [normalized]
-			};
-			case InternalLookupType.GTE: return {
-				sql: `${col} >= ${placeholder}`,
-				params: [normalized]
-			};
-			case InternalLookupType.IN: {
-				const entries = (Array.isArray(value) ? value : [value]).map((entry) => this.normalizeParam(entry));
-				if (entries.length === 0) return {
-					sql: "1=0",
-					params: []
-				};
-				const placeholders = this.dialect === InternalDialect.POSTGRES ? entries.map((_, index) => `$${paramIndex + index}`).join(", ") : entries.map(() => "?").join(", ");
-				return {
-					sql: `${col} IN (${placeholders})`,
-					params: entries
-				};
-			}
-			case InternalLookupType.ISNULL: return {
-				sql: value ? `${col} IS NULL` : `${col} IS NOT NULL`,
-				params: []
-			};
-			case InternalLookupType.CONTAINS: return {
-				sql: `${col} LIKE ${placeholder}`,
-				params: [`%${value}%`]
-			};
-			case InternalLookupType.ICONTAINS: {
-				const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
-				return {
-					sql: `${lowerCol} LIKE ${placeholder}`,
-					params: [`%${String(value).toLowerCase()}%`]
-				};
-			}
-			case InternalLookupType.STARTSWITH: return {
-				sql: `${col} LIKE ${placeholder}`,
-				params: [`${value}%`]
-			};
-			case InternalLookupType.ISTARTSWITH: {
-				const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
-				return {
-					sql: `${lowerCol} LIKE ${placeholder}`,
-					params: [`${String(value).toLowerCase()}%`]
-				};
-			}
-			case InternalLookupType.ENDSWITH: return {
-				sql: `${col} LIKE ${placeholder}`,
-				params: [`%${value}`]
-			};
-			case InternalLookupType.IENDSWITH: {
-				const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
-				return {
-					sql: `${lowerCol} LIKE ${placeholder}`,
-					params: [`%${String(value).toLowerCase()}`]
-				};
-			}
-			default: throw new Error(`Unknown lookup: ${lookup}`);
-		}
-	}
-	normalizeParam(value) {
-		if (this.dialect === InternalDialect.SQLITE && typeof value === "boolean") return value ? 1 : 0;
-		return value;
-	}
-	collectStateFilterKeys(state) {
-		const filterKeys = new Set();
-		if (state.q) this.collectNodeFilterKeys(state.q, filterKeys);
-		state.excludes?.forEach((exclude) => this.collectNodeFilterKeys(exclude, filterKeys));
-		return [...filterKeys];
-	}
-	collectNodeFilterKeys(node, filterKeys) {
-		Object.keys(node.where ?? {}).forEach((key) => filterKeys.add(key));
-		node.nodes?.forEach((child) => this.collectNodeFilterKeys(child, filterKeys));
-		if (node.node) this.collectNodeFilterKeys(node.node, filterKeys);
-	}
-};
-
-//#endregion
-//#region src/query/compiler/index.ts
-var compiler_exports = {};
-__export(compiler_exports, { QueryCompiler: () => QueryCompiler });
-
-//#endregion
-//#region src/query/domain/RelationTyping.ts
-const InternalRelationHydrationCardinality = {
-	SINGLE: "single",
-	MANY: "many"
-};
-
-//#endregion
-//#region src/query/domain/index.ts
-var domain_exports = {};
-__export(domain_exports, { InternalRelationHydrationCardinality: () => InternalRelationHydrationCardinality });
-
-//#endregion
-//#region src/query/domain/internal/InternalDirection.ts
-const InternalDirection = {
-	ASC: "asc",
-	DESC: "desc"
-};
-
-//#endregion
-//#region src/query/QBuilder.ts
-var QBuilder = class QBuilder {
-	static BRAND = "tango.orm.q_builder";
-	__tangoBrand = QBuilder.BRAND;
-	/**
-	* Narrow an unknown value to `QBuilder`.
-	*/
-	static isQBuilder(value) {
-		return typeof value === "object" && value !== null && value.__tangoBrand === QBuilder.BRAND;
-	}
-	/**
-	* Combine multiple filter fragments using logical `AND`.
-	*/
-	static and(...nodes) {
-		return {
-			kind: InternalQNodeType.AND,
-			nodes: nodes.map(QBuilder.wrapNode)
-		};
-	}
-	/**
-	* Combine multiple filter fragments using logical `OR`.
-	*/
-	static or(...nodes) {
-		return {
-			kind: InternalQNodeType.OR,
-			nodes: nodes.map(QBuilder.wrapNode)
-		};
-	}
-	/**
-	* Negate a filter fragment using logical `NOT`.
-	*/
-	static not(node) {
-		return {
-			kind: InternalQNodeType.NOT,
-			node: QBuilder.wrapNode(node)
-		};
-	}
-	static wrapNode(input) {
-		if (input.kind) return input;
-		return {
-			kind: InternalQNodeType.ATOM,
-			where: input
-		};
-	}
-};
-
-//#endregion
-//#region src/query/QuerySet.ts
-var QuerySet = class QuerySet {
-	static BRAND = "tango.orm.query_set";
-	__tangoBrand = QuerySet.BRAND;
-	constructor(executor, state = {}) {
-		this.executor = executor;
-		this.state = state;
-	}
-	/**
-	* Narrow an unknown value to `QuerySet`.
-	*/
-	static isQuerySet(value) {
-		return typeof value === "object" && value !== null && value.__tangoBrand === QuerySet.BRAND;
-	}
-	/**
-	* Add a filter expression to the query.
-	*
-	* Multiple `filter()` calls are composed with `AND`.
-	*/
-	filter(q) {
-		const wrapped = q.kind ? q : {
-			kind: InternalQNodeType.ATOM,
-			where: q
-		};
-		const merged = this.state.q ? QBuilder.and(this.state.q, wrapped) : wrapped;
-		return new QuerySet(this.executor, {
-			...this.state,
-			q: merged
-		});
-	}
-	/**
-	* Add an exclusion expression to the query.
-	*
-	* Exclusions are translated to `NOT (...)` predicates.
-	*/
-	exclude(q) {
-		const wrapped = q.kind ? q : {
-			kind: InternalQNodeType.ATOM,
-			where: q
-		};
-		const excludes = [...this.state.excludes ?? [], wrapped];
-		return new QuerySet(this.executor, {
-			...this.state,
-			excludes
-		});
-	}
-	/**
-	* Apply ordering tokens such as `'name'` or `'-createdAt'`.
-	*/
-	orderBy(...tokens) {
-		const order = tokens.map((t) => {
-			const str = String(t);
-			if (str.startsWith("-")) return {
-				by: str.slice(1),
-				dir: InternalDirection.DESC
-			};
-			return {
-				by: t,
-				dir: InternalDirection.ASC
-			};
-		});
-		return new QuerySet(this.executor, {
-			...this.state,
-			order
-		});
-	}
-	/**
-	* Limit the maximum number of rows returned.
-	*/
-	limit(n) {
-		return new QuerySet(this.executor, {
-			...this.state,
-			limit: n
-		});
-	}
-	/**
-	* Skip the first `n` rows.
-	*/
-	offset(n) {
-		return new QuerySet(this.executor, {
-			...this.state,
-			offset: n
-		});
-	}
-	select(fields) {
-		return new QuerySet(this.executor, {
-			...this.state,
-			select: [...fields]
-		});
-	}
-	/**
-	* Hydrate single-valued relations through SQL joins.
-	*
-	* Forward `belongsTo` relations can be inferred from the source model's
-	* field-authored relation metadata. Reverse `hasOne` relations can be
-	* selected with a target model generic when the target model points back to
-	* the source model.
-	*/
-	selectRelated(...rels) {
-		return new QuerySet(this.executor, {
-			...this.state,
-			selectRelated: [...rels]
-		});
-	}
-	/**
-	* Hydrate collection relations with a follow-up query.
-	*
-	* Reverse `hasMany` relations can be prefetched with a target model generic
-	* when the target model points back to the source model.
-	*/
-	prefetchRelated(...rels) {
-		return new QuerySet(this.executor, {
-			...this.state,
-			prefetchRelated: [...rels]
-		});
-	}
-	async fetch(shape) {
-		this.validateHydrationState();
-		const compiler = new QueryCompiler(this.executor.meta, this.executor.dialect);
-		const compiled = compiler.compile(this.state);
-		const rows = await this.executor.run(compiled);
-		const normalizedRows = this.normalizeRowsForSchemaParsing(rows, shape);
-		const hydratedRows = await this.hydrateRows(normalizedRows, compiled);
-		const projectedRows = hydratedRows;
-		const results = !shape ? projectedRows : typeof shape === "function" ? projectedRows.map(shape) : projectedRows.map((r) => shape.parse(r));
-		return {
-			results,
-			nextCursor: null
-		};
-	}
-	async fetchOne(shape) {
-		const limited = this.limit(1);
-		const result = !shape ? await limited.fetch() : typeof shape === "function" ? await limited.fetch(shape) : await limited.fetch(shape);
-		return result.results[0] ?? null;
-	}
-	/**
-	* Execute a `COUNT(*)` query for the current filtered state.
-	*/
-	async count() {
-		this.validateHydrationState();
-		const compiler = new QueryCompiler(this.executor.meta, this.executor.dialect);
-		const compiled = compiler.compile(this.state);
-		const countQuery = `SELECT COUNT(*) as count FROM (${compiled.sql}) AS tango_count_subquery`;
-		const rows = await this.executor.client.query(countQuery, compiled.params);
-		return Number(rows.rows[0]?.count ?? 0);
-	}
-	/**
-	* Return whether at least one row matches the current query state.
-	*/
-	async exists() {
-		const count = await this.count();
-		return count > 0;
-	}
-	normalizeRowsForSchemaParsing(rows, shape) {
-		if (!shape || typeof shape === "function" || this.executor.dialect !== InternalDialect.SQLITE) return rows;
-		const booleanColumns = Object.entries(this.executor.meta.columns).filter(([, value]) => this.isBooleanColumnType(value)).map(([column]) => column);
-		if (booleanColumns.length === 0) return rows;
-		return rows.map((row) => this.normalizeBooleanColumns(row, booleanColumns));
-	}
-	validateHydrationState() {
-		const seen = new Set();
-		for (const relationName of [...this.state.selectRelated ?? [], ...this.state.prefetchRelated ?? []]) {
-			if (seen.has(relationName)) throw new Error(`Relation '${relationName}' was requested more than once.`);
-			seen.add(relationName);
-			const relation = this.executor.meta.relations?.[relationName];
-			if (!relation) throw new Error(`Unknown relation '${relationName}' for table '${this.executor.meta.table}'.`);
-			if (relation.kind === InternalRelationKind.MANY_TO_MANY) throw new Error(`Relation '${relationName}' is many-to-many and cannot be hydrated yet.`);
-			if (relationName in this.executor.meta.columns && !(relation.kind === InternalRelationKind.BELONGS_TO && relationName === relation.sourceKey)) throw new Error(`Relation '${relationName}' on table '${this.executor.meta.table}' collides with an existing field.`);
-		}
-		for (const relationName of this.state.selectRelated ?? []) {
-			const relation = this.executor.meta.relations[relationName];
-			if (relation.kind !== InternalRelationKind.BELONGS_TO && relation.kind !== InternalRelationKind.HAS_ONE) throw new Error(`Relation '${relationName}' cannot be loaded with selectRelated(...).`);
-		}
-		for (const relationName of this.state.prefetchRelated ?? []) {
-			const relation = this.executor.meta.relations[relationName];
-			if (relation.kind !== InternalRelationKind.HAS_MANY) throw new Error(`Relation '${relationName}' cannot be loaded with prefetchRelated(...).`);
-		}
-	}
-	async hydrateRows(rows, compiled) {
-		const selectedRows = this.hydrateSelectedRows(rows, compiled);
-		return this.hydratePrefetchedRows(selectedRows, compiled);
-	}
-	hydrateSelectedRows(rows, compiled) {
-		const hydrations = compiled.hydrations;
-		if (!hydrations?.length) return rows;
-		return rows.map((row) => {
-			const next = { ...row };
-			for (const hydration of hydrations) {
-				const target = {};
-				let hasTargetValue = false;
-				for (const [column, alias] of Object.entries(hydration.columns)) {
-					const value = next[alias];
-					delete next[alias];
-					target[column] = this.normalizeTargetValue(hydration.relationName, column, value);
-					if (value !== null && value !== undefined) hasTargetValue = true;
-				}
-				next[hydration.relationName] = hasTargetValue ? target : null;
-			}
-			return next;
-		});
-	}
-	async hydratePrefetchedRows(rows, compiled) {
-		if (!compiled.prefetches?.length || rows.length === 0) return rows;
-		const prefetchGroups = await Promise.all(compiled.prefetches.map(async (prefetch) => {
-			const sourceValues = rows.map((row) => row[prefetch.sourceKeyAlias ?? prefetch.sourceKey]).filter((value) => typeof value === "string" || typeof value === "number");
-			const uniqueSourceValues = [...new Set(sourceValues)];
-			return {
-				prefetch,
-				grouped: await this.fetchPrefetchGroup(prefetch, uniqueSourceValues)
-			};
-		}));
-		const hiddenSourceAliases = new Set(compiled.prefetches.map((prefetch) => prefetch.sourceKeyAlias).filter((alias) => typeof alias === "string"));
-		return rows.map((row) => {
-			const next = { ...row };
-			for (const { prefetch, grouped } of prefetchGroups) {
-				const sourceValue = row[prefetch.sourceKeyAlias ?? prefetch.sourceKey];
-				next[prefetch.relationName] = typeof sourceValue === "string" || typeof sourceValue === "number" ? grouped.get(sourceValue) ?? [] : [];
-			}
-			for (const alias of hiddenSourceAliases) delete next[alias];
-			return next;
-		});
-	}
-	async fetchPrefetchGroup(prefetch, sourceValues) {
-		const compiledPrefetch = new QueryCompiler(this.executor.meta, this.executor.dialect).compilePrefetch(prefetch, sourceValues);
-		const grouped = new Map();
-		if (sourceValues.length === 0) return grouped;
-		const result = await this.executor.client.query(compiledPrefetch.sql, compiledPrefetch.params);
-		for (const row of result.rows) {
-			const normalized = this.normalizeTargetRow(compiledPrefetch, row);
-			const key = normalized[compiledPrefetch.targetKey];
-			if (typeof key !== "string" && typeof key !== "number") continue;
-			const bucket = grouped.get(key) ?? [];
-			bucket.push(normalized);
-			grouped.set(key, bucket);
-		}
-		return grouped;
-	}
-	normalizeTargetRow(prefetch, row) {
-		if (this.executor.dialect !== InternalDialect.SQLITE) return row;
-		let normalized = null;
-		for (const [column, type] of Object.entries(prefetch.targetColumns)) {
-			if (!this.isBooleanColumnType(type)) continue;
-			const next = this.normalizeSqliteBoolean(row[column]);
-			if (next === row[column]) continue;
-			normalized ??= { ...row };
-			normalized[column] = next;
-		}
-		return normalized ?? row;
-	}
-	normalizeTargetValue(relationName, column, value) {
-		if (this.executor.dialect !== InternalDialect.SQLITE) return value;
-		const relation = this.executor.meta.relations[relationName];
-		return this.isBooleanColumnType(relation.targetColumns[column]) ? this.normalizeSqliteBoolean(value) : value;
-	}
-	isBooleanColumnType(value) {
-		return typeof value === "string" && ["bool", "boolean"].includes(value.trim().toLowerCase());
-	}
-	normalizeSqliteBoolean(value) {
-		if (value === 0 || value === "0") return false;
-		if (value === 1 || value === "1") return true;
-		return value;
-	}
-	normalizeBooleanColumns(row, columns) {
-		let normalized = null;
-		for (const column of columns) {
-			const current = row[column];
-			const next = this.normalizeSqliteBoolean(current);
-			if (next === current) continue;
-			if (!normalized) normalized = { ...row };
-			normalized[column] = next;
-		}
-		return normalized ?? row;
-	}
-};
-
-//#endregion
-//#region src/query/index.ts
-var query_exports = {};
-__export(query_exports, {
-	Q: () => QBuilder,
-	QBuilder: () => QBuilder,
-	QueryCompiler: () => QueryCompiler,
-	QuerySet: () => QuerySet,
-	compiler: () => compiler_exports,
-	domain: () => domain_exports
-});
-
-//#endregion
-export { InternalRelationKind, OrmSqlSafetyAdapter, QBuilder, QueryCompiler, QuerySet, compiler_exports, domain_exports, query_exports };
-//# sourceMappingURL=query-CWZ1cfjo.js.map