appflare 0.2.4 → 0.2.7

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

@@ -1,1085 +1,13 @@
-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 TableFindManyMethod<TName extends TableName> = TableQuery<TName> extends {
-	findMany: infer TMethod;
-}
-	? TMethod
-	: never;
-type NativeFindManyWith<TName extends TableName> =
-	NonNullable<TableFindManyArgs<TName>> extends { with?: infer TWith }
-		? TWith
-		: never;
-type ResolveNativeFindManyWith<
-	TName extends TableName,
-	TArgs extends QueryFindManyArgs<TName> | undefined,
-> = TArgs extends { with?: infer TWith }
-	? Extract<TWith, NativeFindManyWith<TName>>
-	: never;
-type ResolveTableFindManyArgs<
-	TName extends TableName,
-	TArgs extends QueryFindManyArgs<TName> | undefined,
-> = TArgs extends undefined
-	? undefined
-	: Omit<NonNullable<TableFindManyArgs<TName>>, "where" | "with"> &
-			(ResolveNativeFindManyWith<TName, TArgs> extends never
-				? {}
-				: { with?: ResolveNativeFindManyWith<TName, TArgs> });
-type TableFindManyResult<
-	TName extends TableName,
-	TArgs extends QueryFindManyArgs<TName> | undefined =
-		| QueryFindManyArgs<TName>
-		| undefined,
-> = TableFindManyMethod<TName> extends (
-	args?: ResolveTableFindManyArgs<TName, TArgs>,
-) => infer TResult
-	? TResult
-	: TableFindManyMethod<TName> extends (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 TableFindFirstMethod<TName extends TableName> = TableQuery<TName> extends {
-	findFirst: infer TMethod;
-}
-	? TMethod
-	: never;
-type NativeFindFirstWith<TName extends TableName> =
-	NonNullable<TableFindFirstArgs<TName>> extends { with?: infer TWith }
-		? TWith
-		: never;
-type ResolveNativeFindFirstWith<
-	TName extends TableName,
-	TArgs extends QueryFindFirstArgs<TName> | undefined,
-> = TArgs extends { with?: infer TWith }
-	? Extract<TWith, NativeFindFirstWith<TName>>
-	: never;
-type ResolveTableFindFirstArgs<
-	TName extends TableName,
-	TArgs extends QueryFindFirstArgs<TName> | undefined,
-> = TArgs extends undefined
-	? undefined
-	: Omit<NonNullable<TableFindFirstArgs<TName>>, "where" | "with"> &
-			(ResolveNativeFindFirstWith<TName, TArgs> extends never
-				? {}
-				: { with?: ResolveNativeFindFirstWith<TName, TArgs> });
-type TableFindFirstResult<
-	TName extends TableName,
-	TArgs extends QueryFindFirstArgs<TName> | undefined =
-		| QueryFindFirstArgs<TName>
-		| undefined,
-> = TableFindFirstMethod<TName> extends (
-	args?: ResolveTableFindFirstArgs<TName, TArgs>,
-) => infer TResult
-	? TResult
-	: TableFindFirstMethod<TName> extends (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"
-> & {
-	where?: WhereInput<TableModel<TName>>;
-};
-
-export type QueryFindFirstArgs<TName extends TableName> = Omit<
-	NonNullable<TableFindFirstArgs<TName>>,
-	"where"
-> & {
-	where?: WhereInput<TableModel<TName>>;
-};
-
-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: TableFindManyMethod<TName> & (<
-		TArgs extends QueryFindManyArgs<TName> | undefined =
-			| QueryFindManyArgs<TName>
-			| undefined,
-	>(
-		args?: TArgs,
-	) => ApplyFindManyWithAggregateResult<TableFindManyResult<TName, TArgs>, TArgs>);
-	findFirst: TableFindFirstMethod<TName> & (<
-		TArgs extends QueryFindFirstArgs<TName> | undefined =
-			| QueryFindFirstArgs<TName>
-			| undefined,
-	>(
-		args?: TArgs,
-	) => ApplyFindFirstWithAggregateResult<TableFindFirstResult<TName, TArgs>, 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;
-		}
+import { generateFilterAndWhereTypesSection } from "./query-definitions/filter-and-where-types";
+import { generateQueryApiTypesSection } from "./query-definitions/query-api-types";
+import { generateQueryHelperFunctionsSection } from "./query-definitions/query-helper-functions";
+import { generateSchemaAndTableTypesSection } from "./query-definitions/schema-and-table-types";
 
-		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 [];
-}
-`;
+export function generateTypesQueryDefinitionsSection(): string {
+	return [
+		generateSchemaAndTableTypesSection(),
+		generateFilterAndWhereTypesSection(),
+		generateQueryApiTypesSection(),
+		generateQueryHelperFunctionsSection(),
+	].join("\n\n");
 }