@contember/engine-content-api 1.2.0-alpha.10 → 1.2.0-alpha.11

package/src/mapper/delete/DeleteExecutor.ts

@@ -131,8 +131,8 @@ export class DeleteExecutor {
 					visitManyHasManyOwning: () => null,
 					visitOneHasOneInverse: () => null,
 					visitOneHasMany: () => null,
-					visitOneHasOneOwning: ({}, relation): EntityOwningRelationTuple => [entity, relation],
-					visitManyHasOne: ({}, relation): EntityOwningRelationTuple => [entity, relation],
+					visitOneHasOneOwning: ({ relation }): EntityOwningRelationTuple => [entity, relation],
+					visitManyHasOne: ({ relation }): EntityOwningRelationTuple => [entity, relation],
 				}),
 			)
 			.reduce<EntityOwningRelationTuple[]>(
@@ -155,7 +155,7 @@ export class DeleteExecutor {
 				visitManyHasManyOwning: () => null,
 				visitOneHasOneInverse: () => null,
 				visitOneHasMany: () => null,
-				visitOneHasOneOwning: ({}, relation, targetEntity) =>
+				visitOneHasOneOwning: ({ relation, targetEntity }) =>
 					relation.orphanRemoval ? [targetEntity, relation] : null,
 				visitManyHasOne: () => null,
 			}),

package/src/mapper/insert/SqlCreateInputProcessor.ts

@@ -1,4 +1,4 @@
-import { Input, Value } from '@contember/schema'
+import { Input, Model, Value } from '@contember/schema'
 import { Mapper } from '../Mapper'
 import { InsertBuilder } from './InsertBuilder'
 import { Providers, resolveColumnValue } from '@contember/schema-utils'
@@ -15,7 +15,7 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<MutationRes
 		private readonly providers: Providers,
 	) {}
 
-	public async column(context: Context.ColumnContext): Promise<MutationResultList> {
+	public async column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<MutationResultList> {
 		this.insertBuilder.addFieldValue(
 			context.column.name,
 			((): Value.GenericValueLike<Value.AtomicValue | undefined> => {
@@ -159,7 +159,7 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<MutationRes
 			return []
 		},
 		connect: hasOneProcessor(
-			async (context: Context.OneHasOneOwningContext & { input: Input.UniqueWhere }): Promise<MutationResultList> => {
+			async (context: Model.OneHasOneOwningContext & { input: Input.UniqueWhere }): Promise<MutationResultList> => {
 				const primaryValue = this.mapper.getPrimaryValue(context.targetEntity, context.input)
 				this.insertBuilder.addFieldValue(context.relation.name, async () => {
 					const value = await primaryValue

package/src/mapper/select/JoinVisitor.ts

@@ -4,11 +4,7 @@ import { Path } from './Path'
 export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]> {
 	constructor(private readonly path: Path) {}
 
-	visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-	): JoinDefinition[] {
+	visitOneHasOneOwning({ targetEntity, relation }: Model.OneHasOneOwningContext): JoinDefinition[] {
 		return [
 			{
 				tableName: targetEntity.tableName,
@@ -18,12 +14,7 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 		]
 	}
 
-	visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	): JoinDefinition[] {
+	visitOneHasOneInverse({ targetEntity, entity, targetRelation }: Model.OneHasOneInverseContext): JoinDefinition[] {
 		return [
 			{
 				tableName: targetEntity.tableName,
@@ -33,11 +24,7 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 		]
 	}
 
-	visitManyHasOne(
-		entity: Model.Entity,
-		relation: Model.ManyHasOneRelation,
-		targetEntity: Model.Entity,
-	): JoinDefinition[] {
+	visitManyHasOne({ targetEntity, relation }: Model.ManyHasOneContext): JoinDefinition[] {
 		return [
 			{
 				tableName: targetEntity.tableName,
@@ -47,12 +34,7 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 		]
 	}
 
-	visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	): JoinDefinition[] {
+	visitOneHasMany({ targetEntity, targetRelation, entity }: Model.OneHasManyContext): JoinDefinition[] {
 		return [
 			{
 				tableName: targetEntity.tableName,
@@ -63,11 +45,7 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 		]
 	}
 
-	visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-	): JoinDefinition[] {
+	visitManyHasManyOwning({ relation, entity, targetEntity }: Model.ManyHasManyOwningContext): JoinDefinition[] {
 		const sourceAlias = this.path.back().alias
 		const targetAlias = this.path.alias
 		const joiningAlias = this.path.back().for('x_' + this.path.alias).alias
@@ -90,12 +68,7 @@ export class JoinVisitor implements Model.RelationByTypeVisitor<JoinDefinition[]
 		]
 	}
 
-	visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): JoinDefinition[] {
+	visitManyHasManyInverse({ targetRelation, entity, targetEntity }: Model.ManyHasManyInverseContext): JoinDefinition[] {
 		const sourceAlias = this.path.back().alias
 		const targetAlias = this.path.alias
 		const joiningAlias = this.path.back().for('x_' + this.path.alias).alias

package/src/mapper/select/RelationFetcher.ts

@@ -15,37 +15,26 @@ export type GroupedCounts = Record<Input.PrimaryValue, number>
 type CountOneHasManyGroupsArgs = {
 	mapper: Mapper
 	filter: Input.OptionalWhere | undefined
-	targetEntity: Model.Entity
-	targetRelation: Model.ManyHasOneRelation
+	relationPath: Model.AnyRelationContext[]
+	relationContext: Model.OneHasManyContext
 	ids: Input.PrimaryValue[]
 }
 
 type FetchOneHasManyGroupsArgs = {
 	mapper: Mapper
 	objectNode: ObjectNode<Input.ListQueryInput>
-	targetEntity: Model.Entity
-	relation: Model.OneHasManyRelation
-	targetRelation: Model.ManyHasOneRelation
+	relationPath: Model.AnyRelationContext[]
+	relationContext: Model.OneHasManyContext
 	ids: Input.PrimaryValue[]
 }
 
 type ManyHasManyBaseArgs =
 	& {
 		mapper: Mapper
-		targetEntity: Model.Entity
 		ids: Input.PrimaryValue[]
-	} & (
-		| {
-			directionFrom: 'owning'
-			sourceRelation: Model.ManyHasManyOwningRelation
-			targetRelation: Model.ManyHasManyInverseRelation | null
-		}
-		| {
-			directionFrom: 'inverse'
-			sourceRelation: Model.ManyHasManyInverseRelation
-			targetRelation: Model.ManyHasManyOwningRelation
-		}
-	)
+		relationPath: Model.AnyRelationContext[]
+		relationContext: Model.ManyHasManyInverseContext | Model.ManyHasManyOwningContext
+	}
 type CountManyHasManyGroupArgs =
 	& ManyHasManyBaseArgs
 	& {
@@ -69,22 +58,26 @@ export class RelationFetcher {
 	public async countOneHasManyGroups({
 		mapper,
 		filter,
-		targetEntity,
-		targetRelation,
+		relationContext,
+		relationPath,
 		ids,
 	}: CountOneHasManyGroupsArgs): Promise<GroupedCounts> {
+		const { targetRelation, targetEntity } = relationContext
 		const filterWithParent = this.createOneHasManyFilter(targetEntity, targetRelation, ids, filter)
-		return mapper.countGrouped(targetEntity, filterWithParent, targetRelation)
+		return mapper.countGrouped(targetEntity, filterWithParent, targetRelation, [
+			...relationPath,
+			relationContext,
+		])
 	}
 
 	public async fetchOneHasManyGroups({
 		mapper,
 		objectNode,
-		targetEntity,
-		relation,
-		targetRelation,
+		relationContext,
+		relationPath,
 		ids,
 	}: FetchOneHasManyGroupsArgs): Promise<SelectGroupedObjects> {
+		const { relation, targetEntity, targetRelation } = relationContext
 		const filter = this.createOneHasManyFilter(targetEntity, targetRelation, ids, objectNode.args.filter)
 		const objectNodeWithWhere = objectNode.withArg<Input.ListQueryInput>('filter', filter)
 		const objectNodeWithOrder = OrderByHelper.appendDefaultOrderBy(
@@ -93,7 +86,10 @@ export class RelationFetcher {
 			relation.orderBy || [],
 		)
 
-		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation)
+		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation, [
+			...relationPath,
+			relationContext,
+		])
 	}
 
 	private createOneHasManyFilter(
@@ -114,40 +110,40 @@ export class RelationFetcher {
 	public async countManyHasManyGroups({
 		mapper,
 		filter,
-		targetEntity,
-		directionFrom,
-		sourceRelation,
-		targetRelation,
+		relationContext,
+		relationPath,
 		ids,
 	}: CountManyHasManyGroupArgs): Promise<GroupedCounts> {
-		const owningRelation = directionFrom === 'owning' ? sourceRelation : targetRelation
-		const joiningColumns = this.resolveJoiningColumns({ directionFrom, owningRelation })
-		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, targetEntity, { filter })
+		const owningRelation = relationContext.type === 'manyHasManyInverse' ? relationContext.targetRelation : relationContext.relation
+
+		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
+
+		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, relationContext.targetEntity, { filter }, relationPath)
 			.select(['junction_', joiningColumns.sourceColumn.columnName])
 			.select(expr => expr.raw('count(*)'), 'row_count')
 			.groupBy(['junction_', joiningColumns.sourceColumn.columnName])
+
 		const result = new Map<string, number>()
 		const rows = await qb.getResult(mapper.db)
 		for (const row of rows) {
 			result.set(String(row[joiningColumns.sourceColumn.columnName]), Number(row.row_count))
 		}
+
 		return Object.fromEntries(result)
 	}
 
 	public async fetchManyHasManyGroups({
 		mapper,
 		field,
-		sourceRelation,
-		targetEntity,
-		targetRelation,
-		directionFrom,
+		relationContext,
+		relationPath,
 		ids,
 	}: FetchManyHasManyGroupsArgs): Promise<SelectGroupedObjects> {
-		const owningRelation = directionFrom === 'owning' ? sourceRelation : targetRelation
-		const joiningColumns = this.resolveJoiningColumns({ directionFrom, owningRelation })
-		const defaultOrderBy = sourceRelation.orderBy || []
-		const objectNode = OrderByHelper.appendDefaultOrderBy(targetEntity, field, defaultOrderBy)
-
+		const owningRelation = relationContext.type === 'manyHasManyInverse' ? relationContext.targetRelation : relationContext.relation
+		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
+		const defaultOrderBy = relationContext.relation.orderBy || []
+		const objectNode = OrderByHelper.appendDefaultOrderBy(relationContext.targetEntity, field, defaultOrderBy)
+		const { targetEntity } = relationContext
 		const junctionValues = await this.fetchJunction(
 			mapper.db,
 			owningRelation,
@@ -155,6 +151,7 @@ export class RelationFetcher {
 			joiningColumns,
 			targetEntity,
 			objectNode,
+			relationPath,
 		)
 		if (junctionValues.length === 0) {
 			return {}
@@ -173,18 +170,18 @@ export class RelationFetcher {
 				},
 			})
 			.withField(primaryField)
-		const result = await mapper.select(targetEntity, queryWithWhere, targetRelation)
+		const result = await mapper.select(targetEntity, queryWithWhere, [...relationPath, relationContext])
 
 		return this.buildManyHasManyGroups(targetEntity, joiningColumns, result, junctionValues)
 	}
 
-	private resolveJoiningColumns({ directionFrom, owningRelation }: { owningRelation: Model.ManyHasManyOwningRelation; directionFrom: 'owning' | 'inverse' }): JoiningColumns {
-		return directionFrom === 'owning' ? {
-			sourceColumn: owningRelation.joiningTable.joiningColumn,
-			targetColumn: owningRelation.joiningTable.inverseJoiningColumn,
+	private resolveJoiningColumns({ relationType, joiningTable }: { joiningTable: Model.JoiningTable; relationType: 'manyHasManyOwning' | 'manyHasManyInverse' }): JoiningColumns {
+		return relationType === 'manyHasManyOwning' ? {
+			sourceColumn: joiningTable.joiningColumn,
+			targetColumn: joiningTable.inverseJoiningColumn,
 		} : {
-			sourceColumn: owningRelation.joiningTable.inverseJoiningColumn,
-			targetColumn: owningRelation.joiningTable.joiningColumn,
+			sourceColumn: joiningTable.inverseJoiningColumn,
+			targetColumn: joiningTable.joiningColumn,
 		}
 	}
 
@@ -220,9 +217,10 @@ export class RelationFetcher {
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
 		object: ObjectNode<Input.ListQueryInput>,
+		relationPath: Model.AnyRelationContext[],
 	): Promise<Record<string, Value.AtomicValue>[]> {
 		const joiningTable = relation.joiningTable
-		const qb = this.buildJunctionQb(relation, values, column, targetEntity, object.args)
+		const qb = this.buildJunctionQb(relation, values, column, targetEntity, object.args, relationPath)
 			.select(['junction_', joiningTable.inverseJoiningColumn.columnName])
 			.select(['junction_', joiningTable.joiningColumn.columnName])
 		const wrapper = new LimitByGroupWrapper(
@@ -252,6 +250,7 @@ export class RelationFetcher {
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
 		objectArgs: Input.ListQueryInput,
+		relationPath: Model.AnyRelationContext[],
 	): SelectBuilder {
 		const joiningTable = relation.joiningTable
 
@@ -279,7 +278,7 @@ export class RelationFetcher {
 		}
 
 		if (where && hasWhere) {
-			qb = this.whereBuilder.build(qb, targetEntity, this.pathFactory.create([]), where)
+			qb = this.whereBuilder.build(qb, targetEntity, this.pathFactory.create([]), where, relationPath)
 		}
 		return qb
 	}

package/src/mapper/select/SelectBuilder.ts

@@ -30,6 +30,7 @@ export class SelectBuilder {
 		private readonly fieldsVisitorFactory: FieldsVisitorFactory,
 		private readonly selectHandlers: { [key: string]: SelectExecutionHandler<any> },
 		private readonly pathFactory: PathFactory,
+		private readonly relationPath: Model.AnyRelationContext[],
 	) {}
 
 	public async execute(db: Client): Promise<SelectRow[]> {
@@ -53,7 +54,7 @@ export class SelectBuilder {
 		this.selectInternal(mapper, entity, path, input)
 		const where = input.args.filter
 		if (where) {
-			this.qb = this.whereBuilder.build(this.qb, entity, path, where)
+			this.qb = this.whereBuilder.build(this.qb, entity, path, where, this.relationPath)
 		}
 		const orderBy = input.args.orderBy || []
 
@@ -96,6 +97,7 @@ export class SelectBuilder {
 			})()
 			const executionContext: SelectExecutionHandlerContext = {
 				mapper,
+				relationPath: this.relationPath,
 				addData: async (fieldName, cb, defaultValue = null) => {
 					const columnName = getColumnName(this.schema, entity, fieldName)
 					const ids = (await this.getColumnValues(path.for(fieldName), columnName)).filter(it => it !== null)

package/src/mapper/select/SelectBuilderFactory.ts

@@ -1,7 +1,8 @@
 import { SelectBuilder } from './SelectBuilder'
 import { SelectHydrator } from './SelectHydrator'
 import { SelectBuilder as DbSelectBuilder } from '@contember/database'
+import { Model } from '@contember/schema'
 
 export interface SelectBuilderFactory {
-	create(qb: DbSelectBuilder<DbSelectBuilder.Result>, hydrator: SelectHydrator): SelectBuilder
+	create(qb: DbSelectBuilder<DbSelectBuilder.Result>, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder
 }

package/src/mapper/select/SelectExecutionHandler.ts

@@ -21,6 +21,7 @@ export type SelectExecutionHandlerContext<
 	mapper: Mapper
 	path: Path
 	entity: Model.Entity
+	relationPath: Model.AnyRelationContext[]
 
 	addColumn: (
 		queryCallback: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>,

package/src/mapper/select/WhereBuilder.ts

@@ -21,33 +21,45 @@ export class WhereBuilder {
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
-		allowManyJoin: boolean = false,
+		relationPath: Model.AnyRelationContext[] = [],
 	) {
-		return this.buildAdvanced(entity, path, where, cb => qb.where(clause => cb(clause)), allowManyJoin)
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity, relationPath)
+		return this.buildInternal(entity, path, optimizedWhere, cb => qb.where(clause => cb(clause)), false)
 	}
 
+
 	public buildAdvanced(
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
 		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
-		allowManyJoin: boolean = false,
+		relationPath: Model.AnyRelationContext[] = [],
+	) {
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity, relationPath)
+		return this.buildInternal(entity, path, optimizedWhere, callback, false)
+	}
+
+	private buildInternal(
+		entity: Model.Entity,
+		path: Path,
+		where: Input.OptionalWhere,
+		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
+		allowManyJoin: boolean,
 	) {
-		const optimizedWhere = this.whereOptimizer.optimize(where, entity)
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildInternal(clause, entity, path, optimizedWhere, allowManyJoin, joinList))
+		const qbWithWhere = callback(clause => this.buildRecursive(clause, entity, path, where, allowManyJoin, joinList))
 		return joinList.reduce<SelectBuilder<SelectBuilder.Result>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join(qb, path, entity, relationName),
 			qbWithWhere,
 		)
 	}
 
-	private buildInternal(
+	private buildRecursive(
 		conditionBuilder: SqlConditionBuilder,
 		entity: Model.Entity,
 		path: Path,
-		where: Input.Where,
+		where: Input.OptionalWhere,
 		allowManyJoin: boolean,
 		joinList: WhereJoinDefinition[],
 	): SqlConditionBuilder {
@@ -58,7 +70,7 @@ export class WhereBuilder {
 			conditionBuilder = conditionBuilder.and(clause =>
 				expr.reduce(
 					(clause2, where) =>
-						!where ? clause2 : this.buildInternal(clause2, entity, path, where, allowManyJoin, joinList),
+						!where ? clause2 : this.buildRecursive(clause2, entity, path, where, allowManyJoin, joinList),
 					clause,
 				),
 			)
@@ -70,7 +82,7 @@ export class WhereBuilder {
 					(clause2, where) =>
 						!where
 							? clause2
-							: clause2.and(clause3 => this.buildInternal(clause3, entity, path, where, allowManyJoin, joinList)),
+							: clause2.and(clause3 => this.buildRecursive(clause3, entity, path, where, allowManyJoin, joinList)),
 					clause,
 				),
 			)
@@ -78,7 +90,7 @@ export class WhereBuilder {
 		if (where.not !== undefined) {
 			const expr = where.not
 			conditionBuilder = conditionBuilder.not(clause =>
-				this.buildInternal(clause, entity, path, expr, allowManyJoin, joinList),
+				this.buildRecursive(clause, entity, path, expr, allowManyJoin, joinList),
 			)
 		}
 
@@ -87,11 +99,7 @@ export class WhereBuilder {
 				continue
 			}
 
-			const joinedWhere = (
-				entity: Model.Entity,
-				relation: Model.Relation,
-				targetEntity: Model.Entity,
-			): SqlConditionBuilder => {
+			const joinedWhere = ({ targetEntity, relation, entity }: Model.AnyRelationContext): SqlConditionBuilder => {
 				const targetPath = path.for(fieldName)
 				const relationWhere = where[fieldName] as Input.Where
 				if (Object.keys(relationWhere).length === 0) {
@@ -112,36 +120,37 @@ export class WhereBuilder {
 
 				joinList.push({ path: targetPath, entity, relationName: relation.name })
 
-				return this.buildInternal(conditionBuilder, targetEntity, targetPath, relationWhere, allowManyJoin, joinList)
+				return this.buildRecursive(conditionBuilder, targetEntity, targetPath, relationWhere, allowManyJoin, joinList)
 			}
 
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
-				visitColumn: (entity, column) => {
+				visitColumn: ({ entity, column }) => {
 					const subWhere: Input.Condition<Input.ColumnValue> = where[column.name] as Input.Condition<Input.ColumnValue>
 					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column.columnType, subWhere)
 				},
 				visitOneHasOneInverse: joinedWhere,
 				visitOneHasOneOwning: joinedWhere,
 				visitManyHasOne: joinedWhere,
-				visitManyHasManyInverse: (entity, relation, targetEntity, targetRelation) => {
+				visitManyHasManyInverse: context => {
 					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+						return joinedWhere(context)
 					}
+
 					const relationWhere = where[fieldName] as Input.Where
 
 					return conditionBuilder.exists(
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
 							relationWhere,
-							targetEntity,
-							targetRelation.joiningTable,
+							context.targetEntity,
+							context.targetRelation.joiningTable,
 							'inverse',
 						),
 					)
 				},
-				visitManyHasManyOwning: (entity, relation, targetEntity) => {
+				visitManyHasManyOwning: context => {
 					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+						return joinedWhere(context)
 					}
 
 					const relationWhere = where[fieldName] as Input.Where
@@ -150,28 +159,30 @@ export class WhereBuilder {
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
 							relationWhere,
-							targetEntity,
-							relation.joiningTable,
+							context.targetEntity,
+							context.relation.joiningTable,
 							'owning',
 						),
 					)
 				},
-				visitOneHasMany: (entity, relation, targetEntity, targetRelation) => {
+				visitOneHasMany: context => {
 					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+						return joinedWhere(context)
 					}
 
 					const relationWhere = where[fieldName] as Input.Where
 
+					const qb = SelectBuilder.create()
+						.select(it => it.raw('1'))
+						.from(context.targetEntity.tableName, 'sub_')
+						.where(it => it.columnsEq([tableName, entity.primaryColumn], ['sub_', context.targetRelation.joiningColumn.columnName]))
+
 					return conditionBuilder.exists(
-						this.build(
-							SelectBuilder.create()
-								.select(it => it.raw('1'))
-								.from(targetEntity.tableName, 'sub_')
-								.where(it => it.columnsEq([tableName, entity.primaryColumn], ['sub_', targetRelation.joiningColumn.columnName])),
-							targetEntity,
+						this.buildInternal(
+							context.targetEntity,
 							this.pathFactory.create([], 'sub_'),
 							relationWhere,
+							cb => qb.where(clause => cb(clause)),
 							true,
 						),
 					)
@@ -208,7 +219,7 @@ export class WhereBuilder {
 		const qbJoined = qb.join(targetEntity.tableName, 'sub_', clause =>
 			clause.compareColumns(['junction_', toColumn], Operator.eq, ['sub_', targetEntity.primary]),
 		)
-		return this.buildAdvanced(
+		return this.buildInternal(
 			targetEntity,
 			this.pathFactory.create([], 'sub_'),
 			relationWhere,