@contember/engine-content-api 1.2.0-alpha.1 → 1.2.0-alpha.12

package/src/mapper/Mapper.ts

@@ -1,6 +1,6 @@
 import { Input, Model } from '@contember/schema'
 import { getColumnName } from '@contember/schema-utils'
-import { SelectHydrator, SelectIndexedResultObjects, SelectResultObject } from './select'
+import { SelectGroupedObjects, SelectHydrator, SelectIndexedResultObjects, SelectResultObject } from './select'
 import { PathFactory } from './select'
 import * as database from '@contember/database'
 import { Client, SelectBuilder } from '@contember/database'
@@ -14,7 +14,7 @@ import { Updater } from './update'
 import { Inserter } from './insert'
 import { tryMutation } from './ErrorUtils'
 import { OrderByHelper } from './select'
-import { ObjectNode, UniqueWhereExpander } from '../inputProcessing'
+import {  ObjectNode, UniqueWhereExpander } from '../inputProcessing'
 import { UpdateBuilder } from './update'
 import { Mutex } from '../utils'
 import { CheckedPrimary } from './CheckedPrimary'
@@ -50,59 +50,64 @@ export class Mapper {
 			.from(entity.tableName, 'root_')
 			.select(['root_', columnName])
 		const expandedWhere = this.uniqueWhereExpander.expand(entity, where)
-		const builtQb = this.whereBuilder.build(qb, entity, this.pathFactory.create([]), expandedWhere)
+		const builtQb = this.whereBuilder.build(qb, entity, this.pathFactory.create([]), expandedWhere, [])
 		const result = await builtQb.getResult(this.db)
 
 		return result[0] !== undefined ? result[0][columnName] : undefined
 	}
 
-	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>): Promise<SelectResultObject[]>
-	public async select(
+	public async selectAssoc(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
+		relationPath: Model.AnyRelationContext[],
 		indexBy: string,
-	): Promise<SelectIndexedResultObjects>
-	public async select(
-		entity: Model.Entity,
-		input: ObjectNode<Input.ListQueryInput>,
-		indexBy?: string,
-	): Promise<SelectResultObject[] | SelectIndexedResultObjects> {
+	): Promise<SelectIndexedResultObjects> {
 		const hydrator = new SelectHydrator()
-		let qb: SelectBuilder<SelectBuilder.Result> = SelectBuilder.create()
-		let indexByAlias: string | null = null
-		if (indexBy) {
-			const path = this.pathFactory.create([])
-			indexByAlias = path.for(indexBy).alias
-			qb = qb.select([path.alias, getColumnName(this.schema, entity, indexBy)], indexByAlias)
-		}
-		const rows = await this.selectRows(hydrator, qb, entity, input)
+		const path = this.pathFactory.create([])
+		const indexByAlias: string = path.for(indexBy).alias
+		const qb: SelectBuilder = SelectBuilder.create()
+			.select([path.alias, getColumnName(this.schema, entity, indexBy)], indexByAlias)
+		const rows = await this.selectRows(hydrator, qb, entity, input, relationPath)
+		return await hydrator.hydrateAll(rows, indexByAlias)
+	}
+
+	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>, relationPath: Model.AnyRelationContext[]): Promise<SelectResultObject[]> {
+		const hydrator = new SelectHydrator()
+		const qb: SelectBuilder<SelectBuilder.Result> = SelectBuilder.create()
+
+		const rows = await this.selectRows(hydrator, qb, entity, input, relationPath)
 
-		return await (indexByAlias !== null ? hydrator.hydrateAll(rows, indexByAlias) : hydrator.hydrateAll(rows))
+		return await hydrator.hydrateAll(rows)
 	}
 
 	public async selectUnique(
 		entity: Model.Entity,
 		query: ObjectNode<Input.UniqueQueryInput>,
+		relationPath: Model.AnyRelationContext[],
 	): Promise<SelectResultObject | null> {
 		const uniqueWhere = this.uniqueWhereExpander.expand(entity, query.args.by)
 		const where = query.args.filter ? { and: [uniqueWhere, query.args.filter] } : uniqueWhere
 		const queryExpanded = query.withArg<Input.ListQueryInput>('filter', where)
 
-		return (await this.select(entity, queryExpanded))[0] || null
+		const rows = await this.select(entity, queryExpanded, relationPath)
+
+		return rows[0] ?? null
 	}
 
 	public async selectGrouped(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
-		relation: Model.JoiningColumnRelation & Model.Relation,
-	) {
+		relation: Model.JoiningColumnRelation & Model.AnyRelation,
+		relationPath: Model.AnyRelationContext[],
+	): Promise<SelectGroupedObjects> {
 		const hydrator = new SelectHydrator()
-		let qb: SelectBuilder<SelectBuilder.Result> = SelectBuilder.create()
 		const path = this.pathFactory.create([])
 		const groupingKey = '__grouping_key'
-		qb = qb.select([path.alias, relation.joiningColumn.columnName], groupingKey)
+		const qb: SelectBuilder = SelectBuilder.create()
+			.select([path.alias, relation.joiningColumn.columnName], groupingKey)
+
+		const rows = await this.selectRows(hydrator, qb, entity, input, relationPath, relation.name)
 
-		const rows = await this.selectRows(hydrator, qb, entity, input, relation.name)
 		return await hydrator.hydrateGroups(rows, groupingKey)
 	}
 
@@ -111,14 +116,15 @@ export class Mapper {
 		qb: SelectBuilder<SelectBuilder.Result>,
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
+		relationPath: Model.AnyRelationContext[],
 		groupBy?: string,
 	) {
 		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, [])
 		const path = this.pathFactory.create([])
 		const augmentedBuilder = qb.from(entity.tableName, path.alias).meta('path', [...input.path, input.alias])
 
-		const selector = this.selectBuilderFactory.create(augmentedBuilder, hydrator)
-		const filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {})
+		const selector = this.selectBuilderFactory.create(augmentedBuilder, hydrator, relationPath)
+		const filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {}, relationPath[relationPath.length - 1])
 		const inputWithPredicates = inputWithOrder.withArg('filter', filterWithPredicates)
 		selector.select(this, entity, inputWithPredicates, path, groupBy)
 		return await selector.execute(this.db)
@@ -130,7 +136,7 @@ export class Mapper {
 			.from(entity.tableName, path.alias)
 			.select(expr => expr.raw('count(*)'), 'row_count')
 		const withPredicates = this.predicatesInjector.inject(entity, filter)
-		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates)
+		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates, [])
 		const result = await qbWithWhere.getResult(this.db)
 		return result[0].row_count
 	}
@@ -139,6 +145,7 @@ export class Mapper {
 		entity: Model.Entity,
 		filter: Input.OptionalWhere,
 		relation: Model.JoiningColumnRelation & Model.Relation,
+		relationPath: Model.AnyRelationContext[],
 	): Promise<Record<string, number>> {
 		const path = this.pathFactory.create([])
 		const qb = SelectBuilder.create()
@@ -147,7 +154,7 @@ export class Mapper {
 			.select([path.alias, relation.joiningColumn.columnName])
 			.groupBy([path.alias, relation.joiningColumn.columnName])
 		const withPredicates = this.predicatesInjector.inject(entity, filter)
-		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates)
+		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates, relationPath)
 		const rows = await qbWithWhere.getResult(this.db)
 		const result = new Map<string, number>()
 		for (const row of rows) {

package/src/mapper/MapperContainer.ts

@@ -27,11 +27,13 @@ import {
 	Updater,
 } from '../mapper'
 import { Builder } from '@contember/dic'
-import { Acl, Schema } from '@contember/schema'
+import { Acl, Model, Schema } from '@contember/schema'
 import { Client, SelectBuilder as DbSelectBuilder } from '@contember/database'
 import { Providers } from '@contember/schema-utils'
 import { PaginatedHasManyExecutionHandler } from '../extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
 import { PaginatedHasManyFieldProvider } from '../extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
+import { WhereOptimizer } from './select/optimizer/WhereOptimizer'
+import { ConditionOptimizer } from './select/optimizer/ConditionOptimizer'
 
 type MapperContainerArgs = {
 	schema: Schema
@@ -51,7 +53,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 		.addService('variableInjector', () =>
 			new VariableInjector(schema.model, identityVariables))
 		.addService('predicateFactory', ({ variableInjector }) =>
-			new PredicateFactory(permissions, variableInjector))
+			new PredicateFactory(permissions, schema.model, variableInjector))
 		.addService('predicatesInjector', ({ predicateFactory }) =>
 			new PredicatesInjector(schema.model, predicateFactory))
 		.addService('joinBuilder', () =>
@@ -60,8 +62,10 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 			new ConditionBuilder())
 		.addService('pathFactory', () =>
 			new PathFactory())
-		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory }) =>
-			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory))
+		.addService('whereOptimized', () =>
+			new WhereOptimizer(schema.model, new ConditionOptimizer()))
+		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized }) =>
+			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized))
 		.addService('orderByBuilder', ({ joinBuilder }) =>
 			new OrderByBuilder(schema.model, joinBuilder))
 		.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
@@ -82,7 +86,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 		}))
 		.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory }) =>
 			new (class implements SelectBuilderFactory {
-				create(qb: DbSelectBuilder, hydrator: SelectHydrator): SelectBuilder {
+				create(qb: DbSelectBuilder, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder {
 					return new SelectBuilder(
 						schema.model,
 						whereBuilder,
@@ -93,6 +97,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 						fieldsVisitorFactory,
 						selectHandlers,
 						pathFactory,
+						relationPath,
 					)
 				}
 			})())

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

@@ -12,6 +12,41 @@ import { Mapper } from '../Mapper'
 
 export type GroupedCounts = Record<Input.PrimaryValue, number>
 
+type CountOneHasManyGroupsArgs = {
+	mapper: Mapper
+	filter: Input.OptionalWhere | undefined
+	relationPath: Model.AnyRelationContext[]
+	relationContext: Model.OneHasManyContext
+	ids: Input.PrimaryValue[]
+}
+
+type FetchOneHasManyGroupsArgs = {
+	mapper: Mapper
+	objectNode: ObjectNode<Input.ListQueryInput>
+	relationPath: Model.AnyRelationContext[]
+	relationContext: Model.OneHasManyContext
+	ids: Input.PrimaryValue[]
+}
+
+type ManyHasManyBaseArgs =
+	& {
+		mapper: Mapper
+		ids: Input.PrimaryValue[]
+		relationPath: Model.AnyRelationContext[]
+		relationContext: Model.ManyHasManyInverseContext | Model.ManyHasManyOwningContext
+	}
+type CountManyHasManyGroupArgs =
+	& ManyHasManyBaseArgs
+	& {
+		filter: Input.OptionalWhere | undefined
+	}
+
+type FetchManyHasManyGroupsArgs =
+	& ManyHasManyBaseArgs
+	& {
+		field: ObjectNode<Input.ListQueryInput>
+	}
+
 export class RelationFetcher {
 	constructor(
 		private readonly whereBuilder: WhereBuilder,
@@ -20,25 +55,29 @@ export class RelationFetcher {
 		private readonly pathFactory: PathFactory,
 	) {}
 
-	public async countOneHasManyGroups(
-		mapper: Mapper,
-		filter: Input.OptionalWhere | undefined,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-		ids: Input.PrimaryValue[],
-	): Promise<GroupedCounts> {
+	public async countOneHasManyGroups({
+		mapper,
+		filter,
+		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: Mapper,
-		objectNode: ObjectNode<Input.ListQueryInput>,
-		targetEntity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetRelation: Model.ManyHasOneRelation,
-		ids: Input.PrimaryValue[],
-	): Promise<SelectGroupedObjects> {
+	public async fetchOneHasManyGroups({
+		mapper,
+		objectNode,
+		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(
@@ -47,7 +86,10 @@ export class RelationFetcher {
 			relation.orderBy || [],
 		)
 
-		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation)
+		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation, [
+			...relationPath,
+			relationContext,
+		])
 	}
 
 	private createOneHasManyFilter(
@@ -65,38 +107,43 @@ export class RelationFetcher {
 		}
 	}
 
-	public async countManyHasManyGroups(
-		mapper: Mapper,
-		filter: Input.OptionalWhere | undefined,
-		targetEntity: Model.Entity,
-		owningRelation: Model.ManyHasManyOwningRelation,
-		ids: Input.PrimaryValue[],
-		joiningColumns: JoiningColumns,
-	): Promise<GroupedCounts> {
-		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, targetEntity, { filter })
+	public async countManyHasManyGroups({
+		mapper,
+		filter,
+		relationContext,
+		relationPath,
+		ids,
+	}: CountManyHasManyGroupArgs): Promise<GroupedCounts> {
+		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: Mapper,
-		field: ObjectNode<Input.ListQueryInput>,
-		targetEntity: Model.Entity,
-		fromRelation: Model.ManyHasManyOwningRelation | Model.ManyHasManyInverseRelation,
-		owningRelation: Model.ManyHasManyOwningRelation,
-		joiningColumns: JoiningColumns,
-		ids: Input.PrimaryValue[],
-	): Promise<SelectGroupedObjects> {
-		const defaultOrderBy = fromRelation.orderBy || []
-		const objectNode = OrderByHelper.appendDefaultOrderBy(targetEntity, field, defaultOrderBy)
-
+	public async fetchManyHasManyGroups({
+		mapper,
+		field,
+		relationContext,
+		relationPath,
+		ids,
+	}: FetchManyHasManyGroupsArgs): Promise<SelectGroupedObjects> {
+		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,
@@ -104,6 +151,7 @@ export class RelationFetcher {
 			joiningColumns,
 			targetEntity,
 			objectNode,
+			relationPath,
 		)
 		if (junctionValues.length === 0) {
 			return {}
@@ -122,11 +170,21 @@ export class RelationFetcher {
 				},
 			})
 			.withField(primaryField)
-		const result = await mapper.select(targetEntity, queryWithWhere)
+		const result = await mapper.select(targetEntity, queryWithWhere, [...relationPath, relationContext])
 
 		return this.buildManyHasManyGroups(targetEntity, joiningColumns, result, junctionValues)
 	}
 
+	private resolveJoiningColumns({ relationType, joiningTable }: { joiningTable: Model.JoiningTable; relationType: 'manyHasManyOwning' | 'manyHasManyInverse' }): JoiningColumns {
+		return relationType === 'manyHasManyOwning' ? {
+			sourceColumn: joiningTable.joiningColumn,
+			targetColumn: joiningTable.inverseJoiningColumn,
+		} : {
+			sourceColumn: joiningTable.inverseJoiningColumn,
+			targetColumn: joiningTable.joiningColumn,
+		}
+	}
+
 	private buildManyHasManyGroups(
 		entity: Model.Entity,
 		joiningColumns: JoiningColumns,
@@ -159,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(
@@ -191,6 +250,7 @@ export class RelationFetcher {
 		column: JoiningColumns,
 		targetEntity: Model.Entity,
 		objectArgs: Input.ListQueryInput,
+		relationPath: Model.AnyRelationContext[],
 	): SelectBuilder {
 		const joiningTable = relation.joiningTable
 
@@ -218,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>,