@danceroutine/tango-orm 1.11.11 → 1.11.12

package/dist/{query-D_93uktq.js → query-hvcqTb9O.js}

@@ -1104,6 +1104,263 @@ var QBuilder = class QBuilder {
 	}
 };
 //#endregion
+//#region src/query/hydration/HydrationEntityRegistry.ts
+/**
+* Tracks hydrated related records so repeated rows point at one canonical
+* object per model primary key.
+*/
+var HydrationEntityRegistry = class HydrationEntityRegistry {
+	attachPersistedRecordAccessors;
+	static BRAND = "tango.orm.hydration_entity_registry";
+	__tangoBrand = HydrationEntityRegistry.BRAND;
+	recordsByModel = /* @__PURE__ */ new Map();
+	constructor(attachPersistedRecordAccessors) {
+		this.attachPersistedRecordAccessors = attachPersistedRecordAccessors;
+	}
+	static isHydrationEntityRegistry(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === HydrationEntityRegistry.BRAND;
+	}
+	canonicalize(node, row) {
+		const primaryKeyValue = row[node.targetPrimaryKey];
+		if (typeof primaryKeyValue !== "string" && typeof primaryKeyValue !== "number") return row;
+		const byModel = this.recordsByModel.get(node.targetModelKey) ?? /* @__PURE__ */ new Map();
+		const existing = byModel.get(primaryKeyValue);
+		if (existing) {
+			Object.assign(existing, row);
+			return existing;
+		}
+		byModel.set(primaryKeyValue, row);
+		this.recordsByModel.set(node.targetModelKey, byModel);
+		this.attachPersistedRecordAccessors?.(row, node.targetModelKey);
+		return row;
+	}
+};
+//#endregion
+//#region src/query/hydration/QueryRowNormalizerStrategy.ts
+var PassthroughQueryRowNormalizerStrategy = class {
+	normalizeRootRows(rows, _columns) {
+		return [...rows];
+	}
+	normalizeHydratedRowsForParserShape(rows, _columns) {
+		return [...rows];
+	}
+	normalizeTargetRow(row, _targetColumns) {
+		return row;
+	}
+	normalizeColumnValue(_columnType, value) {
+		return value;
+	}
+};
+function createQueryRowNormalizerStrategy(dialect) {
+	return dialect === InternalDialect.SQLITE ? new SqliteRowNormalizerStrategy() : new PassthroughQueryRowNormalizerStrategy();
+}
+var SqliteRowNormalizerStrategy = class {
+	normalizeRootRows(rows, columns) {
+		return this.normalizeRows(rows, columns);
+	}
+	normalizeHydratedRowsForParserShape(rows, columns) {
+		return this.normalizeRows(rows, columns);
+	}
+	normalizeTargetRow(row, targetColumns) {
+		return this.normalizeRow(row, this.booleanColumns(targetColumns));
+	}
+	normalizeColumnValue(columnType, value) {
+		return this.isBooleanColumnType(columnType) ? this.normalizeSqliteBoolean(value) : value;
+	}
+	normalizeRows(rows, columns) {
+		const booleanColumns = this.booleanColumns(columns);
+		if (booleanColumns.length === 0) return [...rows];
+		return rows.map((row) => this.normalizeRow(row, booleanColumns));
+	}
+	normalizeRow(row, columns) {
+		let normalized = null;
+		for (const column of columns) {
+			const current = row[column];
+			const next = this.normalizeSqliteBoolean(current);
+			if (next === current) continue;
+			normalized ??= { ...row };
+			normalized[column] = next;
+		}
+		return normalized ?? row;
+	}
+	booleanColumns(columns) {
+		return Object.entries(columns).filter(([, value]) => this.isBooleanColumnType(value)).map(([column]) => column);
+	}
+	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;
+	}
+};
+//#endregion
+//#region src/query/hydration/QueryHydrator.ts
+/**
+* Coordinates compiled relation hydration for `QuerySet` evaluation.
+*/
+var QueryHydrator = class QueryHydrator {
+	executor;
+	static BRAND = "tango.orm.query_hydrator";
+	__tangoBrand = QueryHydrator.BRAND;
+	normalizer;
+	constructor(executor, normalizer) {
+		this.executor = executor;
+		this.normalizer = normalizer ?? createQueryRowNormalizerStrategy(executor.adapter.dialect);
+	}
+	static isQueryHydrator(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === QueryHydrator.BRAND;
+	}
+	async materializeRows(rows, compiled) {
+		const hydratedRows = await this.hydrateRows(rows, compiled);
+		this.attachRootRecordAccessors(hydratedRows);
+		return hydratedRows;
+	}
+	async hydrateRows(rows, compiled) {
+		if (!compiled.hydrationPlan) return rows;
+		const hydratedRows = rows.map((row) => ({ ...row }));
+		this.attachRootRecordAccessors(hydratedRows);
+		const registry = new HydrationEntityRegistry(this.executor.attachPersistedRecordAccessors);
+		const queuedJoinPrefetchOwners = /* @__PURE__ */ new Map();
+		const compiler = new QueryCompiler(this.executor.meta, this.executor.adapter);
+		for (const row of hydratedRows) this.hydrateJoinNodesForOwner(row, row, compiled.hydrationPlan.joinNodes, registry, queuedJoinPrefetchOwners);
+		for (const node of compiled.hydrationPlan.prefetchNodes) await this.hydratePrefetchNode(node, hydratedRows, registry, compiler);
+		for (const [node, owners] of queuedJoinPrefetchOwners.entries()) await this.hydratePrefetchNode(node, [...owners], registry, compiler);
+		for (const row of hydratedRows) for (const alias of compiled.hydrationPlan.hiddenRootAliases) delete row[alias];
+		return hydratedRows;
+	}
+	attachRootRecordAccessors(rows) {
+		if (!this.executor.attachPersistedRecordAccessors) return;
+		const sourceModelKey = this.executor.meta.modelKey;
+		for (const row of rows) this.executor.attachPersistedRecordAccessors(row, sourceModelKey);
+	}
+	hydrateJoinNodesForOwner(owner, rawRow, nodes, registry, queuedJoinPrefetchOwners) {
+		for (const node of nodes) {
+			if (!node.join) continue;
+			const target = {};
+			let hasTargetValue = false;
+			for (const [column, alias] of Object.entries(node.join.columns)) {
+				const value = rawRow[alias];
+				delete rawRow[alias];
+				target[column] = this.normalizer.normalizeColumnValue(node.targetColumns[column], value);
+				if (value !== null && value !== void 0) hasTargetValue = true;
+			}
+			if (!hasTargetValue) {
+				owner[node.relationName] = null;
+				continue;
+			}
+			const canonical = registry.canonicalize(node, target);
+			owner[node.relationName] = canonical;
+			for (const childNode of node.prefetchChildren) {
+				const queuedOwners = queuedJoinPrefetchOwners?.get(childNode);
+				if (queuedOwners) {
+					queuedOwners.add(canonical);
+					continue;
+				}
+				queuedJoinPrefetchOwners?.set(childNode, new Set([canonical]));
+			}
+			this.hydrateJoinNodesForOwner(canonical, rawRow, node.joinChildren, registry, queuedJoinPrefetchOwners);
+		}
+	}
+	async hydratePrefetchNode(node, owners, registry, compiler) {
+		if (owners.length === 0) return;
+		const groupedOwners = this.groupOwnersByAccessor(owners, node.ownerSourceAccessor);
+		const sourceValues = [...groupedOwners.keys()];
+		if (!!!node.throughTable) for (const owner of owners) owner[node.relationName] = node.cardinality === InternalRelationHydrationCardinality.MANY ? [] : null;
+		if (sourceValues.length === 0) return;
+		const sourceChunks = this.chunkValues(sourceValues, 500);
+		const compiledPrefetch = compiler.compilePrefetch(node, sourceChunks[0]);
+		if (compiledPrefetch.kind === InternalPrefetchQueryKind.MANY_TO_MANY) {
+			const idsByOwner = /* @__PURE__ */ new Map();
+			const uniqueTargetIds = /* @__PURE__ */ new Set();
+			for (const chunk of sourceChunks) {
+				const chunkCompiled = compiler.compilePrefetch(node, chunk);
+				const throughResult = await this.executor.client.query(chunkCompiled.throughSql, chunkCompiled.throughParams);
+				for (const row of throughResult.rows) {
+					const ownerId = row[chunkCompiled.ownerAlias];
+					const targetId = row[chunkCompiled.targetAlias];
+					if (typeof ownerId !== "string" && typeof ownerId !== "number" || typeof targetId !== "string" && typeof targetId !== "number") continue;
+					const bucket = idsByOwner.get(ownerId) ?? [];
+					bucket.push(targetId);
+					idsByOwner.set(ownerId, bucket);
+					uniqueTargetIds.add(targetId);
+				}
+			}
+			const targets = {};
+			const targetIds = [...uniqueTargetIds.values()];
+			if (targetIds.length > 0) for (const targetChunk of this.chunkValues(targetIds, 500)) {
+				const targetQuery = compiler.compileManyToManyTargets(node, targetChunk);
+				const targetResult = await this.executor.client.query(targetQuery.sql, targetQuery.params);
+				for (const rawTargetRow of targetResult.rows) {
+					const normalized = this.normalizer.normalizeTargetRow(rawTargetRow, compiledPrefetch.targetColumns);
+					const canonical = registry.canonicalize(node, normalized);
+					this.hydrateJoinNodesForOwner(canonical, normalized, node.joinChildren, registry);
+					const primaryKey = canonical[node.targetPrimaryKey];
+					if (typeof primaryKey === "string" || typeof primaryKey === "number") targets[primaryKey] = canonical;
+				}
+			}
+			const canonicalChildren = /* @__PURE__ */ new Map();
+			const handledOwners = /* @__PURE__ */ new Set();
+			for (const [ownerId, ids] of idsByOwner.entries()) {
+				const bucket = ids.map((id) => targets[id]).filter((value) => !!value);
+				for (const owner of groupedOwners.get(ownerId) ?? []) {
+					this.primeManyToManyOwnerCache(owner, node.relationName, bucket);
+					handledOwners.add(owner);
+				}
+				for (const child of bucket) canonicalChildren.set(child[node.targetPrimaryKey], child);
+			}
+			for (const owner of owners) if (!handledOwners.has(owner)) this.primeManyToManyOwnerCache(owner, node.relationName, []);
+			const childOwners = [...canonicalChildren.values()];
+			for (const childNode of node.prefetchChildren) await this.hydratePrefetchNode(childNode, childOwners, registry, compiler);
+			return;
+		}
+		const canonicalChildren = /* @__PURE__ */ new Map();
+		for (const chunk of sourceChunks) {
+			const chunkCompiled = compiler.compilePrefetch(node, chunk);
+			const result = await this.executor.client.query(chunkCompiled.sql, chunkCompiled.params);
+			for (const rawResultRow of result.rows) {
+				const normalized = this.normalizer.normalizeTargetRow(rawResultRow, chunkCompiled.targetColumns);
+				const canonical = registry.canonicalize(node, normalized);
+				this.hydrateJoinNodesForOwner(canonical, normalized, node.joinChildren, registry);
+				const key = normalized[chunkCompiled.targetKey];
+				if (typeof key !== "string" && typeof key !== "number") continue;
+				for (const owner of groupedOwners.get(key) ?? []) if (node.cardinality === InternalRelationHydrationCardinality.MANY) owner[node.relationName].push(canonical);
+				else if (owner[node.relationName] === null) owner[node.relationName] = canonical;
+				const childPrimaryKey = canonical[node.targetPrimaryKey];
+				if (typeof childPrimaryKey === "string" || typeof childPrimaryKey === "number") canonicalChildren.set(childPrimaryKey, canonical);
+			}
+		}
+		const childOwners = [...canonicalChildren.values()];
+		for (const childNode of node.prefetchChildren) await this.hydratePrefetchNode(childNode, childOwners, registry, compiler);
+	}
+	primeManyToManyOwnerCache(owner, relationName, bucket) {
+		const existing = owner[relationName];
+		if (existing && typeof existing.primePrefetchCache === "function") {
+			existing.primePrefetchCache(bucket);
+			return;
+		}
+		owner[relationName] = bucket.slice();
+	}
+	chunkValues(values, size) {
+		if (values.length <= size) return [Array.from(values)];
+		const chunks = [];
+		for (let i = 0; i < values.length; i += size) chunks.push(values.slice(i, i + size));
+		return chunks;
+	}
+	groupOwnersByAccessor(owners, accessor) {
+		const grouped = /* @__PURE__ */ new Map();
+		for (const owner of owners) {
+			const key = owner[accessor];
+			if (typeof key !== "string" && typeof key !== "number") continue;
+			const bucket = grouped.get(key) ?? [];
+			bucket.push(owner);
+			grouped.set(key, bucket);
+		}
+		return grouped;
+	}
+};
+//#endregion
 //#region src/query/QuerySet.ts
 /**
 * Django-inspired query builder for constructing and executing database queries.
@@ -1132,9 +1389,13 @@ var QuerySet = class QuerySet {
 	static BRAND = "tango.orm.query_set";
 	__tangoBrand = QuerySet.BRAND;
 	evaluationCache;
+	hydrator;
+	rowNormalizer;
 	constructor(executor, state = {}) {
 		this.executor = executor;
 		this.state = state;
+		this.rowNormalizer = createQueryRowNormalizerStrategy(executor.adapter.dialect);
+		this.hydrator = new QueryHydrator(executor, this.rowNormalizer);
 	}
 	/**
 	* Narrow an unknown value to `QuerySet`.
@@ -1275,7 +1536,7 @@ var QuerySet = class QuerySet {
 	async fetch(shape) {
 		const baseResult = await this.getOrCreateEvaluationCache();
 		if (!shape) return baseResult;
-		return new QueryResult(typeof shape === "function" ? baseResult.items.map(shape) : this.normalizeHydratedRowsForParserShape(baseResult.items).map((row) => shape.parse(row)));
+		return new QueryResult(typeof shape === "function" ? baseResult.items.map(shape) : this.rowNormalizer.normalizeHydratedRowsForParserShape(baseResult.items, this.executor.meta.columns).map((row) => shape.parse(row)));
 	}
 	/**
 	* Async iterable surface for `for await (... of queryset)`.
@@ -1339,7 +1600,7 @@ var QuerySet = class QuerySet {
 	shapeFetchedRow(row, shape) {
 		if (!shape) return row;
 		if (typeof shape === "function") return shape(row);
-		const normalizedRow = this.normalizeHydratedRowsForParserShape([row])[0] ?? row;
+		const normalizedRow = this.rowNormalizer.normalizeHydratedRowsForParserShape([row], this.executor.meta.columns)[0];
 		return shape.parse(normalizedRow);
 	}
 	getOrCreateEvaluationCache() {
@@ -1352,213 +1613,8 @@ var QuerySet = class QuerySet {
 	async evaluateRows() {
 		const compiled = new QueryCompiler(this.executor.meta, this.executor.adapter).compile(this.state);
 		const rows = await this.executor.run(compiled);
-		const normalizedRows = this.normalizeRowsForSchemaParsing(rows);
-		const hydratedRows = await this.hydrateRows(normalizedRows, compiled);
-		this.attachRootRecordAccessors(hydratedRows);
-		return new QueryResult(hydratedRows);
-	}
-	normalizeRowsForSchemaParsing(rows) {
-		if (this.executor.adapter.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));
-	}
-	normalizeHydratedRowsForParserShape(rows) {
-		if (this.executor.adapter.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));
-	}
-	async hydrateRows(rows, compiled) {
-		if (!compiled.hydrationPlan) return rows;
-		const hydratedRows = rows.map((row) => ({ ...row }));
-		this.attachRootRecordAccessors(hydratedRows);
-		const canonicalEntities = /* @__PURE__ */ new Map();
-		const queuedJoinPrefetchOwners = /* @__PURE__ */ new Map();
-		const compiler = new QueryCompiler(this.executor.meta, this.executor.adapter);
-		for (const row of hydratedRows) this.hydrateJoinNodesForOwner(row, row, compiled.hydrationPlan.joinNodes, canonicalEntities, queuedJoinPrefetchOwners);
-		for (const node of compiled.hydrationPlan.prefetchNodes) await this.hydratePrefetchNode(node, hydratedRows, canonicalEntities, compiler);
-		for (const [node, owners] of queuedJoinPrefetchOwners.entries()) await this.hydratePrefetchNode(node, [...owners], canonicalEntities, compiler);
-		for (const row of hydratedRows) for (const alias of compiled.hydrationPlan.hiddenRootAliases) delete row[alias];
-		return hydratedRows;
-	}
-	primeManyToManyOwnerCache(owner, relationName, bucket) {
-		const existing = owner[relationName];
-		if (existing && typeof existing.primePrefetchCache === "function") {
-			existing.primePrefetchCache(bucket);
-			return;
-		}
-		owner[relationName] = bucket.slice();
-	}
-	attachRootRecordAccessors(rows) {
-		if (!this.executor.attachPersistedRecordAccessors) return;
-		const sourceModelKey = this.executor.meta.modelKey;
-		for (const row of rows) this.executor.attachPersistedRecordAccessors(row, sourceModelKey);
-	}
-	hydrateJoinNodesForOwner(owner, rawRow, nodes, canonicalEntities, queuedJoinPrefetchOwners) {
-		for (const node of nodes) {
-			if (!node.join) continue;
-			const target = {};
-			let hasTargetValue = false;
-			for (const [column, alias] of Object.entries(node.join.columns)) {
-				const value = rawRow[alias];
-				delete rawRow[alias];
-				target[column] = this.normalizeColumnValue(node.targetColumns[column], value);
-				if (value !== null && value !== void 0) hasTargetValue = true;
-			}
-			if (!hasTargetValue) {
-				owner[node.relationName] = null;
-				continue;
-			}
-			const canonical = this.canonicalizeEntity(node, target, canonicalEntities);
-			owner[node.relationName] = canonical;
-			for (const childNode of node.prefetchChildren) {
-				const queuedOwners = queuedJoinPrefetchOwners?.get(childNode);
-				if (queuedOwners) {
-					queuedOwners.add(canonical);
-					continue;
-				}
-				queuedJoinPrefetchOwners?.set(childNode, new Set([canonical]));
-			}
-			this.hydrateJoinNodesForOwner(canonical, rawRow, node.joinChildren, canonicalEntities, queuedJoinPrefetchOwners);
-		}
-	}
-	async hydratePrefetchNode(node, owners, canonicalEntities, compiler) {
-		if (owners.length === 0) return;
-		const groupedOwners = this.groupOwnersByAccessor(owners, node.ownerSourceAccessor);
-		const sourceValues = [...groupedOwners.keys()];
-		if (!!!node.throughTable) for (const owner of owners) owner[node.relationName] = node.cardinality === InternalRelationHydrationCardinality.MANY ? [] : null;
-		if (sourceValues.length === 0) return;
-		const sourceChunks = this.chunkValues(sourceValues, 500);
-		const compiledPrefetch = compiler.compilePrefetch(node, sourceChunks[0]);
-		if (compiledPrefetch.kind === InternalPrefetchQueryKind.MANY_TO_MANY) {
-			const idsByOwner = /* @__PURE__ */ new Map();
-			const uniqueTargetIds = /* @__PURE__ */ new Set();
-			for (const chunk of sourceChunks) {
-				const chunkCompiled = compiler.compilePrefetch(node, chunk);
-				const throughResult = await this.executor.client.query(chunkCompiled.throughSql, chunkCompiled.throughParams);
-				for (const row of throughResult.rows) {
-					const ownerId = row[chunkCompiled.ownerAlias];
-					const targetId = row[chunkCompiled.targetAlias];
-					if (typeof ownerId !== "string" && typeof ownerId !== "number" || typeof targetId !== "string" && typeof targetId !== "number") continue;
-					const bucket = idsByOwner.get(ownerId) ?? [];
-					bucket.push(targetId);
-					idsByOwner.set(ownerId, bucket);
-					uniqueTargetIds.add(targetId);
-				}
-			}
-			const targets = {};
-			const targetIds = [...uniqueTargetIds.values()];
-			if (targetIds.length > 0) for (const targetChunk of this.chunkValues(targetIds, 500)) {
-				const targetQuery = compiler.compileManyToManyTargets(node, targetChunk);
-				const targetResult = await this.executor.client.query(targetQuery.sql, targetQuery.params);
-				for (const rawTargetRow of targetResult.rows) {
-					const normalized = this.normalizeTargetRow({ targetColumns: compiledPrefetch.targetColumns }, rawTargetRow);
-					const canonical = this.canonicalizeEntity(node, normalized, canonicalEntities);
-					this.hydrateJoinNodesForOwner(canonical, normalized, node.joinChildren, canonicalEntities);
-					const primaryKey = canonical[node.targetPrimaryKey];
-					if (typeof primaryKey === "string" || typeof primaryKey === "number") targets[primaryKey] = canonical;
-				}
-			}
-			const canonicalChildren = /* @__PURE__ */ new Map();
-			const handledOwners = /* @__PURE__ */ new Set();
-			for (const [ownerId, ids] of idsByOwner.entries()) {
-				const bucket = ids.map((id) => targets[id]).filter((value) => !!value);
-				for (const owner of groupedOwners.get(ownerId) ?? []) {
-					this.primeManyToManyOwnerCache(owner, node.relationName, bucket);
-					handledOwners.add(owner);
-				}
-				for (const child of bucket) canonicalChildren.set(child[node.targetPrimaryKey], child);
-			}
-			for (const owner of owners) if (!handledOwners.has(owner)) this.primeManyToManyOwnerCache(owner, node.relationName, []);
-			const childOwners = [...canonicalChildren.values()];
-			for (const childNode of node.prefetchChildren) await this.hydratePrefetchNode(childNode, childOwners, canonicalEntities, compiler);
-			return;
-		}
-		const canonicalChildren = /* @__PURE__ */ new Map();
-		for (const chunk of sourceChunks) {
-			const chunkCompiled = compiler.compilePrefetch(node, chunk);
-			const result = await this.executor.client.query(chunkCompiled.sql, chunkCompiled.params);
-			for (const rawResultRow of result.rows) {
-				const normalized = this.normalizeTargetRow(chunkCompiled, rawResultRow);
-				const canonical = this.canonicalizeEntity(node, normalized, canonicalEntities);
-				this.hydrateJoinNodesForOwner(canonical, normalized, node.joinChildren, canonicalEntities);
-				const key = normalized[chunkCompiled.targetKey];
-				if (typeof key !== "string" && typeof key !== "number") continue;
-				for (const owner of groupedOwners.get(key) ?? []) if (node.cardinality === InternalRelationHydrationCardinality.MANY) owner[node.relationName].push(canonical);
-				else if (owner[node.relationName] === null) owner[node.relationName] = canonical;
-				const childPrimaryKey = canonical[node.targetPrimaryKey];
-				if (typeof childPrimaryKey === "string" || typeof childPrimaryKey === "number") canonicalChildren.set(childPrimaryKey, canonical);
-			}
-		}
-		const childOwners = [...canonicalChildren.values()];
-		for (const childNode of node.prefetchChildren) await this.hydratePrefetchNode(childNode, childOwners, canonicalEntities, compiler);
-	}
-	chunkValues(values, size) {
-		if (values.length === 0) return [];
-		if (values.length <= size) return [Array.from(values)];
-		const chunks = [];
-		for (let i = 0; i < values.length; i += size) chunks.push(values.slice(i, i + size));
-		return chunks;
-	}
-	groupOwnersByAccessor(owners, accessor) {
-		const grouped = /* @__PURE__ */ new Map();
-		for (const owner of owners) {
-			const key = owner[accessor];
-			if (typeof key !== "string" && typeof key !== "number") continue;
-			const bucket = grouped.get(key) ?? [];
-			bucket.push(owner);
-			grouped.set(key, bucket);
-		}
-		return grouped;
-	}
-	canonicalizeEntity(node, row, canonicalEntities) {
-		const primaryKeyValue = row[node.targetPrimaryKey];
-		if (typeof primaryKeyValue !== "string" && typeof primaryKeyValue !== "number") return row;
-		const byModel = canonicalEntities.get(node.targetModelKey) ?? /* @__PURE__ */ new Map();
-		const existing = byModel.get(primaryKeyValue);
-		if (existing) {
-			Object.assign(existing, row);
-			return existing;
-		}
-		byModel.set(primaryKeyValue, row);
-		canonicalEntities.set(node.targetModelKey, byModel);
-		this.executor.attachPersistedRecordAccessors?.(row, node.targetModelKey);
-		return row;
-	}
-	normalizeTargetRow(prefetch, row) {
-		if (this.executor.adapter.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;
-	}
-	normalizeColumnValue(columnType, value) {
-		return this.executor.adapter.dialect === InternalDialect.SQLITE && this.isBooleanColumnType(columnType) ? 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;
+		const normalizedRows = this.rowNormalizer.normalizeRootRows(rows, this.executor.meta.columns);
+		return new QueryResult(await this.hydrator.materializeRows(normalizedRows, compiled));
 	}
 	withoutHydrationState() {
 		const { selectRelated: _selectRelated, prefetchRelated: _prefetchRelated, ...rest } = this.state;
@@ -1596,4 +1652,4 @@ var query_exports = /* @__PURE__ */ __exportAll({
 //#endregion
 export { isQNodeLike as a, InternalRelationKind as c, QueryCompiler as d, OrmSqlSafetyAdapter as f, QBuilder as i, QueryResult as l, InternalQNodeType as m, ModelQuerySet as n, domain_exports as o, InternalSqlValidationPlanKind as p, QuerySet as r, TableMetaFactory as s, query_exports as t, compiler_exports as u };
 
-//# sourceMappingURL=query-D_93uktq.js.map
+//# sourceMappingURL=query-hvcqTb9O.js.map