appflare 0.0.28 → 0.1.1

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

@@ -0,0 +1,1029 @@
+export function generateTypesQueryDefinitionsSection(): string {
+	return `const mergedSchema = {
+	...authSchema,
+	...schema,
+};
+
+export const createDb = (database: D1Database) =>
+	drizzle(database, { schema: mergedSchema });
+
+export type AppflareDb = ReturnType<typeof createDb>;
+
+type QueryTables = AppflareDb["query"];
+type TableName = Extract<keyof QueryTables, string>;
+type TableQuery<TName extends TableName> = QueryTables[TName];
+type TableFindManyArgs<TName extends TableName> = TableQuery<TName> extends {
+	findMany: (args?: infer TArgs) => Promise<unknown>;
+}
+	? TArgs
+	: never;
+type TableFindManyResult<TName extends TableName> = TableQuery<TName> extends {
+	findMany: (args?: unknown) => infer TResult;
+}
+	? TResult
+	: Promise<Array<TableModel<TName>>>;
+type TableFindFirstArgs<TName extends TableName> = TableQuery<TName> extends {
+	findFirst: (args?: infer TArgs) => Promise<unknown>;
+}
+	? TArgs
+	: never;
+type TableFindFirstResult<TName extends TableName> = TableQuery<TName> extends {
+	findFirst: (args?: unknown) => infer TResult;
+}
+	? TResult
+	: Promise<TableModel<TName> | null>;
+type TableModel<TName extends TableName> = InferSelectModel<
+	(typeof mergedSchema)[TName]
+>;
+type TableInsertModel<TName extends TableName> = InferInsertModel<
+	(typeof mergedSchema)[TName]
+>;
+
+type Primitive = string | number | boolean | Date;
+type NonNil<T> = Exclude<T, null | undefined>;
+type Friendly<T> = T extends Date ? Date | number : T;
+type Comparable<T> = Friendly<Extract<NonNil<T>, Primitive>>;
+type RegexOperand<T> = T extends string ? string : never;
+
+type GeoPoint = {
+	latitude: number;
+	longitude: number;
+};
+
+type GeoCoordinates = {
+	type?: "Point";
+	coordinates: [number, number] | readonly [number, number];
+};
+
+type GeoWithinOperand = {
+	$geometry: GeoPoint | GeoCoordinates;
+	latitudeField?: string;
+	longitudeField?: string;
+	$minDistance?: number;
+	$maxDistance?: number;
+	gt?: number;
+	gte?: number;
+	lt?: number;
+	lte?: number;
+	$gt?: number;
+	$gte?: number;
+	$lt?: number;
+	$lte?: number;
+};
+
+type GeoWithinOperandForField<TFieldKey extends string> = Omit<
+	GeoWithinOperand,
+	"latitudeField" | "longitudeField"
+> & {
+	latitudeField?: TFieldKey;
+	longitudeField?: TFieldKey;
+};
+
+type FieldOperators<T, TFieldKey extends string = string> = {
+	eq?: Friendly<NonNil<T>>;
+	$eq?: Friendly<NonNil<T>>;
+	ne?: Friendly<NonNil<T>>;
+	$ne?: Friendly<NonNil<T>>;
+	in?: ReadonlyArray<Friendly<NonNil<T>>>;
+	$in?: ReadonlyArray<Friendly<NonNil<T>>>;
+	nin?: ReadonlyArray<Friendly<NonNil<T>>>;
+	$nin?: ReadonlyArray<Friendly<NonNil<T>>>;
+	gt?: Comparable<T>;
+	$gt?: Comparable<T>;
+	gte?: Comparable<T>;
+	$gte?: Comparable<T>;
+	lt?: Comparable<T>;
+	$lt?: Comparable<T>;
+	lte?: Comparable<T>;
+	$lte?: Comparable<T>;
+	exists?: boolean;
+	regex?: RegexOperand<T>;
+	$options?: string;
+	geoWithin?: GeoWithinOperandForField<TFieldKey>;
+};
+
+type WhereFieldValue<T, TFieldKey extends string> =
+	| Friendly<NonNil<T>>
+	| FieldOperators<T, TFieldKey>;
+
+export type WhereInput<TModel extends Record<string, unknown>> = {
+	[K in keyof TModel]?: WhereFieldValue<
+		TModel[K],
+		Extract<keyof TModel, string>
+	>;
+} & {
+	geoWithin?: GeoWithinOperandForField<Extract<keyof TModel, string>>;
+	$geoWithin?: GeoWithinOperandForField<Extract<keyof TModel, string>>;
+};
+
+type ColumnData<TColumn> = TColumn extends { _: { data: infer TData } }
+	? TData
+	: unknown;
+
+type InferRelationWhereFields<TConfig> = TConfig extends { where?: infer TWhere }
+	? TWhere extends (...args: infer TArgs) => unknown
+		? TArgs extends [infer TFields, ...unknown[]]
+			? TFields extends Record<string, unknown>
+				? TFields
+				: never
+			: never
+		: never
+	: never;
+
+type RelationModelFromConfig<TConfig extends Record<string, unknown>> =
+	InferRelationWhereFields<TConfig> extends infer TFields
+		? TFields extends Record<string, unknown>
+			? {
+					[K in Extract<keyof TFields, string>]: ColumnData<TFields[K]>;
+			  }
+			: Record<string, unknown>
+		: Record<string, unknown>;
+
+type NumericModelFieldKey<TModel extends Record<string, unknown>> = Extract<
+	{
+		[K in keyof TModel]-?: NonNullable<TModel[K]> extends number ? K : never;
+	}[keyof TModel],
+	string
+>;
+
+type RelationAvgSelectionInput<TModel extends Record<string, unknown>> =
+	Partial<Record<NumericModelFieldKey<TModel>, boolean>>;
+
+type RelationAggregateSelectionInput<TModel extends Record<string, unknown>> = {
+	_count?: boolean;
+	_avg?: RelationAvgSelectionInput<TModel>;
+};
+
+type QueryWithRelationInput<TEntry> =
+	| (Extract<TEntry, true> extends never ? never : true)
+	| (Extract<TEntry, Record<string, unknown>> extends infer TRelation
+			? TRelation extends Record<string, unknown>
+				? Omit<TRelation, "where" | "with" | "_count" | "_avg"> &
+						RelationAggregateSelectionInput<RelationModelFromConfig<TRelation>> & {
+						where?: WhereInput<RelationModelFromConfig<TRelation>>;
+						with?: TRelation extends { with?: infer TNestedWith }
+							? QueryWithInput<TNestedWith>
+							: never;
+				  }
+				: never
+			: never);
+
+type QueryWithInput<TWith> = TWith extends Record<string, unknown>
+	? {
+			[K in keyof TWith]?: QueryWithRelationInput<TWith[K]>;
+	  }
+	: TWith;
+
+export type QueryFindManyArgs<TName extends TableName> = Omit<
+	NonNullable<TableFindManyArgs<TName>>,
+	"where" | "with"
+> & {
+	where?: WhereInput<TableModel<TName>>;
+	with?: TableFindManyArgs<TName> extends { with?: infer TWith }
+		? QueryWithInput<TWith>
+		: never;
+};
+
+export type QueryFindFirstArgs<TName extends TableName> = Omit<
+	NonNullable<TableFindFirstArgs<TName>>,
+	"where" | "with"
+> & {
+	where?: WhereInput<TableModel<TName>>;
+	with?: TableFindFirstArgs<TName> extends { with?: infer TWith }
+		? QueryWithInput<TWith>
+		: never;
+};
+
+export type QueryInsertArgs<TName extends TableName> = {
+	values: TableInsertModel<TName> | Array<TableInsertModel<TName>>;
+};
+
+export type QueryUpdateArgs<TName extends TableName> = {
+	set: Partial<TableInsertModel<TName>>;
+	where?: WhereInput<TableModel<TName>>;
+	limit?: number;
+};
+
+export type QueryDeleteArgs<TName extends TableName> = {
+	where?: WhereInput<TableModel<TName>>;
+	limit?: number;
+};
+
+type AggregateWithInput<TName extends TableName> =
+	TableFindManyArgs<TName> extends { with?: infer TWith }
+		? QueryWithInput<TWith>
+		: never;
+
+type NumericFieldKey<TName extends TableName> = NumericModelFieldKey<
+	TableModel<TName>
+>;
+
+type RelationAggregateAvgResult<TAvg> = TAvg extends Record<string, unknown>
+	? {
+			[K in Extract<keyof TAvg, string> as TAvg[K] extends true ? K : never]: number;
+	  }
+	: {};
+
+type RelationAggregateResult<TEntry> =
+	Extract<TEntry, Record<string, unknown>> extends infer TRelation
+		? TRelation extends Record<string, unknown>
+			? (TRelation extends { _count?: true } ? { count: number } : {}) &
+					(TRelation extends { _avg?: infer TAvg }
+						? { avg: RelationAggregateAvgResult<TAvg> }
+						: {})
+			: {}
+		: {};
+
+type HasRelationAggregateRequest<TEntry> =
+	Extract<TEntry, Record<string, unknown>> extends infer TRelation
+		? TRelation extends Record<string, unknown>
+			? TRelation extends { _count?: true }
+				? true
+				: TRelation extends { _avg?: Record<string, unknown> }
+					? true
+					: false
+			: false
+		: false;
+
+type QueryWithAggregateResult<TWith> = TWith extends Record<string, unknown>
+	? {
+			[K in Extract<keyof TWith, string> as HasRelationAggregateRequest<
+				TWith[K]
+			> extends true
+				? \`\${K}Aggregate\`
+				: never]: RelationAggregateResult<TWith[K]>;
+	  }
+	: {};
+
+type WithFromArgs<TArgs> = TArgs extends { with?: infer TWith }
+	? TWith
+	: undefined;
+
+type AppendRelationAggregatesToRow<TRow, TWith> = TRow &
+	QueryWithAggregateResult<TWith>;
+
+type ApplyFindManyWithAggregateResult<TResult, TArgs> =
+	TResult extends Promise<infer TRows>
+		? TRows extends Array<infer TRow>
+			? Promise<
+					Array<AppendRelationAggregatesToRow<TRow, WithFromArgs<TArgs>>>
+			  >
+			: TResult
+		: TResult;
+
+type ApplyFindFirstWithAggregateResult<TResult, TArgs> =
+	TResult extends Promise<infer TRow>
+		? Promise<
+				TRow extends null
+					? null
+					: AppendRelationAggregatesToRow<TRow, WithFromArgs<TArgs>>
+		  >
+		: TResult;
+
+export type QueryCountArgs<TName extends TableName> = {
+	where?: WhereInput<TableModel<TName>>;
+	field?: Extract<keyof TableModel<TName>, string> | string;
+	distinct?: boolean;
+	with?: AggregateWithInput<TName>;
+};
+
+export type QueryAvgArgs<TName extends TableName> = {
+	where?: WhereInput<TableModel<TName>>;
+	field: NumericFieldKey<TName> | string;
+	distinct?: boolean;
+	with?: AggregateWithInput<TName>;
+};
+
+export type QueryUpsertArgs<TName extends TableName> = {
+	values: TableInsertModel<TName> | Array<TableInsertModel<TName>>;
+	target?:
+		| Extract<keyof TableInsertModel<TName>, string>
+		| Array<Extract<keyof TableInsertModel<TName>, string>>;
+	set?: Partial<TableInsertModel<TName>>;
+};
+
+export type QueryTableApi<TName extends TableName> = {
+	findMany: <
+		TArgs extends QueryFindManyArgs<TName> | undefined =
+			| QueryFindManyArgs<TName>
+			| undefined,
+	>(
+		args?: TArgs,
+	) => ApplyFindManyWithAggregateResult<TableFindManyResult<TName>, TArgs>;
+	findFirst: <
+		TArgs extends QueryFindFirstArgs<TName> | undefined =
+			| QueryFindFirstArgs<TName>
+			| undefined,
+	>(
+		args?: TArgs,
+	) => ApplyFindFirstWithAggregateResult<TableFindFirstResult<TName>, TArgs>;
+	insert: (args: QueryInsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	update: (args: QueryUpdateArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	upsert: (args: QueryUpsertArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	delete: (args?: QueryDeleteArgs<TName>) => Promise<Array<TableModel<TName>>>;
+	count: (args?: QueryCountArgs<TName>) => Promise<number>;
+	avg: (args: QueryAvgArgs<TName>) => Promise<number | null>;
+};
+
+export type AppflareQueryDb = {
+	[TName in TableName]: QueryTableApi<TName>;
+};
+
+export type DbMutationKind = "insert" | "update" | "upsert" | "delete";
+
+export type DbMutationEvent = {
+	kind: DbMutationKind;
+	table: string;
+	args: Record<string, unknown>;
+	rows: unknown[];
+};
+
+export type QueryDbOptions = {
+	onMutation?: (event: DbMutationEvent) => void;
+};
+
+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 [];
+}
+`;
+}