@danceroutine/tango-orm 1.4.0 → 1.6.0

package/dist/query-C6So1r6H.js

@@ -0,0 +1,1198 @@
+import { __export } from "./chunk-DLY2FNSh.js";
+import { SqlSafetyEngine, getLogger, isError } from "@danceroutine/tango-core";
+import { ModelRegistry } from "@danceroutine/tango-schema";
+
+//#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/TableMetaFactory.ts
+var TableMetaFactory = class TableMetaFactory {
+	static create(model) {
+		const owner = model.metadata.key ? ModelRegistry.getOwner(model) : undefined;
+		const cache = new Map();
+		return TableMetaFactory.createWithCache(model, owner, cache);
+	}
+	static createWithCache(model, owner, cache) {
+		if (model.metadata.key) {
+			const cached = cache.get(model.metadata.key);
+			if (cached) return cached;
+		}
+		const pkField = model.metadata.fields.find((field) => field.primaryKey);
+		if (!pkField) throw new Error(`Model '${model.metadata.name}' cannot attach a manager without a primary key field.`);
+		const tableMeta = {
+			modelKey: model.metadata.key,
+			table: model.metadata.table,
+			pk: pkField.name,
+			columns: Object.fromEntries(model.metadata.fields.map((field) => [field.name, field.type]))
+		};
+		if (model.metadata.key) cache.set(model.metadata.key, tableMeta);
+		if (!model.metadata.key || !owner) return tableMeta;
+		const relations = owner.getResolvedRelationGraph().byModel.get(model.metadata.key);
+		if (!relations || relations.size === 0) return tableMeta;
+		tableMeta.relations = Object.fromEntries(Array.from(relations.entries()).filter(([, relation]) => relation.capabilities.queryable && relation.capabilities.hydratable).map(([name, relation]) => {
+			const targetModel = owner.getByKey(relation.targetModelKey);
+			const targetMeta = TableMetaFactory.createWithCache(targetModel, owner, cache);
+			const { queryable, hydratable } = relation.capabilities;
+			const isSingleRelation = relation.kind === InternalRelationKind.BELONGS_TO || relation.kind === InternalRelationKind.HAS_ONE;
+			const sourceKey = relation.kind === InternalRelationKind.BELONGS_TO ? relation.localFieldName : relation.targetFieldName;
+			const targetKey = relation.kind === InternalRelationKind.BELONGS_TO ? relation.targetFieldName : relation.localFieldName;
+			const targetColumns = Object.fromEntries(targetModel.metadata.fields.map((field) => [field.name, field.type]));
+			const capabilities = {
+				queryable,
+				hydratable,
+				joinable: isSingleRelation && queryable && hydratable,
+				prefetchable: queryable && hydratable
+			};
+			return [name, {
+				edgeId: relation.edgeId,
+				sourceModelKey: relation.sourceModelKey,
+				targetModelKey: relation.targetModelKey,
+				kind: relation.kind,
+				cardinality: isSingleRelation ? "single" : "many",
+				capabilities,
+				table: targetModel.metadata.table,
+				sourceKey,
+				targetKey,
+				targetPrimaryKey: targetMeta.pk,
+				targetColumns,
+				alias: relation.alias,
+				targetMeta
+			}];
+		}));
+		return tableMeta;
+	}
+};
+
+//#endregion
+//#region src/query/domain/RelationMeta.ts
+const InternalRelationHydrationLoadMode = {
+	JOIN: "join",
+	PREFETCH: "prefetch"
+};
+
+//#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/domain/RelationTyping.ts
+const InternalRelationHydrationCardinality = {
+	SINGLE: "single",
+	MANY: "many"
+};
+
+//#endregion
+//#region src/query/planning/QueryPlanner.ts
+var QueryPlanner = class QueryPlanner {
+	static BRAND = "tango.orm.query_planner";
+	__tangoBrand = QueryPlanner.BRAND;
+	constructor(meta) {
+		this.meta = meta;
+	}
+	static isQueryPlanner(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === QueryPlanner.BRAND;
+	}
+	plan(state) {
+		const requestedPaths = Array.from(new Set([...state.selectRelated ?? [], ...state.prefetchRelated ?? []]));
+		if (requestedPaths.length === 0) return {
+			joinNodes: [],
+			prefetchNodes: [],
+			requestedPaths: []
+		};
+		const rootChildren = new Map();
+		for (const relationPath of new Set(state.selectRelated ?? [])) this.addPath(rootChildren, relationPath, "select");
+		for (const relationPath of new Set(state.prefetchRelated ?? [])) this.addPath(rootChildren, relationPath, "prefetch");
+		const { joinNodes, prefetchNodes } = this.buildPlannedChildren(rootChildren);
+		return {
+			joinNodes,
+			prefetchNodes,
+			requestedPaths
+		};
+	}
+	addPath(rootChildren, relationPath, mode) {
+		const segments = relationPath.split("__").filter(Boolean);
+		if (segments.length === 0) throw new Error(`Invalid empty relation path '${relationPath}'.`);
+		let currentMeta = this.meta;
+		let currentChildren = rootChildren;
+		let builtPath = "";
+		let containsCollection = false;
+		for (const segment of segments) {
+			const relation = currentMeta.relations?.[segment];
+			if (!relation) throw new Error(`Unknown relation path '${relationPath}' for table '${currentMeta.table}'.`);
+			if (segment in currentMeta.columns && relation.sourceKey !== segment) throw new Error(`Relation path '${relationPath}' collides with an existing field on table '${currentMeta.table}'.`);
+			if (relation.kind === InternalRelationKind.MANY_TO_MANY) throw new Error(`Relation path '${relationPath}' uses unsupported many-to-many hydration.`);
+			if (!relation.capabilities.queryable || !relation.capabilities.hydratable) throw new Error(`Relation path '${relationPath}' cannot be hydrated.`);
+			if (mode === "select") {
+				if (relation.cardinality !== InternalRelationHydrationCardinality.SINGLE || !relation.capabilities.joinable) throw new Error(`Relation path '${relationPath}' cannot be loaded with selectRelated(...).`);
+			} else if (relation.cardinality === InternalRelationHydrationCardinality.MANY) {
+				if (!relation.capabilities.prefetchable) throw new Error(`Relation path '${relationPath}' cannot be loaded with prefetchRelated(...).`);
+				containsCollection = true;
+			} else if (!relation.capabilities.joinable) throw new Error(`Relation path '${relationPath}' cannot be loaded with prefetchRelated(...).`);
+			const targetMeta = relation.targetMeta;
+			if (!targetMeta) throw new Error(`Relation path '${relationPath}' is missing target metadata.`);
+			builtPath = builtPath.length > 0 ? `${builtPath}__${segment}` : segment;
+			const existing = currentChildren.get(segment);
+			const nextNode = existing ?? {
+				segment,
+				relationEdge: relation,
+				relationPath: builtPath,
+				targetMeta,
+				provenance: new Set(),
+				children: new Map()
+			};
+			nextNode.provenance.add(relationPath);
+			currentChildren.set(segment, nextNode);
+			currentChildren = nextNode.children;
+			currentMeta = targetMeta;
+		}
+		if (mode === "prefetch" && !containsCollection) throw new Error(`Relation path '${relationPath}' cannot be loaded with prefetchRelated(...).`);
+	}
+	buildPlannedChildren(children) {
+		const joinNodes = [];
+		const prefetchNodes = [];
+		for (const child of children.values()) {
+			const { joinNodes: joinChildren, prefetchNodes: prefetchChildren } = this.buildPlannedChildren(child.children);
+			const plannedNode = {
+				nodeId: child.relationPath,
+				relationName: child.segment,
+				relationPath: child.relationPath,
+				ownerModelKey: child.relationEdge.sourceModelKey,
+				relationEdge: child.relationEdge,
+				targetModelKey: child.relationEdge.targetModelKey,
+				loadMode: child.relationEdge.cardinality === InternalRelationHydrationCardinality.SINGLE ? InternalRelationHydrationLoadMode.JOIN : InternalRelationHydrationLoadMode.PREFETCH,
+				cardinality: child.relationEdge.cardinality,
+				provenance: [...child.provenance],
+				joinChildren,
+				prefetchChildren
+			};
+			if (plannedNode.loadMode === InternalRelationHydrationLoadMode.JOIN) joinNodes.push(plannedNode);
+else prefetchNodes.push(plannedNode);
+		}
+		return {
+			joinNodes,
+			prefetchNodes
+		};
+	}
+};
+
+//#endregion
+//#region src/query/compiler/QueryCompiler.ts
+const sqlSafetyAdapter = new OrmSqlSafetyAdapter();
+var QueryCompiler = class QueryCompiler {
+	static BRAND = "tango.orm.query_compiler";
+	__tangoBrand = QueryCompiler.BRAND;
+	constructor(meta, dialect = InternalDialect.POSTGRES) {
+		this.meta = meta;
+		this.dialect = dialect;
+	}
+	static isQueryCompiler(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === QueryCompiler.BRAND;
+	}
+	compile(state) {
+		const hydrationPlan = new QueryPlanner(this.meta).plan(state);
+		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 baseSelects = state.select?.length ? state.select.map((field) => validatedPlan.selectFields[String(field)]) : [`${table}.*`];
+		const joinCollection = {
+			selects: [],
+			joins: []
+		};
+		const hiddenRootAliases = [];
+		const compiledJoinNodes = hydrationPlan.joinNodes.map((node) => this.compileHydrationNode(node, {
+			rootTable: table,
+			ownerMeta: this.meta,
+			ownerAlias: table,
+			collectRootJoins: true,
+			rootSelectedFields: state.select?.map(String) ?? undefined,
+			hiddenRootAliases,
+			joinCollection
+		}));
+		const compiledPrefetchNodes = hydrationPlan.prefetchNodes.map((node) => this.compileHydrationNode(node, {
+			rootTable: table,
+			ownerMeta: this.meta,
+			ownerAlias: table,
+			collectRootJoins: false,
+			rootSelectedFields: state.select?.map(String) ?? undefined,
+			hiddenRootAliases,
+			joinCollection
+		}));
+		const select = [
+			...baseSelects,
+			...joinCollection.selects,
+			...this.buildRootHiddenSelects(compiledPrefetchNodes, table)
+		].join(", ");
+		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}${joinCollection.joins.length ? ` ${joinCollection.joins.join(" ")}` : ""}${whereSQL}${orderSQL}${limitSQL}${offsetSQL}`;
+		const compiledHydrationPlan = compiledJoinNodes.length > 0 || compiledPrefetchNodes.length > 0 ? {
+			requestedPaths: hydrationPlan.requestedPaths,
+			hiddenRootAliases: [...new Set(hiddenRootAliases)],
+			joinNodes: compiledJoinNodes,
+			prefetchNodes: compiledPrefetchNodes
+		} : undefined;
+		return {
+			sql,
+			params,
+			hydrationPlan: compiledHydrationPlan
+		};
+	}
+	compilePrefetch(node, sourceValues) {
+		const placeholders = this.dialect === InternalDialect.POSTGRES ? sourceValues.map((_, index) => `$${index + 1}`).join(", ") : sourceValues.map(() => "?").join(", ");
+		const validatedTarget = this.validatePrefetchTarget(node);
+		const baseAlias = this.buildPrefetchBaseAlias(node.relationPath);
+		const joinCollection = {
+			selects: [],
+			joins: []
+		};
+		for (const joinChild of node.joinChildren) this.collectNestedJoinSql(joinChild, baseAlias, validatedTarget.columns, joinCollection);
+		const baseSelects = Object.keys(validatedTarget.columns).map((column) => `${baseAlias}.${column} AS ${column}`);
+		return {
+			sql: `SELECT ${[...baseSelects, ...joinCollection.selects].join(", ")} FROM ${validatedTarget.table} ${baseAlias}${joinCollection.joins.length ? ` ${joinCollection.joins.join(" ")}` : ""} WHERE ${baseAlias}.${validatedTarget.targetKey} IN (${placeholders}) ORDER BY ${baseAlias}.${validatedTarget.targetKey} ASC, ${baseAlias}.${validatedTarget.primaryKey} ASC`,
+			params: sourceValues,
+			targetKey: validatedTarget.targetKey,
+			targetColumns: validatedTarget.columns
+		};
+	}
+	compileHydrationNode(node, context) {
+		const validatedRelation = this.validateHydrationRelation(context.ownerMeta, node.relationName);
+		const targetColumns = validatedRelation.targetColumns;
+		const targetMeta = node.relationEdge.targetMeta;
+		if (!targetMeta) throw new Error(`Relation path '${node.relationPath}' is missing target metadata.`);
+		const compiledJoinChildren = node.joinChildren.map((child) => this.compileHydrationNode(child, {
+			...context,
+			ownerMeta: targetMeta,
+			ownerAlias: this.buildJoinAlias(node.relationPath),
+			collectRootJoins: context.collectRootJoins
+		}));
+		const compiledPrefetchChildren = node.prefetchChildren.map((child) => this.compileHydrationNode(child, {
+			...context,
+			ownerMeta: targetMeta,
+			ownerAlias: this.buildJoinAlias(node.relationPath),
+			collectRootJoins: false
+		}));
+		let joinDescriptor;
+		if (node.loadMode === InternalRelationHydrationLoadMode.JOIN) {
+			joinDescriptor = {
+				alias: this.buildJoinAlias(node.relationPath),
+				columns: Object.fromEntries(Object.keys(targetColumns).map((column) => [column, this.buildHydrationColumnAlias(node.relationPath, column)]))
+			};
+			if (context.collectRootJoins) {
+				context.joinCollection.joins.push(`LEFT JOIN ${validatedRelation.table} ${joinDescriptor.alias} ON ${joinDescriptor.alias}.${validatedRelation.targetKey} = ${context.ownerAlias}.${validatedRelation.sourceKey}`);
+				context.joinCollection.selects.push(...Object.entries(joinDescriptor.columns).map(([column, alias]) => `${joinDescriptor.alias}.${column} AS ${alias}`));
+			}
+		}
+		const ownerSourceAccessor = node.loadMode === InternalRelationHydrationLoadMode.PREFETCH && context.collectRootJoins === false && context.ownerAlias === context.rootTable && context.rootSelectedFields?.length && !context.rootSelectedFields.includes(validatedRelation.sourceKey) ? this.buildPrefetchSourceAlias(node.relationPath, validatedRelation.sourceKey) : validatedRelation.sourceKey;
+		if (node.loadMode === InternalRelationHydrationLoadMode.PREFETCH && ownerSourceAccessor !== validatedRelation.sourceKey) context.hiddenRootAliases.push(ownerSourceAccessor);
+		return {
+			nodeId: node.nodeId,
+			relationName: node.relationName,
+			relationPath: node.relationPath,
+			ownerModelKey: node.ownerModelKey,
+			targetModelKey: node.targetModelKey,
+			loadMode: node.loadMode,
+			cardinality: node.cardinality,
+			sourceKey: validatedRelation.sourceKey,
+			ownerSourceAccessor,
+			targetKey: validatedRelation.targetKey,
+			targetTable: validatedRelation.table,
+			targetPrimaryKey: node.relationEdge.targetPrimaryKey,
+			targetColumns,
+			provenance: node.provenance,
+			joinChildren: compiledJoinChildren,
+			prefetchChildren: compiledPrefetchChildren,
+			join: joinDescriptor
+		};
+	}
+	validateHydrationRelation(ownerMeta, relationName) {
+		return sqlSafetyAdapter.validate({
+			kind: "select",
+			meta: ownerMeta,
+			relationNames: [relationName]
+		}).relations[relationName];
+	}
+	buildRootHiddenSelects(nodes, table) {
+		return nodes.flatMap((node) => {
+			const select = node.ownerSourceAccessor !== node.sourceKey ? [`${table}.${node.sourceKey} AS ${node.ownerSourceAccessor}`] : [];
+			return [...select, ...this.buildRootHiddenSelects(node.prefetchChildren, table)];
+		});
+	}
+	validatePrefetchTarget(node) {
+		try {
+			const validated = sqlSafetyAdapter.validate({
+				kind: "select",
+				meta: {
+					table: node.targetTable,
+					pk: node.targetPrimaryKey,
+					columns: node.targetColumns
+				},
+				filterKeys: [node.targetKey]
+			});
+			return {
+				table: validated.meta.table,
+				primaryKey: validated.meta.pk,
+				targetKey: validated.filterKeys[node.targetKey].field,
+				columns: validated.meta.columns
+			};
+		} catch (error) {
+			const message = isError(error) ? error.message : String(error);
+			throw new Error(`Compiled prefetch query failed validation: ${message}`, { cause: error });
+		}
+	}
+	collectNestedJoinSql(node, ownerAlias, ownerColumns, collection) {
+		if (!node.join) return;
+		const validatedTarget = this.validatePrefetchJoinTarget(node, ownerColumns);
+		const validatedJoinAlias = this.validateInternalAlias(node.join.alias);
+		const validatedJoinColumns = Object.fromEntries(Object.entries(node.join.columns).map(([column, alias]) => {
+			if (!(column in validatedTarget.columns)) throw new Error(`Compiled prefetch query failed validation: unknown nested join column '${column}'.`);
+			return [column, this.validateInternalAlias(alias)];
+		}));
+		collection.joins.push(`LEFT JOIN ${validatedTarget.table} ${validatedJoinAlias} ON ${validatedJoinAlias}.${validatedTarget.targetKey} = ${ownerAlias}.${node.sourceKey}`);
+		collection.selects.push(...Object.entries(validatedJoinColumns).map(([column, alias]) => `${validatedJoinAlias}.${column} AS ${alias}`));
+		for (const child of node.joinChildren) this.collectNestedJoinSql(child, validatedJoinAlias, validatedTarget.columns, collection);
+	}
+	validatePrefetchJoinTarget(node, ownerColumns) {
+		if (!(node.sourceKey in ownerColumns)) throw new Error(`Compiled prefetch query failed validation: unknown owner column '${node.sourceKey}' for nested join.`);
+		return this.validatePrefetchTarget(node);
+	}
+	validateInternalAlias(alias) {
+		if (!/^__tango_[A-Za-z0-9_]+$/.test(alias)) throw new Error(`Compiled prefetch query failed validation: invalid internal alias '${alias}'.`);
+		return alias;
+	}
+	buildJoinAlias(relationPath) {
+		return this.assertInternalAliasDoesNotCollide(`__tango_join_${this.sanitizeRelationPath(relationPath)}`);
+	}
+	buildPrefetchBaseAlias(relationPath) {
+		return this.assertInternalAliasDoesNotCollide(`__tango_prefetch_base_${this.sanitizeRelationPath(relationPath)}`);
+	}
+	buildHydrationColumnAlias(relationPath, column) {
+		return this.assertInternalAliasDoesNotCollide(`__tango_hydrate_${this.sanitizeRelationPath(relationPath)}_${column}`);
+	}
+	buildPrefetchSourceAlias(relationPath, sourceKey) {
+		return this.assertInternalAliasDoesNotCollide(`__tango_prefetch_${this.sanitizeRelationPath(relationPath)}_${sourceKey}`);
+	}
+	sanitizeRelationPath(relationPath) {
+		return relationPath.replace(/[^a-zA-Z0-9]+/g, "_");
+	}
+	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/QueryResult.ts
+let didWarnDeprecatedResults = false;
+var QueryResult = class QueryResult {
+	static BRAND = "tango.orm.query_result";
+	__tangoBrand = QueryResult.BRAND;
+	items;
+	constructor(items) {
+		this.items = items;
+	}
+	/**
+	* Runtime narrowing for values that may be a plain array or a `QueryResult` instance.
+	*/
+	static isQueryResult(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === QueryResult.BRAND;
+	}
+	/**
+	* Sync iteration over materialized rows.
+	*/
+	[Symbol.iterator]() {
+		return this.items[Symbol.iterator]();
+	}
+	/** Number of materialized rows. */
+	get length() {
+		return this.items.length;
+	}
+	/** Same as `Array#map` on the materialized rows. */
+	map(callbackfn, thisArg) {
+		return this.items.map(callbackfn, thisArg);
+	}
+	/** Indexed read with support for negative indices, like `Array#at`. */
+	at(index) {
+		return this.items.at(index);
+	}
+	/** Returns a shallow copy of the materialized rows as a plain array. */
+	toArray() {
+		return [...this.items];
+	}
+	/**
+	* @deprecated Use iteration, `length`, `map`, or `toArray()` instead.
+	*/
+	get results() {
+		if (!didWarnDeprecatedResults) {
+			didWarnDeprecatedResults = true;
+			getLogger("tango.orm.query_result").warn("`QueryResult.results` is deprecated. Use iteration, `length`, `map`, or `toArray()` instead.");
+		}
+		return this.items;
+	}
+};
+
+//#endregion
+//#region src/query/domain/index.ts
+var domain_exports = {};
+__export(domain_exports, {
+	InternalRelationHydrationCardinality: () => InternalRelationHydrationCardinality,
+	QueryResult: () => QueryResult,
+	TableMetaFactory: () => TableMetaFactory
+});
+
+//#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;
+	evaluationCache;
+	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 relation paths 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. Generated relation typing also enables nested `__`
+	* path keys for applications that keep the app-local registry current.
+	*/
+	selectRelated(...rels) {
+		return new QuerySet(this.executor, {
+			...this.state,
+			selectRelated: [...rels]
+		});
+	}
+	/**
+	* Hydrate collection-rooted relation paths with follow-up queries.
+	*
+	* Reverse `hasMany` relations can be prefetched with a target model generic
+	* when the target model points back to the source model. Generated relation
+	* typing also enables nested `__` path keys for applications that keep the
+	* app-local registry current.
+	*/
+	prefetchRelated(...rels) {
+		return new QuerySet(this.executor, {
+			...this.state,
+			prefetchRelated: [...rels]
+		});
+	}
+	async fetch(shape) {
+		const baseResult = await this.getOrCreateEvaluationCache();
+		if (!shape) return baseResult;
+		const results = typeof shape === "function" ? baseResult.items.map(shape) : this.normalizeHydratedRowsForParserShape(baseResult.items).map((row) => shape.parse(row));
+		return new QueryResult(results);
+	}
+	/**
+	* Async iterable surface for `for await (... of queryset)`.
+	*
+	* Evaluates this queryset on first use by awaiting {@link QuerySet.fetch} without arguments, then
+	* yields each element from that {@link QueryResult}. Later async iterations over the same queryset
+	* instance reuse the cached materialized result instead of issuing another database round-trip.
+	*/
+	async *[Symbol.asyncIterator]() {
+		const result = await this.fetch();
+		for (const row of result) yield row;
+	}
+	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);
+		for (const row of result) return row;
+		return null;
+	}
+	/**
+	* Execute a `COUNT(*)` query for the current filtered state.
+	*/
+	async count() {
+		const compiler = new QueryCompiler(this.executor.meta, this.executor.dialect);
+		const compiled = compiler.compile(this.withoutHydrationState());
+		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;
+	}
+	getOrCreateEvaluationCache() {
+		if (!this.evaluationCache) this.evaluationCache = this.evaluateRows().catch((error) => {
+			this.evaluationCache = undefined;
+			throw error;
+		});
+		return this.evaluationCache;
+	}
+	async evaluateRows() {
+		const compiler = new QueryCompiler(this.executor.meta, this.executor.dialect);
+		const compiled = compiler.compile(this.state);
+		const rows = await this.executor.run(compiled);
+		const hydratedRows = await this.hydrateRows(rows, compiled);
+		const projectedRows = hydratedRows;
+		return new QueryResult(projectedRows);
+	}
+	normalizeHydratedRowsForParserShape(rows) {
+		if (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));
+	}
+	async hydrateRows(rows, compiled) {
+		if (!compiled.hydrationPlan) return rows;
+		const hydratedRows = rows.map((row) => ({ ...row }));
+		const canonicalEntities = new Map();
+		const queuedJoinPrefetchOwners = new Map();
+		const compiler = new QueryCompiler(this.executor.meta, this.executor.dialect);
+		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;
+	}
+	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 !== undefined) 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()];
+		for (const owner of owners) owner[node.relationName] = node.cardinality === InternalRelationHydrationCardinality.MANY ? [] : null;
+		if (sourceValues.length === 0) return;
+		const compiledPrefetch = compiler.compilePrefetch(node, sourceValues);
+		const result = await this.executor.client.query(compiledPrefetch.sql, compiledPrefetch.params);
+		const groupedTargets = new Map();
+		const canonicalChildren = new Map();
+		for (const rawResultRow of result.rows) {
+			const normalized = this.normalizeTargetRow(compiledPrefetch, rawResultRow);
+			const canonical = this.canonicalizeEntity(node, normalized, canonicalEntities);
+			this.hydrateJoinNodesForOwner(canonical, normalized, node.joinChildren, canonicalEntities);
+			const key = normalized[compiledPrefetch.targetKey];
+			if (typeof key !== "string" && typeof key !== "number") continue;
+			const bucket = groupedTargets.get(key) ?? [];
+			bucket.push(canonical);
+			groupedTargets.set(key, bucket);
+			const childPrimaryKey = canonical[node.targetPrimaryKey];
+			if (typeof childPrimaryKey === "string" || typeof childPrimaryKey === "number") canonicalChildren.set(childPrimaryKey, canonical);
+		}
+		for (const [sourceValue, grouped] of groupedTargets.entries()) for (const owner of groupedOwners.get(sourceValue) ?? []) owner[node.relationName] = node.cardinality === InternalRelationHydrationCardinality.MANY ? grouped : grouped[0];
+		const childOwners = [...canonicalChildren.values()];
+		for (const childNode of node.prefetchChildren) await this.hydratePrefetchNode(childNode, childOwners, canonicalEntities, compiler);
+	}
+	groupOwnersByAccessor(owners, accessor) {
+		const grouped = 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) ?? new Map();
+		const existing = byModel.get(primaryKeyValue);
+		if (existing) {
+			Object.assign(existing, row);
+			return existing;
+		}
+		byModel.set(primaryKeyValue, row);
+		canonicalEntities.set(node.targetModelKey, byModel);
+		return row;
+	}
+	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;
+	}
+	normalizeColumnValue(columnType, value) {
+		return this.executor.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;
+	}
+	withoutHydrationState() {
+		const { selectRelated: _selectRelated, prefetchRelated: _prefetchRelated,...rest } = this.state;
+		return rest;
+	}
+};
+
+//#endregion
+//#region src/query/index.ts
+var query_exports = {};
+__export(query_exports, {
+	Q: () => QBuilder,
+	QBuilder: () => QBuilder,
+	QueryCompiler: () => QueryCompiler,
+	QueryResult: () => QueryResult,
+	QuerySet: () => QuerySet,
+	compiler: () => compiler_exports,
+	domain: () => domain_exports
+});
+
+//#endregion
+export { OrmSqlSafetyAdapter, QBuilder, QueryCompiler, QueryResult, QuerySet, TableMetaFactory, compiler_exports, domain_exports, query_exports };
+//# sourceMappingURL=query-C6So1r6H.js.map