appflare 0.2.30 → 0.2.31

package/cli/templates/handlers/generators/types/query-definitions/query-helper-functions.ts

@@ -1,1031 +1,1103 @@
-export function generateQueryHelperFunctionsSection(): string {
-	return `function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}
-
-function readOperatorValue(record: Record<string, unknown>, key: string): unknown {
-	if (record[key] !== undefined) {
-		return record[key];
-	}
-	const prefixed = "$" + key;
-	return record[prefixed];
-}
-
-function normalizeGeoPoint(
-	value: GeoPoint | GeoCoordinates,
-): { latitude: number; longitude: number } | null {
-	if ((value as GeoPoint).latitude !== undefined) {
-		const point = value as GeoPoint;
-		if (
-			typeof point.latitude === "number" &&
-			typeof point.longitude === "number"
-		) {
-			return {
-				latitude: point.latitude,
-				longitude: point.longitude,
-			};
-		}
-		return null;
-	}
-
-	const coordinates = (value as GeoCoordinates).coordinates;
-	if (!Array.isArray(coordinates) || coordinates.length < 2) {
-		return null;
-	}
-
-	const [longitude, latitude] = coordinates;
-	if (typeof latitude !== "number" || typeof longitude !== "number") {
-		return null;
-	}
-
-	return {
-		latitude,
-		longitude,
-	};
-}
-
-function createGeoDistanceFilter(
-	operand: GeoWithinOperand,
-	fields: Record<string, unknown>,
-	tableName?: string,
-	fallbackLatitudeField?: string,
-): SQL | undefined {
-	const geometry = normalizeGeoPoint(operand.$geometry);
-	if (!geometry) {
-		return undefined;
-	}
-
-	const latitudeField = operand.latitudeField ?? fallbackLatitudeField;
-	const longitudeField = operand.longitudeField;
-	if (!latitudeField || !longitudeField) {
-		return undefined;
-	}
-
-	const latitudeColumn = fields[latitudeField];
-	if (!latitudeColumn) {
-		console.warn(
-			"Invalid geoWithin latitudeField",
-			tableName ?? "unknown",
-			latitudeField,
-		);
-		return undefined;
-	}
-
-	const longitudeColumn = fields[longitudeField];
-	if (!longitudeColumn) {
-		console.warn(
-			"Invalid geoWithin longitudeField",
-			tableName ?? "unknown",
-			longitudeField,
-		);
-		return undefined;
-	}
-
-	const distanceExpression = sql<number>\`(
-		6371000 * acos(
-			cos(radians(\${geometry.latitude})) * cos(radians(\${latitudeColumn}))
-			* cos(radians(\${longitudeColumn}) - radians(\${geometry.longitude}))
-			+ sin(radians(\${geometry.latitude})) * sin(radians(\${latitudeColumn}))
-		)
-	)\`;
-
-	const minDistance =
-		operand.$minDistance ??
-		operand.gte ??
-		operand.$gte ??
-		operand.gt ??
-		operand.$gt;
-	const maxDistance =
-		operand.$maxDistance ??
-		operand.lte ??
-		operand.$lte ??
-		operand.lt ??
-		operand.$lt;
-
-	const filters: SQL[] = [];
-	if (typeof minDistance === "number") {
-		filters.push(sql\`\${distanceExpression} >= \${minDistance}\`);
-	}
-	if (typeof maxDistance === "number") {
-		filters.push(sql\`\${distanceExpression} <= \${maxDistance}\`);
-	}
-
-	if (filters.length === 0) {
-		return undefined;
-	}
-
-	if (filters.length === 1) {
-		return filters[0];
-	}
-
-	return and(...filters);
-}
-
-function buildFieldFilter(
-	fieldName: string,
-	field: unknown,
-	value: unknown,
-	fields: Record<string, unknown>,
-): SQL | undefined {
-	if (!isRecord(value) || value instanceof Date || Array.isArray(value)) {
-		return eq(field as never, value as never);
-	}
-
-	const filters: SQL[] = [];
-	const eqValue = readOperatorValue(value, "eq");
-	if (eqValue !== undefined) {
-		filters.push(eq(field as never, eqValue as never));
-	}
-
-	const neValue = readOperatorValue(value, "ne");
-	if (neValue !== undefined) {
-		filters.push(ne(field as never, neValue as never));
-	}
-
-	const inValue = readOperatorValue(value, "in");
-	if (Array.isArray(inValue) && inValue.length > 0) {
-		filters.push(inArray(field as never, inValue as never));
-	}
-
-	const ninValue = readOperatorValue(value, "nin");
-	if (Array.isArray(ninValue) && ninValue.length > 0) {
-		filters.push(notInArray(field as never, ninValue as never));
-	}
-
-	const gtValue = readOperatorValue(value, "gt");
-	if (gtValue !== undefined) {
-		filters.push(gt(field as never, gtValue as never));
-	}
-
-	const gteValue = readOperatorValue(value, "gte");
-	if (gteValue !== undefined) {
-		filters.push(gte(field as never, gteValue as never));
-	}
-
-	const ltValue = readOperatorValue(value, "lt");
-	if (ltValue !== undefined) {
-		filters.push(lt(field as never, ltValue as never));
-	}
-
-	const lteValue = readOperatorValue(value, "lte");
-	if (lteValue !== undefined) {
-		filters.push(lte(field as never, lteValue as never));
-	}
-
-	if (typeof value.exists === "boolean") {
-		filters.push(value.exists ? isNotNull(field as never) : isNull(field as never));
-	}
-
-	if (typeof value.regex === "string") {
-		const caseInsensitive = typeof value.$options === "string" && value.$options.includes("i");
-		const pattern = "%" + value.regex + "%";
-		if (caseInsensitive) {
-			filters.push(
-				sql\`lower(\${field as never}) like lower(\${pattern})\`,
-			);
-		} else {
-			filters.push(sql\`\${field as never} like \${pattern}\`);
-		}
-	}
-
-	if (isRecord(value.geoWithin)) {
-		const geoFilter = createGeoDistanceFilter(
-			value.geoWithin as GeoWithinOperand,
-			fields,
-			undefined,
-			fieldName,
-		);
-		if (geoFilter) {
-			filters.push(geoFilter);
-		}
-	}
-
-	if (filters.length === 0) {
-		return eq(field as never, value as never);
-	}
-
-	if (filters.length === 1) {
-		return filters[0];
-	}
-
-	return and(...filters);
-}
-
-function buildWhereFilter(
-	table: unknown,
-	where?: Record<string, unknown>,
-	tableName?: string,
-): SQL | undefined {
-	if (!table || !where || Object.keys(where).length === 0) {
-		return undefined;
-	}
-
-	const fields = getTableColumns(table as never) as Record<string, unknown>;
-	return buildWhereFilterFromFields(fields, where, tableName);
-}
-
-function buildWhereFilterFromFields(
-	fields: Record<string, unknown>,
-	where?: Record<string, unknown>,
-	tableName?: string,
-): SQL | undefined {
-	if (!where || Object.keys(where).length === 0) {
-		return undefined;
-	}
-
-	const filters: SQL[] = [];
-
-	const topLevelGeoWithin = isRecord(where.geoWithin)
-		? (where.geoWithin as GeoWithinOperand)
-		: isRecord(where.$geoWithin)
-			? (where.$geoWithin as GeoWithinOperand)
-			: undefined;
-
-	if (topLevelGeoWithin) {
-		const geoFilter = createGeoDistanceFilter(topLevelGeoWithin, fields, tableName);
-		if (geoFilter) {
-			filters.push(geoFilter);
-		}
-	}
-
-	for (const [fieldName, fieldValue] of Object.entries(where)) {
-		if (fieldName === "geoWithin" || fieldName === "$geoWithin") {
-			continue;
-		}
-
-		if (fieldValue === undefined) {
-			continue;
-		}
-
-		const field = fields[fieldName];
-		if (!field) {
-			continue;
-		}
-
-		const filter = buildFieldFilter(fieldName, field, fieldValue, fields);
-		if (filter) {
-			filters.push(filter);
-		}
-	}
-
-	if (filters.length === 0) {
-		return undefined;
-	}
-
-	if (filters.length === 1) {
-		return filters[0];
-	}
-
-	return and(...filters);
-}
-
-type ManyToManyRuntimeRelation = {
-	targetTable: string;
-	junctionTable: string;
-	sourceField?: string;
-	targetField?: string;
-	referenceField?: string;
-	targetReferenceField?: string;
-};
-
-type RuntimeRelationOne = {
-	kind: "one";
-	targetTable: string;
-	sourceField?: string;
-	referenceField?: string;
-};
-
-type RuntimeRelationMany = {
-	kind: "many";
-	targetTable: string;
-	sourceField?: string;
-	referenceField?: string;
-};
-
-type RuntimeRelationManyToMany = ManyToManyRuntimeRelation & {
-	kind: "manyToMany";
-};
-
-type RuntimeRelation =
-	| RuntimeRelationOne
-	| RuntimeRelationMany
-	| RuntimeRelationManyToMany;
-
-type RuntimeRelationMap = Record<string, Record<string, RuntimeRelation>>;
-
-function getRuntimeRelationMap(): RuntimeRelationMap {
-	const rawValue = (mergedSchema as Record<string, unknown>)[
-		"__appflareRelations"
-	];
-	if (!isRecord(rawValue)) {
-		return {};
-	}
-
-	const map: RuntimeRelationMap = {};
-	for (const [tableName, tableValue] of Object.entries(rawValue)) {
-		if (!isRecord(tableValue)) {
-			continue;
-		}
-
-		const relationMap: Record<string, RuntimeRelation> = {};
-		for (const [relationName, relationValue] of Object.entries(tableValue)) {
-			if (!isRecord(relationValue)) {
-				continue;
-			}
-
-			const kind = relationValue.kind;
-			const targetTable = relationValue.targetTable;
-			if (typeof kind !== "string" || typeof targetTable !== "string") {
-				continue;
-			}
-
-			const sourceField =
-				typeof relationValue.sourceField === "string"
-					? relationValue.sourceField
-					: undefined;
-			const referenceField =
-				typeof relationValue.referenceField === "string"
-					? relationValue.referenceField
-					: undefined;
-
-			if (kind === "one") {
-				relationMap[relationName] = {
-					kind: "one",
-					targetTable,
-					sourceField,
-					referenceField,
-				};
-				continue;
-			}
-
-			if (kind === "many") {
-				relationMap[relationName] = {
-					kind: "many",
-					targetTable,
-					sourceField,
-					referenceField,
-				};
-				continue;
-			}
-
-			if (kind === "manyToMany") {
-				const junctionTable = relationValue.junctionTable;
-				if (typeof junctionTable !== "string") {
-					continue;
-				}
-
-				relationMap[relationName] = {
-					kind: "manyToMany",
-					targetTable,
-					junctionTable,
-					sourceField,
-					targetField:
-						typeof relationValue.targetField === "string"
-							? relationValue.targetField
-							: undefined,
-					referenceField,
-					targetReferenceField:
-						typeof relationValue.targetReferenceField === "string"
-							? relationValue.targetReferenceField
-							: undefined,
-				};
-			}
-		}
-
-		if (Object.keys(relationMap).length > 0) {
-			map[tableName] = relationMap;
-		}
-	}
-
-	return map;
-}
-
-const runtimeRelationMap = getRuntimeRelationMap();
-
-function getRuntimeRelation(
-	tableName: string,
-	relationName: string,
-): RuntimeRelation | undefined {
-	return runtimeRelationMap[tableName]?.[relationName];
-}
-
-type ManyToManyRuntimeMap = Record<
-	string,
-	Record<string, ManyToManyRuntimeRelation>
->;
-
-function getManyToManyRuntimeMap(): ManyToManyRuntimeMap {
-	const rawValue = (mergedSchema as Record<string, unknown>)[
-		"__appflareManyToMany"
-	];
-	if (!isRecord(rawValue)) {
-		return {};
-	}
-
-	const map: ManyToManyRuntimeMap = {};
-	for (const [tableName, tableValue] of Object.entries(rawValue)) {
-		if (!isRecord(tableValue)) {
-			continue;
-		}
-
-		const relationMap: Record<string, ManyToManyRuntimeRelation> = {};
-		for (const [relationName, relationValue] of Object.entries(tableValue)) {
-			const runtimeRelation = getRuntimeRelation(tableName, relationName);
-			if (!runtimeRelation || runtimeRelation.kind !== "manyToMany") {
-				continue;
-			}
-
-			relationMap[relationName] = {
-				targetTable: runtimeRelation.targetTable,
-				junctionTable: runtimeRelation.junctionTable,
-				sourceField: runtimeRelation.sourceField,
-				targetField: runtimeRelation.targetField,
-				referenceField: runtimeRelation.referenceField,
-				targetReferenceField: runtimeRelation.targetReferenceField,
-			};
-		}
-
-		if (Object.keys(relationMap).length > 0) {
-			map[tableName] = relationMap;
-		}
-	}
-
-	return map;
-}
-
-const manyToManyRuntimeMap = getManyToManyRuntimeMap();
-
-function getManyToManyRelation(
-	tableName: string,
-	relationName: string,
-): ManyToManyRuntimeRelation | undefined {
-	return manyToManyRuntimeMap[tableName]?.[relationName];
-}
-
-function hasManyToManyRelationsInWith(
-	tableName: string,
-	withValue: unknown,
-): boolean {
-	if (!isRecord(withValue)) {
-		return false;
-	}
-
-	for (const [relationName, relationValue] of Object.entries(withValue)) {
-		const manyToMany = getManyToManyRelation(tableName, relationName);
-		if (manyToMany) {
-			return true;
-		}
-
-		if (!isRecord(relationValue)) {
-			continue;
-		}
-
-		const nestedWith = relationValue.with;
-		if (hasManyToManyRelationsInWith(relationName, nestedWith)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-function flattenManyToManyResult(
-	tableName: string,
-	result: unknown,
-	withValue: unknown,
-): unknown {
-	if (!isRecord(withValue)) {
-		return result;
-	}
-
-	if (Array.isArray(result)) {
-		return result.map((entry) =>
-			flattenManyToManyResult(tableName, entry, withValue),
-		);
-	}
-
-	if (!isRecord(result)) {
-		return result;
-	}
-
-	const nextRow: Record<string, unknown> = {
-		...result,
-	};
-
-	for (const [relationName, relationValue] of Object.entries(withValue)) {
-		const manyToMany = getManyToManyRelation(tableName, relationName);
-		const currentValue = nextRow[relationName];
-
-		if (manyToMany) {
-			const relationEntries = Array.isArray(currentValue)
-				? currentValue
-				: currentValue === null || currentValue === undefined
-					? []
-					: [currentValue];
-
-			const nestedWith =
-				isRecord(relationValue) && relationValue.with !== undefined
-					? relationValue.with
-					: undefined;
-
-			const flattened = relationEntries
-				.map((entry) => {
-					if (!isRecord(entry)) {
-						return undefined;
-					}
-
-					const targetValue = entry[manyToMany.targetTable];
-					return flattenManyToManyResult(
-						manyToMany.targetTable,
-						targetValue,
-						nestedWith,
-					);
-				})
-				.filter((entry) => entry !== undefined && entry !== null);
-
-			nextRow[relationName] = flattened;
-			continue;
-		}
-
-		if (isRecord(relationValue) && relationValue.with !== undefined) {
-			nextRow[relationName] = flattenManyToManyResult(
-				relationName,
-				currentValue,
-				relationValue.with,
-			);
-		}
-	}
-
-	return nextRow;
-}
-
-function transformWithRelations(withValue: unknown, tableName?: string): unknown {
-	return transformWithRelationsAndExtractAggregates(withValue, tableName).with;
-}
-
-type RelationWithAggregatePlanEntry = {
-	count: boolean;
-	avgFields: string[];
-	nested?: RelationWithAggregatePlan;
-};
-
-type RelationWithAggregatePlan = Record<string, RelationWithAggregatePlanEntry>;
-
-function hasRelationAggregatePlanEntries(
-	plan: RelationWithAggregatePlan | undefined,
-): plan is RelationWithAggregatePlan {
-	return !!plan && Object.keys(plan).length > 0;
-}
-
-function extractRelationAvgFieldNames(value: unknown): string[] {
-	if (!isRecord(value)) {
-		return [];
-	}
-
-	return Object.entries(value)
-		.filter(([, enabled]) => enabled === true)
-		.map(([fieldName]) => fieldName);
-}
-
-function transformWithRelationsAndExtractAggregates(
-	withValue: unknown,
-	tableName?: string,
-): {
-	with: unknown;
-	aggregatePlan: RelationWithAggregatePlan | undefined;
-} {
-	if (!isRecord(withValue)) {
-		return {
-			with: withValue,
-			aggregatePlan: undefined,
-		};
-	}
-
-	const transformed: Record<string, unknown> = {};
-	const aggregatePlan: RelationWithAggregatePlan = {};
-	for (const [relationName, relationValue] of Object.entries(withValue)) {
-		const manyToMany =
-			tableName === undefined
-				? undefined
-				: getManyToManyRelation(tableName, relationName);
-
-		if (typeof relationValue === "boolean") {
-			if (manyToMany && relationValue) {
-				transformed[relationName] = {
-					with: {
-						[manyToMany.targetTable]: true,
-					},
-				};
-			} else {
-				transformed[relationName] = relationValue;
-			}
-			continue;
-		}
-
-		if (!isRecord(relationValue)) {
-			transformed[relationName] = relationValue;
-			continue;
-		}
-
-		const relationConfigInput: Record<string, unknown> = {
-			...relationValue,
-		};
-		const countRequested = relationConfigInput._count === true;
-		const avgFieldNames = extractRelationAvgFieldNames(relationConfigInput._avg);
-		delete relationConfigInput._count;
-		delete relationConfigInput._avg;
-
-		const relationConfig: Record<string, unknown> = manyToMany
-			? {
-				...relationConfigInput,
-			}
-			: relationConfigInput;
-
-		let nestedAggregatePlan: RelationWithAggregatePlan | undefined;
-
-		const relationWhere = relationConfig.where;
-		if (relationWhere !== undefined && !isRecord(relationWhere)) {
-			throw new Error(
-				"Invalid relational with.where for relation " +
-					relationName +
-					": only shorthand object filters are supported.",
-			);
-		}
-
-		if (isRecord(relationWhere) && !manyToMany) {
-			relationConfig.where = (fields: Record<string, unknown>) => {
-				const filter = buildWhereFilterFromFields(
-					fields,
-					relationWhere,
-					relationName,
-				);
-				if (filter) {
-					return filter;
-				}
-
-				return sql\`1 = 1\`;
-			};
-		}
-
-		if (manyToMany) {
-			const targetRelationConfig: Record<string, unknown> = {};
-			for (const [configKey, configValue] of Object.entries(relationConfig)) {
-				if (configKey === "with" || configKey === "where") {
-					continue;
-				}
-				targetRelationConfig[configKey] = configValue;
-			}
-
-			if (isRecord(relationWhere)) {
-				targetRelationConfig.where = (fields: Record<string, unknown>) => {
-					const filter = buildWhereFilterFromFields(
-						fields,
-						relationWhere,
-						manyToMany.targetTable,
-					);
-					if (filter) {
-						return filter;
-					}
-
-					return sql\`1 = 1\`;
-				};
-			}
-
-			if (relationConfig.with !== undefined) {
-				const nestedTransform = transformWithRelationsAndExtractAggregates(
-					relationConfig.with,
-					manyToMany.targetTable,
-				);
-				targetRelationConfig.with = nestedTransform.with;
-				nestedAggregatePlan = nestedTransform.aggregatePlan;
-			}
-
-			const targetConfigValue =
-				Object.keys(targetRelationConfig).length === 0
-					? true
-					: targetRelationConfig;
-
-			relationConfig.with = {
-				[manyToMany.targetTable]: targetConfigValue,
-			};
-			delete relationConfig.where;
-		} else if (relationConfig.with !== undefined) {
-			const nestedTransform = transformWithRelationsAndExtractAggregates(
-				relationConfig.with,
-				relationName,
-			);
-			relationConfig.with = nestedTransform.with;
-			nestedAggregatePlan = nestedTransform.aggregatePlan;
-		}
-
-		if (
-			countRequested ||
-			avgFieldNames.length > 0 ||
-			hasRelationAggregatePlanEntries(nestedAggregatePlan)
-		) {
-			aggregatePlan[relationName] = {
-				count: countRequested,
-				avgFields: avgFieldNames,
-				...(nestedAggregatePlan
-					? { nested: nestedAggregatePlan }
-					: {}),
-			};
-		}
-
-		transformed[relationName] = relationConfig;
-	}
-
-	return {
-		with: transformed,
-		aggregatePlan: hasRelationAggregatePlanEntries(aggregatePlan)
-			? aggregatePlan
-			: undefined,
-	};
-}
-
-function computeAverageOrZero(values: number[]): number {
-	if (values.length === 0) {
-		return 0;
-	}
-
-	const total = values.reduce((sum, current) => sum + current, 0);
-	return total / values.length;
-}
-
-function applyRelationAggregatePlanToRow(
-	row: unknown,
-	plan: RelationWithAggregatePlan,
-): unknown {
-	if (!isRecord(row)) {
-		return row;
-	}
-
-	const nextRow: Record<string, unknown> = {
-		...row,
-	};
-
-	for (const [relationName, relationPlan] of Object.entries(plan)) {
-		const relationData = nextRow[relationName];
-		const relationEntries = Array.isArray(relationData)
-			? relationData.filter((entry) => entry !== null && entry !== undefined)
-			: relationData === null || relationData === undefined
-				? []
-				: [relationData];
-
-		if (relationPlan.nested) {
-			if (Array.isArray(relationData)) {
-				nextRow[relationName] = relationData.map((entry) =>
-					applyRelationAggregatePlanToRow(entry, relationPlan.nested as RelationWithAggregatePlan),
-				);
-			} else if (isRecord(relationData)) {
-				nextRow[relationName] = applyRelationAggregatePlanToRow(
-					relationData,
-					relationPlan.nested,
-				);
-			}
-		}
-
-		if (!relationPlan.count && relationPlan.avgFields.length === 0) {
-			continue;
-		}
-
-		const aggregatePayload: Record<string, unknown> = {};
-		if (relationPlan.count) {
-			aggregatePayload.count = relationEntries.length;
-		}
-
-		if (relationPlan.avgFields.length > 0) {
-			const averagePayload: Record<string, number> = {};
-			for (const fieldName of relationPlan.avgFields) {
-				const numericValues = relationEntries
-					.map((entry) =>
-						isRecord(entry) ? toFiniteNumber(entry[fieldName]) : null,
-					)
-					.filter((value): value is number => value !== null);
-				averagePayload[fieldName] = computeAverageOrZero(numericValues);
-			}
-			aggregatePayload.avg = averagePayload;
-		}
-
-		nextRow[relationName + "Aggregate"] = aggregatePayload;
-	}
-
-	return nextRow;
-}
-
-function applyRelationAggregatePlanToResult(
-	result: unknown,
-	plan: RelationWithAggregatePlan | undefined,
-): unknown {
-	if (!hasRelationAggregatePlanEntries(plan)) {
-		return result;
-	}
-
-	if (Array.isArray(result)) {
-		return result.map((row) => applyRelationAggregatePlanToRow(row, plan));
-	}
-
-	if (result === null || result === undefined) {
-		return result;
-	}
-
-	return applyRelationAggregatePlanToRow(result, plan);
-}
-
-function hasAggregateWithConstraints(withValue: unknown): boolean {
-	if (!isRecord(withValue)) {
-		return false;
-	}
-
-	for (const relationValue of Object.values(withValue)) {
-		if (!isRecord(relationValue)) {
-			continue;
-		}
-
-		if (isRecord(relationValue.where)) {
-			return true;
-		}
-
-		if (hasAggregateWithConstraints(relationValue.with)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-function rowMatchesAggregateWithConstraints(
-	row: unknown,
-	withValue: unknown,
-): boolean {
-	if (!isRecord(withValue)) {
-		return true;
-	}
-
-	if (!isRecord(row)) {
-		return !hasAggregateWithConstraints(withValue);
-	}
-
-	for (const [relationName, relationValue] of Object.entries(withValue)) {
-		if (!isRecord(relationValue)) {
-			continue;
-		}
-
-		const nestedWith = relationValue.with;
-		const requiresPresence =
-			isRecord(relationValue.where) || hasAggregateWithConstraints(nestedWith);
-		if (!requiresPresence) {
-			continue;
-		}
-
-		const relationData = row[relationName];
-		if (Array.isArray(relationData)) {
-			if (relationData.length === 0) {
-				return false;
-			}
-
-			if (hasAggregateWithConstraints(nestedWith)) {
-				const hasNestedMatch = relationData.some((entry) =>
-					rowMatchesAggregateWithConstraints(entry, nestedWith),
-				);
-				if (!hasNestedMatch) {
-					return false;
-				}
-			}
-
-			continue;
-		}
-
-		if (!isRecord(relationData)) {
-			return false;
-		}
-
-		if (
-			hasAggregateWithConstraints(nestedWith) &&
-			!rowMatchesAggregateWithConstraints(relationData, nestedWith)
-		) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-function splitAggregateFieldPath(field: string): string[] {
-	return field
-		.split(".")
-		.map((segment) => segment.trim())
-		.filter((segment) => segment.length > 0);
-}
-
-function collectValuesFromPath(
-	value: unknown,
-	pathSegments: string[],
-	index = 0,
-): unknown[] {
-	if (index >= pathSegments.length) {
-		return [value];
-	}
-
-	if (value === null || value === undefined) {
-		return [];
-	}
-
-	if (Array.isArray(value)) {
-		return value.flatMap((entry) =>
-			collectValuesFromPath(entry, pathSegments, index),
-		);
-	}
-
-	if (!isRecord(value)) {
-		return [];
-	}
-
-	const nextValue = value[pathSegments[index]];
-	return collectValuesFromPath(nextValue, pathSegments, index + 1);
-}
-
-function createDistinctValueKey(value: unknown): string {
-	if (value instanceof Date) {
-		return "date:" + value.toISOString();
-	}
-
-	if (Array.isArray(value)) {
-		return (
-			"[" + value.map((entry) => createDistinctValueKey(entry)).join(",") + "]"
-		);
-	}
-
-	if (isRecord(value)) {
-		const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
-		return (
-			"{" +
-			keys
-				.map((key) => JSON.stringify(key) + ":" + createDistinctValueKey(value[key]))
-				.join(",") +
-			"}"
-		);
-	}
-
-	if (value === null) {
-		return "null";
-	}
-
-	if (value === undefined) {
-		return "undefined";
-	}
-
-	if (typeof value === "number" && Number.isNaN(value)) {
-		return "number:NaN";
-	}
-
-	return typeof value + ":" + String(value);
-}
-
-function countAggregateValues(values: unknown[], distinct: boolean): number {
-	const nonNullValues = values.filter(
-		(value) => value !== null && value !== undefined,
-	);
-	if (!distinct) {
-		return nonNullValues.length;
-	}
-
-	const seen = new Set<string>();
-	for (const value of nonNullValues) {
-		seen.add(createDistinctValueKey(value));
-	}
-
-	return seen.size;
-}
-
-function toFiniteNumber(value: unknown): number | null {
-	if (typeof value !== "number" || !Number.isFinite(value)) {
-		return null;
-	}
-
-	return value;
-}
-
-function averageAggregateValues(values: number[]): number | null {
-	if (values.length === 0) {
-		return null;
-	}
-
-	const total = values.reduce((sum, current) => sum + current, 0);
-	return total / values.length;
-}
-
-function inferConflictTarget(table: unknown): string[] {
-	if (!table) {
-		return [];
-	}
-
-	const columns = getTableColumns(table as never) as Record<string, unknown>;
-	if (columns.id) {
-		return ["id"];
-	}
-
-	return [];
-}
-`;
-}
+export function generateQueryHelperFunctionsSection(): string {
+	return `function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function readOperatorValue(record: Record<string, unknown>, key: string): unknown {
+	if (record[key] !== undefined) {
+		return record[key];
+	}
+	const prefixed = "$" + key;
+	return record[prefixed];
+}
+
+function normalizeGeoPoint(
+	value: GeoPoint | GeoCoordinates,
+): { latitude: number; longitude: number } | null {
+	if ((value as GeoPoint).latitude !== undefined) {
+		const point = value as GeoPoint;
+		if (
+			typeof point.latitude === "number" &&
+			typeof point.longitude === "number"
+		) {
+			return {
+				latitude: point.latitude,
+				longitude: point.longitude,
+			};
+		}
+		return null;
+	}
+
+	const coordinates = (value as GeoCoordinates).coordinates;
+	if (!Array.isArray(coordinates) || coordinates.length < 2) {
+		return null;
+	}
+
+	const [longitude, latitude] = coordinates;
+	if (typeof latitude !== "number" || typeof longitude !== "number") {
+		return null;
+	}
+
+	return {
+		latitude,
+		longitude,
+	};
+}
+
+function createGeoDistanceFilter(
+	operand: GeoWithinOperand,
+	fields: Record<string, unknown>,
+	tableName?: string,
+	fallbackLatitudeField?: string,
+): SQL | undefined {
+	const geometry = normalizeGeoPoint(operand.$geometry);
+	if (!geometry) {
+		return undefined;
+	}
+
+	const latitudeField = operand.latitudeField ?? fallbackLatitudeField;
+	const longitudeField = operand.longitudeField;
+	if (!latitudeField || !longitudeField) {
+		return undefined;
+	}
+
+	const latitudeColumn = fields[latitudeField];
+	if (!latitudeColumn) {
+		console.warn(
+			"Invalid geoWithin latitudeField",
+			tableName ?? "unknown",
+			latitudeField,
+		);
+		return undefined;
+	}
+
+	const longitudeColumn = fields[longitudeField];
+	if (!longitudeColumn) {
+		console.warn(
+			"Invalid geoWithin longitudeField",
+			tableName ?? "unknown",
+			longitudeField,
+		);
+		return undefined;
+	}
+
+	const distanceExpression = sql<number>\`(
+		6371000 * acos(
+			cos(radians(\${geometry.latitude})) * cos(radians(\${latitudeColumn}))
+			* cos(radians(\${longitudeColumn}) - radians(\${geometry.longitude}))
+			+ sin(radians(\${geometry.latitude})) * sin(radians(\${latitudeColumn}))
+		)
+	)\`;
+
+	const minDistance =
+		operand.$minDistance ??
+		operand.gte ??
+		operand.$gte ??
+		operand.gt ??
+		operand.$gt;
+	const maxDistance =
+		operand.$maxDistance ??
+		operand.lte ??
+		operand.$lte ??
+		operand.lt ??
+		operand.$lt;
+
+	const filters: SQL[] = [];
+	if (typeof minDistance === "number") {
+		filters.push(sql\`\${distanceExpression} >= \${minDistance}\`);
+	}
+	if (typeof maxDistance === "number") {
+		filters.push(sql\`\${distanceExpression} <= \${maxDistance}\`);
+	}
+
+	if (filters.length === 0) {
+		return undefined;
+	}
+
+	if (filters.length === 1) {
+		return filters[0];
+	}
+
+	return and(...filters);
+}
+
+function buildFieldFilter(
+	fieldName: string,
+	field: unknown,
+	value: unknown,
+	fields: Record<string, unknown>,
+): SQL | undefined {
+	if (!isRecord(value) || value instanceof Date || Array.isArray(value)) {
+		return eq(field as never, value as never);
+	}
+
+	const filters: SQL[] = [];
+	const eqValue = readOperatorValue(value, "eq");
+	if (eqValue !== undefined) {
+		filters.push(eq(field as never, eqValue as never));
+	}
+
+	const neValue = readOperatorValue(value, "ne");
+	if (neValue !== undefined) {
+		filters.push(ne(field as never, neValue as never));
+	}
+
+	const inValue = readOperatorValue(value, "in");
+	if (Array.isArray(inValue) && inValue.length > 0) {
+		filters.push(inArray(field as never, inValue as never));
+	}
+
+	const ninValue = readOperatorValue(value, "nin");
+	if (Array.isArray(ninValue) && ninValue.length > 0) {
+		filters.push(notInArray(field as never, ninValue as never));
+	}
+
+	const gtValue = readOperatorValue(value, "gt");
+	if (gtValue !== undefined) {
+		filters.push(gt(field as never, gtValue as never));
+	}
+
+	const gteValue = readOperatorValue(value, "gte");
+	if (gteValue !== undefined) {
+		filters.push(gte(field as never, gteValue as never));
+	}
+
+	const ltValue = readOperatorValue(value, "lt");
+	if (ltValue !== undefined) {
+		filters.push(lt(field as never, ltValue as never));
+	}
+
+	const lteValue = readOperatorValue(value, "lte");
+	if (lteValue !== undefined) {
+		filters.push(lte(field as never, lteValue as never));
+	}
+
+	if (typeof value.exists === "boolean") {
+		filters.push(value.exists ? isNotNull(field as never) : isNull(field as never));
+	}
+
+	if (typeof value.regex === "string") {
+		const caseInsensitive = typeof value.$options === "string" && value.$options.includes("i");
+		const pattern = "%" + value.regex + "%";
+		if (caseInsensitive) {
+			filters.push(
+				sql\`lower(\${field as never}) like lower(\${pattern})\`,
+			);
+		} else {
+			filters.push(sql\`\${field as never} like \${pattern}\`);
+		}
+	}
+
+	if (isRecord(value.geoWithin)) {
+		const geoFilter = createGeoDistanceFilter(
+			value.geoWithin as GeoWithinOperand,
+			fields,
+			undefined,
+			fieldName,
+		);
+		if (geoFilter) {
+			filters.push(geoFilter);
+		}
+	}
+
+	if (filters.length === 0) {
+		return eq(field as never, value as never);
+	}
+
+	if (filters.length === 1) {
+		return filters[0];
+	}
+
+	return and(...filters);
+}
+
+function buildWhereFilter(
+	table: unknown,
+	where?: Record<string, unknown>,
+	tableName?: string,
+): SQL | undefined {
+	if (!table || !where || Object.keys(where).length === 0) {
+		return undefined;
+	}
+
+	const fields = getTableColumns(table as never) as Record<string, unknown>;
+	return buildWhereFilterFromFields(fields, where, tableName);
+}
+
+function buildWhereFilterFromFields(
+	fields: Record<string, unknown>,
+	where?: Record<string, unknown>,
+	tableName?: string,
+): SQL | undefined {
+	if (!where || Object.keys(where).length === 0) {
+		return undefined;
+	}
+
+	const filters: SQL[] = [];
+
+	const topLevelGeoWithin = isRecord(where.geoWithin)
+		? (where.geoWithin as GeoWithinOperand)
+		: isRecord(where.$geoWithin)
+			? (where.$geoWithin as GeoWithinOperand)
+			: undefined;
+
+	if (topLevelGeoWithin) {
+		const geoFilter = createGeoDistanceFilter(topLevelGeoWithin, fields, tableName);
+		if (geoFilter) {
+			filters.push(geoFilter);
+		}
+	}
+
+	for (const [fieldName, fieldValue] of Object.entries(where)) {
+		if (fieldName === "geoWithin" || fieldName === "$geoWithin") {
+			continue;
+		}
+
+		if (fieldValue === undefined) {
+			continue;
+		}
+
+		const field = fields[fieldName];
+		if (!field) {
+			if (isRecord(fieldValue) && tableName) {
+				const relation = getRuntimeRelation(tableName, fieldName);
+				if (relation) {
+					const relationFilter = buildRelationFilter(
+						relation,
+						fieldValue,
+						tableName,
+						fields,
+					);
+					if (relationFilter) {
+						filters.push(relationFilter);
+					}
+					continue;
+				}
+			}
+			continue;
+		}
+
+		const filter = buildFieldFilter(fieldName, field, fieldValue, fields);
+		if (filter) {
+			filters.push(filter);
+		}
+	}
+
+	if (filters.length === 0) {
+		return undefined;
+	}
+
+	if (filters.length === 1) {
+		return filters[0];
+	}
+
+	return and(...filters);
+}
+
+type ManyToManyRuntimeRelation = {
+	targetTable: string;
+	junctionTable: string;
+	sourceField?: string;
+	targetField?: string;
+	referenceField?: string;
+	targetReferenceField?: string;
+};
+
+type RuntimeRelationOne = {
+	kind: "one";
+	targetTable: string;
+	sourceField?: string;
+	referenceField?: string;
+};
+
+type RuntimeRelationMany = {
+	kind: "many";
+	targetTable: string;
+	sourceField?: string;
+	referenceField?: string;
+};
+
+type RuntimeRelationManyToMany = ManyToManyRuntimeRelation & {
+	kind: "manyToMany";
+};
+
+type RuntimeRelation =
+	| RuntimeRelationOne
+	| RuntimeRelationMany
+	| RuntimeRelationManyToMany;
+
+type RuntimeRelationMap = Record<string, Record<string, RuntimeRelation>>;
+
+function getRuntimeRelationMap(): RuntimeRelationMap {
+	const rawValue = (mergedSchema as Record<string, unknown>)[
+		"__appflareRelations"
+	];
+	if (!isRecord(rawValue)) {
+		return {};
+	}
+
+	const map: RuntimeRelationMap = {};
+	for (const [tableName, tableValue] of Object.entries(rawValue)) {
+		if (!isRecord(tableValue)) {
+			continue;
+		}
+
+		const relationMap: Record<string, RuntimeRelation> = {};
+		for (const [relationName, relationValue] of Object.entries(tableValue)) {
+			if (!isRecord(relationValue)) {
+				continue;
+			}
+
+			const kind = relationValue.kind;
+			const targetTable = relationValue.targetTable;
+			if (typeof kind !== "string" || typeof targetTable !== "string") {
+				continue;
+			}
+
+			const sourceField =
+				typeof relationValue.sourceField === "string"
+					? relationValue.sourceField
+					: undefined;
+			const referenceField =
+				typeof relationValue.referenceField === "string"
+					? relationValue.referenceField
+					: undefined;
+
+			if (kind === "one") {
+				relationMap[relationName] = {
+					kind: "one",
+					targetTable,
+					sourceField,
+					referenceField,
+				};
+				continue;
+			}
+
+			if (kind === "many") {
+				relationMap[relationName] = {
+					kind: "many",
+					targetTable,
+					sourceField,
+					referenceField,
+				};
+				continue;
+			}
+
+			if (kind === "manyToMany") {
+				const junctionTable = relationValue.junctionTable;
+				if (typeof junctionTable !== "string") {
+					continue;
+				}
+
+				relationMap[relationName] = {
+					kind: "manyToMany",
+					targetTable,
+					junctionTable,
+					sourceField,
+					targetField:
+						typeof relationValue.targetField === "string"
+							? relationValue.targetField
+							: undefined,
+					referenceField,
+					targetReferenceField:
+						typeof relationValue.targetReferenceField === "string"
+							? relationValue.targetReferenceField
+							: undefined,
+				};
+			}
+		}
+
+		if (Object.keys(relationMap).length > 0) {
+			map[tableName] = relationMap;
+		}
+	}
+
+	return map;
+}
+
+const runtimeRelationMap = getRuntimeRelationMap();
+
+function getRuntimeRelation(
+	tableName: string,
+	relationName: string,
+): RuntimeRelation | undefined {
+	return runtimeRelationMap[tableName]?.[relationName];
+}
+
+function buildRelationFilter(
+	relation: RuntimeRelation,
+	whereValue: Record<string, unknown>,
+	sourceTableName: string,
+	sourceFields: Record<string, unknown>
+): SQL | undefined {
+	const rawTargetTable = (mergedSchema as Record<string, unknown>)[relation.targetTable];
+	if (!rawTargetTable) {
+		return undefined;
+	}
+
+	const targetFields = getTableColumns(rawTargetTable as never) as Record<string, unknown>;
+	const relationFilter = buildWhereFilterFromFields(
+		targetFields,
+		whereValue,
+		relation.targetTable,
+	);
+
+	if (!relationFilter) {
+		return undefined;
+	}
+
+	if (relation.kind === "one") {
+		const sourceField = relation.sourceField || (relation.targetTable + "Id");
+		const targetFieldCol = targetFields[relation.referenceField || "id"];
+		const sourceFieldCol = sourceFields[sourceField];
+		if (!targetFieldCol || !sourceFieldCol) return undefined;
+		return sql\`exists (select 1 from \${rawTargetTable as never} where \${eq(targetFieldCol as never, sourceFieldCol as never)} and \${relationFilter})\`;
+	}
+
+	if (relation.kind === "many") {
+		const sourceFieldCol = sourceFields[relation.sourceField || "id"];
+		const targetFieldCol = targetFields[relation.referenceField || (sourceTableName + "Id")];
+		if (!targetFieldCol || !sourceFieldCol) return undefined;
+		return sql\`exists (select 1 from \${rawTargetTable as never} where \${eq(targetFieldCol as never, sourceFieldCol as never)} and \${relationFilter})\`;
+	}
+
+	if (relation.kind === "manyToMany") {
+		const junctionTableName = (relation as RuntimeRelationManyToMany).junctionTable;
+		const junctionTable = (mergedSchema as Record<string, unknown>)[junctionTableName];
+		if (!junctionTable) return undefined;
+		const junctionFields = getTableColumns(junctionTable as never) as Record<string, unknown>;
+
+		const sourceFieldCol = sourceFields[(relation as RuntimeRelationManyToMany).sourceField || "id"];
+		const targetFieldCol = targetFields[(relation as RuntimeRelationManyToMany).targetField || "id"];
+		
+		const junctionSourceRefCol = junctionFields[(relation as RuntimeRelationManyToMany).referenceField || (sourceTableName + "Id")];
+		const junctionTargetRefCol = junctionFields[(relation as RuntimeRelationManyToMany).targetReferenceField || (relation.targetTable + "Id")];
+
+		if (!sourceFieldCol || !targetFieldCol || !junctionSourceRefCol || !junctionTargetRefCol) return undefined;
+
+		return sql\`exists (select 1 from \${junctionTable as never} inner join \${rawTargetTable as never} on \${eq(junctionTargetRefCol as never, targetFieldCol as never)} where \${eq(junctionSourceRefCol as never, sourceFieldCol as never)} and \${relationFilter})\`;
+	}
+
+	return undefined;
+}
+
+type ManyToManyRuntimeMap = Record<
+	string,
+	Record<string, ManyToManyRuntimeRelation>
+>;
+
+function getManyToManyRuntimeMap(): ManyToManyRuntimeMap {
+	const rawValue = (mergedSchema as Record<string, unknown>)[
+		"__appflareManyToMany"
+	];
+	if (!isRecord(rawValue)) {
+		return {};
+	}
+
+	const map: ManyToManyRuntimeMap = {};
+	for (const [tableName, tableValue] of Object.entries(rawValue)) {
+		if (!isRecord(tableValue)) {
+			continue;
+		}
+
+		const relationMap: Record<string, ManyToManyRuntimeRelation> = {};
+		for (const [relationName, relationValue] of Object.entries(tableValue)) {
+			const runtimeRelation = getRuntimeRelation(tableName, relationName);
+			if (!runtimeRelation || runtimeRelation.kind !== "manyToMany") {
+				continue;
+			}
+
+			relationMap[relationName] = {
+				targetTable: runtimeRelation.targetTable,
+				junctionTable: runtimeRelation.junctionTable,
+				sourceField: runtimeRelation.sourceField,
+				targetField: runtimeRelation.targetField,
+				referenceField: runtimeRelation.referenceField,
+				targetReferenceField: runtimeRelation.targetReferenceField,
+			};
+		}
+
+		if (Object.keys(relationMap).length > 0) {
+			map[tableName] = relationMap;
+		}
+	}
+
+	return map;
+}
+
+const manyToManyRuntimeMap = getManyToManyRuntimeMap();
+
+function getManyToManyRelation(
+	tableName: string,
+	relationName: string,
+): ManyToManyRuntimeRelation | undefined {
+	return manyToManyRuntimeMap[tableName]?.[relationName];
+}
+
+function hasManyToManyRelationsInWith(
+	tableName: string,
+	withValue: unknown,
+): boolean {
+	if (!isRecord(withValue)) {
+		return false;
+	}
+
+	for (const [relationName, relationValue] of Object.entries(withValue)) {
+		const manyToMany = getManyToManyRelation(tableName, relationName);
+		if (manyToMany) {
+			return true;
+		}
+
+		if (!isRecord(relationValue)) {
+			continue;
+		}
+
+		const nestedWith = relationValue.with;
+		if (hasManyToManyRelationsInWith(relationName, nestedWith)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function flattenManyToManyResult(
+	tableName: string,
+	result: unknown,
+	withValue: unknown,
+): unknown {
+	if (!isRecord(withValue)) {
+		return result;
+	}
+
+	if (Array.isArray(result)) {
+		return result.map((entry) =>
+			flattenManyToManyResult(tableName, entry, withValue),
+		);
+	}
+
+	if (!isRecord(result)) {
+		return result;
+	}
+
+	const nextRow: Record<string, unknown> = {
+		...result,
+	};
+
+	for (const [relationName, relationValue] of Object.entries(withValue)) {
+		const manyToMany = getManyToManyRelation(tableName, relationName);
+		const currentValue = nextRow[relationName];
+
+		if (manyToMany) {
+			const relationEntries = Array.isArray(currentValue)
+				? currentValue
+				: currentValue === null || currentValue === undefined
+					? []
+					: [currentValue];
+
+			const nestedWith =
+				isRecord(relationValue) && relationValue.with !== undefined
+					? relationValue.with
+					: undefined;
+
+			const flattened = relationEntries
+				.map((entry) => {
+					if (!isRecord(entry)) {
+						return undefined;
+					}
+
+					const targetValue = entry[manyToMany.targetTable];
+					return flattenManyToManyResult(
+						manyToMany.targetTable,
+						targetValue,
+						nestedWith,
+					);
+				})
+				.filter((entry) => entry !== undefined && entry !== null);
+
+			nextRow[relationName] = flattened;
+			continue;
+		}
+
+		if (isRecord(relationValue) && relationValue.with !== undefined) {
+			nextRow[relationName] = flattenManyToManyResult(
+				relationName,
+				currentValue,
+				relationValue.with,
+			);
+		}
+	}
+
+	return nextRow;
+}
+
+function transformWithRelations(withValue: unknown, tableName?: string): unknown {
+	return transformWithRelationsAndExtractAggregates(withValue, tableName).with;
+}
+
+type RelationWithAggregatePlanEntry = {
+	count: boolean;
+	avgFields: string[];
+	nested?: RelationWithAggregatePlan;
+};
+
+type RelationWithAggregatePlan = Record<string, RelationWithAggregatePlanEntry>;
+
+function hasRelationAggregatePlanEntries(
+	plan: RelationWithAggregatePlan | undefined,
+): plan is RelationWithAggregatePlan {
+	return !!plan && Object.keys(plan).length > 0;
+}
+
+function extractRelationAvgFieldNames(value: unknown): string[] {
+	if (!isRecord(value)) {
+		return [];
+	}
+
+	return Object.entries(value)
+		.filter(([, enabled]) => enabled === true)
+		.map(([fieldName]) => fieldName);
+}
+
+function transformWithRelationsAndExtractAggregates(
+	withValue: unknown,
+	tableName?: string,
+): {
+	with: unknown;
+	aggregatePlan: RelationWithAggregatePlan | undefined;
+} {
+	if (!isRecord(withValue)) {
+		return {
+			with: withValue,
+			aggregatePlan: undefined,
+		};
+	}
+
+	const transformed: Record<string, unknown> = {};
+	const aggregatePlan: RelationWithAggregatePlan = {};
+	for (const [relationName, relationValue] of Object.entries(withValue)) {
+		const manyToMany =
+			tableName === undefined
+				? undefined
+				: getManyToManyRelation(tableName, relationName);
+
+		if (typeof relationValue === "boolean") {
+			if (manyToMany && relationValue) {
+				transformed[relationName] = {
+					with: {
+						[manyToMany.targetTable]: true,
+					},
+				};
+			} else {
+				transformed[relationName] = relationValue;
+			}
+			continue;
+		}
+
+		if (!isRecord(relationValue)) {
+			transformed[relationName] = relationValue;
+			continue;
+		}
+
+		const relationConfigInput: Record<string, unknown> = {
+			...relationValue,
+		};
+		const countRequested = relationConfigInput._count === true;
+		const avgFieldNames = extractRelationAvgFieldNames(relationConfigInput._avg);
+		delete relationConfigInput._count;
+		delete relationConfigInput._avg;
+
+		const relationConfig: Record<string, unknown> = manyToMany
+			? {
+				...relationConfigInput,
+			}
+			: relationConfigInput;
+
+		let nestedAggregatePlan: RelationWithAggregatePlan | undefined;
+
+		const relationWhere = relationConfig.where;
+		if (relationWhere !== undefined && !isRecord(relationWhere)) {
+			throw new Error(
+				"Invalid relational with.where for relation " +
+					relationName +
+					": only shorthand object filters are supported.",
+			);
+		}
+
+		if (isRecord(relationWhere) && !manyToMany) {
+			relationConfig.where = (fields: Record<string, unknown>) => {
+				const filter = buildWhereFilterFromFields(
+					fields,
+					relationWhere,
+					relationName,
+				);
+				if (filter) {
+					return filter;
+				}
+
+				return sql\`1 = 1\`;
+			};
+		}
+
+		if (manyToMany) {
+			const targetRelationConfig: Record<string, unknown> = {};
+			for (const [configKey, configValue] of Object.entries(relationConfig)) {
+				if (configKey === "with" || configKey === "where") {
+					continue;
+				}
+				targetRelationConfig[configKey] = configValue;
+			}
+
+			if (isRecord(relationWhere)) {
+				targetRelationConfig.where = (fields: Record<string, unknown>) => {
+					const filter = buildWhereFilterFromFields(
+						fields,
+						relationWhere,
+						manyToMany.targetTable,
+					);
+					if (filter) {
+						return filter;
+					}
+
+					return sql\`1 = 1\`;
+				};
+			}
+
+			if (relationConfig.with !== undefined) {
+				const nestedTransform = transformWithRelationsAndExtractAggregates(
+					relationConfig.with,
+					manyToMany.targetTable,
+				);
+				targetRelationConfig.with = nestedTransform.with;
+				nestedAggregatePlan = nestedTransform.aggregatePlan;
+			}
+
+			const targetConfigValue =
+				Object.keys(targetRelationConfig).length === 0
+					? true
+					: targetRelationConfig;
+
+			relationConfig.with = {
+				[manyToMany.targetTable]: targetConfigValue,
+			};
+			delete relationConfig.where;
+		} else if (relationConfig.with !== undefined) {
+			const nestedTransform = transformWithRelationsAndExtractAggregates(
+				relationConfig.with,
+				relationName,
+			);
+			relationConfig.with = nestedTransform.with;
+			nestedAggregatePlan = nestedTransform.aggregatePlan;
+		}
+
+		if (
+			countRequested ||
+			avgFieldNames.length > 0 ||
+			hasRelationAggregatePlanEntries(nestedAggregatePlan)
+		) {
+			aggregatePlan[relationName] = {
+				count: countRequested,
+				avgFields: avgFieldNames,
+				...(nestedAggregatePlan
+					? { nested: nestedAggregatePlan }
+					: {}),
+			};
+		}
+
+		transformed[relationName] = relationConfig;
+	}
+
+	return {
+		with: transformed,
+		aggregatePlan: hasRelationAggregatePlanEntries(aggregatePlan)
+			? aggregatePlan
+			: undefined,
+	};
+}
+
+function computeAverageOrZero(values: number[]): number {
+	if (values.length === 0) {
+		return 0;
+	}
+
+	const total = values.reduce((sum, current) => sum + current, 0);
+	return total / values.length;
+}
+
+function applyRelationAggregatePlanToRow(
+	row: unknown,
+	plan: RelationWithAggregatePlan,
+): unknown {
+	if (!isRecord(row)) {
+		return row;
+	}
+
+	const nextRow: Record<string, unknown> = {
+		...row,
+	};
+
+	for (const [relationName, relationPlan] of Object.entries(plan)) {
+		const relationData = nextRow[relationName];
+		const relationEntries = Array.isArray(relationData)
+			? relationData.filter((entry) => entry !== null && entry !== undefined)
+			: relationData === null || relationData === undefined
+				? []
+				: [relationData];
+
+		if (relationPlan.nested) {
+			if (Array.isArray(relationData)) {
+				nextRow[relationName] = relationData.map((entry) =>
+					applyRelationAggregatePlanToRow(entry, relationPlan.nested as RelationWithAggregatePlan),
+				);
+			} else if (isRecord(relationData)) {
+				nextRow[relationName] = applyRelationAggregatePlanToRow(
+					relationData,
+					relationPlan.nested,
+				);
+			}
+		}
+
+		if (!relationPlan.count && relationPlan.avgFields.length === 0) {
+			continue;
+		}
+
+		const aggregatePayload: Record<string, unknown> = {};
+		if (relationPlan.count) {
+			aggregatePayload.count = relationEntries.length;
+		}
+
+		if (relationPlan.avgFields.length > 0) {
+			const averagePayload: Record<string, number> = {};
+			for (const fieldName of relationPlan.avgFields) {
+				const numericValues = relationEntries
+					.map((entry) =>
+						isRecord(entry) ? toFiniteNumber(entry[fieldName]) : null,
+					)
+					.filter((value): value is number => value !== null);
+				averagePayload[fieldName] = computeAverageOrZero(numericValues);
+			}
+			aggregatePayload.avg = averagePayload;
+		}
+
+		nextRow[relationName + "Aggregate"] = aggregatePayload;
+	}
+
+	return nextRow;
+}
+
+function applyRelationAggregatePlanToResult(
+	result: unknown,
+	plan: RelationWithAggregatePlan | undefined,
+): unknown {
+	if (!hasRelationAggregatePlanEntries(plan)) {
+		return result;
+	}
+
+	if (Array.isArray(result)) {
+		return result.map((row) => applyRelationAggregatePlanToRow(row, plan));
+	}
+
+	if (result === null || result === undefined) {
+		return result;
+	}
+
+	return applyRelationAggregatePlanToRow(result, plan);
+}
+
+function hasAggregateWithConstraints(withValue: unknown): boolean {
+	if (!isRecord(withValue)) {
+		return false;
+	}
+
+	for (const relationValue of Object.values(withValue)) {
+		if (!isRecord(relationValue)) {
+			continue;
+		}
+
+		if (isRecord(relationValue.where)) {
+			return true;
+		}
+
+		if (hasAggregateWithConstraints(relationValue.with)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function rowMatchesAggregateWithConstraints(
+	row: unknown,
+	withValue: unknown,
+): boolean {
+	if (!isRecord(withValue)) {
+		return true;
+	}
+
+	if (!isRecord(row)) {
+		return !hasAggregateWithConstraints(withValue);
+	}
+
+	for (const [relationName, relationValue] of Object.entries(withValue)) {
+		if (!isRecord(relationValue)) {
+			continue;
+		}
+
+		const nestedWith = relationValue.with;
+		const requiresPresence =
+			isRecord(relationValue.where) || hasAggregateWithConstraints(nestedWith);
+		if (!requiresPresence) {
+			continue;
+		}
+
+		const relationData = row[relationName];
+		if (Array.isArray(relationData)) {
+			if (relationData.length === 0) {
+				return false;
+			}
+
+			if (hasAggregateWithConstraints(nestedWith)) {
+				const hasNestedMatch = relationData.some((entry) =>
+					rowMatchesAggregateWithConstraints(entry, nestedWith),
+				);
+				if (!hasNestedMatch) {
+					return false;
+				}
+			}
+
+			continue;
+		}
+
+		if (!isRecord(relationData)) {
+			return false;
+		}
+
+		if (
+			hasAggregateWithConstraints(nestedWith) &&
+			!rowMatchesAggregateWithConstraints(relationData, nestedWith)
+		) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function splitAggregateFieldPath(field: string): string[] {
+	return field
+		.split(".")
+		.map((segment) => segment.trim())
+		.filter((segment) => segment.length > 0);
+}
+
+function collectValuesFromPath(
+	value: unknown,
+	pathSegments: string[],
+	index = 0,
+): unknown[] {
+	if (index >= pathSegments.length) {
+		return [value];
+	}
+
+	if (value === null || value === undefined) {
+		return [];
+	}
+
+	if (Array.isArray(value)) {
+		return value.flatMap((entry) =>
+			collectValuesFromPath(entry, pathSegments, index),
+		);
+	}
+
+	if (!isRecord(value)) {
+		return [];
+	}
+
+	const nextValue = value[pathSegments[index]];
+	return collectValuesFromPath(nextValue, pathSegments, index + 1);
+}
+
+function createDistinctValueKey(value: unknown): string {
+	if (value instanceof Date) {
+		return "date:" + value.toISOString();
+	}
+
+	if (Array.isArray(value)) {
+		return (
+			"[" + value.map((entry) => createDistinctValueKey(entry)).join(",") + "]"
+		);
+	}
+
+	if (isRecord(value)) {
+		const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+		return (
+			"{" +
+			keys
+				.map((key) => JSON.stringify(key) + ":" + createDistinctValueKey(value[key]))
+				.join(",") +
+			"}"
+		);
+	}
+
+	if (value === null) {
+		return "null";
+	}
+
+	if (value === undefined) {
+		return "undefined";
+	}
+
+	if (typeof value === "number" && Number.isNaN(value)) {
+		return "number:NaN";
+	}
+
+	return typeof value + ":" + String(value);
+}
+
+function countAggregateValues(values: unknown[], distinct: boolean): number {
+	const nonNullValues = values.filter(
+		(value) => value !== null && value !== undefined,
+	);
+	if (!distinct) {
+		return nonNullValues.length;
+	}
+
+	const seen = new Set<string>();
+	for (const value of nonNullValues) {
+		seen.add(createDistinctValueKey(value));
+	}
+
+	return seen.size;
+}
+
+function toFiniteNumber(value: unknown): number | null {
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		return null;
+	}
+
+	return value;
+}
+
+function averageAggregateValues(values: number[]): number | null {
+	if (values.length === 0) {
+		return null;
+	}
+
+	const total = values.reduce((sum, current) => sum + current, 0);
+	return total / values.length;
+}
+
+function inferConflictTarget(table: unknown): string[] {
+	if (!table) {
+		return [];
+	}
+
+	const columns = getTableColumns(table as never) as Record<string, unknown>;
+	if (columns.id) {
+		return ["id"];
+	}
+
+	return [];
+}
+`;
+}