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

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'
@@ -56,56 +56,58 @@ export class Mapper {
 		return result[0] !== undefined ? result[0][columnName] : undefined
 	}
 
-	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>, overRelation: Model.AnyRelation | null): Promise<SelectResultObject[]>
-	public async select(
+	public async selectAssoc(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
-		overRelation: Model.AnyRelation | null,
+		relationPath: Model.AnyRelationContext[],
 		indexBy: string,
-	): Promise<SelectIndexedResultObjects>
-	public async select(
-		entity: Model.Entity,
-		input: ObjectNode<Input.ListQueryInput>,
-		overRelation: Model.AnyRelation | null,
-		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, overRelation)
+		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>,
-		overRelation: Model.AnyRelation | null,
+		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, overRelation))[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.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, relation.name)
 		return await hydrator.hydrateGroups(rows, groupingKey)
 	}
 
@@ -114,15 +116,15 @@ export class Mapper {
 		qb: SelectBuilder<SelectBuilder.Result>,
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
-		overRelation: Model.AnyRelation | null,
+		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 || {}, overRelation ?? undefined)
+		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)
@@ -143,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()
@@ -151,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

@@ -3,9 +3,9 @@ import {
 	ConditionBuilder,
 	FieldsVisitorFactory,
 	JoinBuilder,
-	RelationFetcher,
 	MetaHandler,
 	OrderByBuilder,
+	RelationFetcher,
 	WhereBuilder,
 } from './select'
 import { UniqueWhereExpander } from '../inputProcessing'
@@ -27,7 +27,7 @@ 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'
@@ -65,7 +65,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 		.addService('whereOptimized', () =>
 			new WhereOptimizer(schema.model, new ConditionOptimizer()))
 		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized }) =>
-			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized))
+			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema.settings.useExistsInHasManyFilter === true))
 		.addService('orderByBuilder', ({ joinBuilder }) =>
 			new OrderByBuilder(schema.model, joinBuilder))
 		.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
@@ -84,9 +84,9 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 			[HasManyToHasOneReducer.extensionName]: hasManyToHasOneReducer,
 			[PaginatedHasManyFieldProvider.extensionName]: paginatedHasManyExecutionHandler,
 		}))
-		.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory }) =>
+		.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory, predicateFactory }) =>
 			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,
@@ -97,6 +97,8 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 						fieldsVisitorFactory,
 						selectHandlers,
 						pathFactory,
+						relationPath,
+						predicateFactory,
 					)
 				}
 			})())

package/src/mapper/Result.ts

@@ -2,6 +2,7 @@ import { Input, Model, Value } from '@contember/schema'
 import { convertError } from './ErrorUtils'
 import { getFulfilledValues, getRejections } from '../utils'
 import { SerializationFailureError } from '@contember/database'
+import { logger } from '@contember/logger'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -225,10 +226,7 @@ export const collectResults = async (
 	const failures = getRejections(results)
 	if (failures.length > 0) {
 		if (failures.length > 1 && !failures.every(it => it instanceof SerializationFailureError)) {
-			// eslint-disable-next-line no-console
-			console.error('Multiple error has occurred, printing them & rethrowing the first one')
-			// eslint-disable-next-line no-console
-			failures.slice(1).map(e => console.error(e))
+			failures.slice(1).map(e => logger.error(e))
 		}
 		throw failures[0]
 	}

package/src/mapper/delete/DeleteExecutor.ts

@@ -36,7 +36,6 @@ export class DeleteExecutor {
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		return mapper.mutex.execute(async () => {
-			await mapper.constraintHelper.setFkConstraintsDeferred()
 			const primaryValue = await mapper.getPrimaryValue(entity, by)
 			if (!primaryValue) {
 				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
@@ -44,20 +43,21 @@ export class DeleteExecutor {
 			if (mapper.deletedEntities.isDeleted(entity.name, primaryValue)) {
 				return [new MutationNothingToDo([], NothingToDoReason.alreadyDeleted)]
 			}
+			await mapper.constraintHelper.setFkConstraintsDeferred()
 			const primaryWhere = { [entity.primary]: { eq: primaryValue } }
 			const result = await this.delete(mapper, entity, filter ? { and: [primaryWhere, filter] } : primaryWhere)
+			await mapper.constraintHelper.setFkConstraintsImmediate()
 			if (result.length === 0) {
 				return [new MutationNoResultError([])]
 			}
 
-			await mapper.constraintHelper.setFkConstraintsImmediate()
 			return [new MutationDeleteOk([], entity, primaryValue)]
 		})
 	}
 
 	private async delete(mapper: Mapper, entity: Model.Entity, where: Input.OptionalWhere): Promise<string[]> {
 		const db = mapper.db
-		const predicate = this.predicateFactory.create(entity, Acl.Operation.delete)
+		const predicate = this.predicateFactory.createDeletePredicate(entity)
 		const inQb = SelectBuilder.create() //
 			.from(entity.tableName, 'root_')
 			.select(['root_', entity.primaryColumn])
@@ -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/InsertBuilder.ts

@@ -20,7 +20,7 @@ export class InsertBuilder {
 	public readonly insert: Promise<Value.PrimaryValue | null> = new Promise(resolve => (this.resolver = resolve))
 
 	private rowData: ColumnValue<AbortInsert | undefined>[] = []
-	private where: Input.Where = {}
+	private where: Input.OptionalWhere = {}
 
 	constructor(
 		private readonly schema: Model.Schema,
@@ -35,7 +35,7 @@ export class InsertBuilder {
 		this.rowData.push({ columnName, value: resolveGenericValue(value), columnType, fieldName })
 	}
 
-	public addWhere(where: Input.Where): void {
+	public addWhere(where: Input.OptionalWhere): void {
 		this.where = { and: [where, this.where] }
 	}
 

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/Path.ts

@@ -27,6 +27,9 @@ export class PathFactory {
 export class Path {
 	public readonly alias = this.createAlias()
 
+	public get fullAlias() {
+		return this.rootAlias + this.path.join('_')
+	}
 	constructor(
 		public readonly path: string[],
 		private readonly aliasContext: AliasContext,
@@ -44,7 +47,7 @@ export class Path {
 	}
 
 	private createAlias(): string {
-		const alias = this.rootAlias + this.path.join('_')
+		const alias = this.fullAlias
 
 		// intentionally not allowing == MAX_IDENTIFIER_LENGTH
 		if (alias.length < MAX_IDENTIFIER_LENGTH) {

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
 	}