appflare 0.2.4 → 0.2.7

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

@@ -0,0 +1,686 @@
+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);
+}
+
+function transformWithRelations(withValue: unknown): unknown {
+	return transformWithRelationsAndExtractAggregates(withValue).with;
+}
+
+type RelationWithAggregatePlanEntry = {
+	count: boolean;
+	avgFields: string[];
+	nested?: RelationWithAggregatePlan;
+};
+
+type RelationWithAggregatePlan = Record<string, RelationWithAggregatePlanEntry>;
+
+function hasRelationAggregatePlanEntries(
+	plan: RelationWithAggregatePlan | undefined,
+): boolean {
+	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): {
+	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)) {
+		if (typeof relationValue === "boolean") {
+			transformed[relationName] = relationValue;
+			continue;
+		}
+
+		if (!isRecord(relationValue)) {
+			transformed[relationName] = relationValue;
+			continue;
+		}
+
+		const relationConfig: Record<string, unknown> = {
+			...relationValue,
+		};
+		const countRequested = relationConfig._count === true;
+		const avgFieldNames = extractRelationAvgFieldNames(relationConfig._avg);
+		delete relationConfig._count;
+		delete relationConfig._avg;
+
+		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)) {
+			relationConfig.where = (fields: Record<string, unknown>) => {
+				const filter = buildWhereFilterFromFields(
+					fields,
+					relationWhere,
+					relationName,
+				);
+				if (filter) {
+					return filter;
+				}
+
+				return sql\`1 = 1\`;
+			};
+		}
+
+		if (relationConfig.with !== undefined) {
+			const nestedTransform = transformWithRelationsAndExtractAggregates(
+				relationConfig.with,
+			);
+			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 [];
+}
+`;
+}