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

package/src/input-validation/preValidation/UpdateInputPreValidationProcessor.ts

@@ -1,5 +1,4 @@
 import { UpdateInputProcessor } from '../../inputProcessing'
-import * as Context from '../../inputProcessing'
 import { Input, Model } from '@contember/schema'
 import { appendRelationToPath, ValidationPath } from '../ValidationPath'
 import { Mapper } from '../../mapper'
@@ -16,11 +15,11 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		private readonly mapper: Mapper,
 	) {}
 
-	async column(context: Context.ColumnContext): Promise<Result> {
+	async column(context: Model.ColumnContext): Promise<Result> {
 		return []
 	}
 
-	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Context.ManyHasManyInverseContext, Result> = {
+	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyInverseContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
@@ -28,7 +27,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		disconnect: NoResult,
 		['delete']: NoResult,
 	}
-	manyHasManyOwning: UpdateInputProcessor.HasManyRelationInputProcessor<Context.ManyHasManyOwningContext, Result> = {
+	manyHasManyOwning: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyOwningContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
@@ -36,7 +35,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		disconnect: NoResult,
 		['delete']: NoResult,
 	}
-	manyHasOne: UpdateInputProcessor.HasOneRelationInputProcessor<Context.ManyHasOneContext, Result> = {
+	manyHasOne: UpdateInputProcessor.HasOneRelationInputProcessor<Model.ManyHasOneContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
@@ -44,7 +43,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		disconnect: NoResult,
 		['delete']: NoResult,
 	}
-	oneHasMany: UpdateInputProcessor.HasManyRelationInputProcessor<Context.OneHasManyContext, Result> = {
+	oneHasMany: UpdateInputProcessor.HasManyRelationInputProcessor<Model.OneHasManyContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
@@ -52,7 +51,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		disconnect: NoResult,
 		['delete']: NoResult,
 	}
-	oneHasOneInverse: UpdateInputProcessor.HasOneRelationInputProcessor<Context.OneHasOneInverseContext, Result> = {
+	oneHasOneInverse: UpdateInputProcessor.HasOneRelationInputProcessor<Model.OneHasOneInverseContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
@@ -61,7 +60,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		['delete']: NoResult,
 	}
 
-	oneHasOneOwning: UpdateInputProcessor.HasOneRelationInputProcessor<Context.OneHasOneOwningContext, Result> = {
+	oneHasOneOwning: UpdateInputProcessor.HasOneRelationInputProcessor<Model.OneHasOneOwningContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),

package/src/inputProcessing/CreateInputProcessor.ts

@@ -1,17 +1,16 @@
-import { Input } from '@contember/schema'
-import * as Context from './InputContext'
+import { Input, Model } from '@contember/schema'
 
 interface CreateInputProcessor<Result = void> {
-	column(context: Context.ColumnContext): Promise<Result>
+	column(context: CreateInputProcessor.ContextWithInput<Model.ColumnContext, Input.ColumnValue | undefined>): Promise<Result>
 
-	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Context.ManyHasManyInverseContext, Result>
-	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Context.ManyHasManyOwningContext, Result>
+	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyInverseContext, Result>
+	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyOwningContext, Result>
 
-	oneHasOneInverse: CreateInputProcessor.HasOneRelationProcessor<Context.OneHasOneInverseContext, Result>
-	oneHasOneOwning: CreateInputProcessor.HasOneRelationProcessor<Context.OneHasOneOwningContext, Result>
+	oneHasOneInverse: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneInverseContext, Result>
+	oneHasOneOwning: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneOwningContext, Result>
 
-	oneHasMany: CreateInputProcessor.HasManyRelationProcessor<Context.OneHasManyContext, Result>
-	manyHasOne: CreateInputProcessor.HasOneRelationProcessor<Context.ManyHasOneContext, Result>
+	oneHasMany: CreateInputProcessor.HasManyRelationProcessor<Model.OneHasManyContext, Result>
+	manyHasOne: CreateInputProcessor.HasOneRelationProcessor<Model.ManyHasOneContext, Result>
 }
 
 namespace CreateInputProcessor {

package/src/inputProcessing/CreateInputVisitor.ts

@@ -1,7 +1,6 @@
 import { isIt } from '../utils'
 import { Input, Model } from '@contember/schema'
 import { CreateInputProcessor } from './CreateInputProcessor'
-import * as Context from './InputContext'
 import { filterObject } from '../utils'
 import { UserError } from '../exception'
 import { ImplementationException } from '../exception'
@@ -16,119 +15,58 @@ export class CreateInputVisitor<Result> implements
 		private readonly data: Input.CreateDataInput,
 	) {}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): Promise<Result> {
+	public visitColumn(context: Model.ColumnContext): Promise<Result> {
 		return this.createInputProcessor.column({
-			entity,
-			column,
-			input: this.data[column.name] as Input.ColumnValue,
+			...context,
+			input: this.data[context.column.name] as Input.ColumnValue,
 		})
 	}
 
-	public visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	) {
-		return this.processManyRelationInput<Context.ManyHasManyInverseContext>(
+	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
+		return this.processManyRelationInput(
 			this.createInputProcessor.manyHasManyInverse,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	) {
-		return this.processManyRelationInput<Context.ManyHasManyOwningContext>(
+	public visitManyHasManyOwning(context: Model.ManyHasManyOwningContext) {
+		return this.processManyRelationInput(
 			this.createInputProcessor.manyHasManyOwning,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitManyHasOne(
-		entity: Model.Entity,
-		relation: Model.ManyHasOneRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasManyRelation | null,
-	) {
-		return this.processRelationInput<Context.ManyHasOneContext>(
+	public visitManyHasOne(context: Model.ManyHasOneContext) {
+		return this.processRelationInput(
 			this.createInputProcessor.manyHasOne,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 
-	public visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	) {
-		return this.processManyRelationInput<Context.OneHasManyContext>(
+	public visitOneHasMany(context: Model.OneHasManyContext) {
+		return this.processManyRelationInput(
 			this.createInputProcessor.oneHasMany,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	) {
-		return this.processRelationInput<Context.OneHasOneInverseContext>(
+	public visitOneHasOneInverse(context: Model.OneHasOneInverseContext) {
+		return this.processRelationInput(
 			this.createInputProcessor.oneHasOneInverse,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	) {
-		return this.processRelationInput<Context.OneHasOneOwningContext>(
+	public visitOneHasOneOwning(context: Model.OneHasOneOwningContext) {
+		return this.processRelationInput(
 			this.createInputProcessor.oneHasOneOwning,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 

package/src/inputProcessing/UpdateInputProcessor.ts

@@ -1,20 +1,19 @@
-import { Input } from '@contember/schema'
-import * as Context from './InputContext'
+import { Input, Model } from '@contember/schema'
 
 interface UpdateInputProcessor<Result = void> {
-	column(context: Context.ColumnContext): Promise<Result>
+	column(context: UpdateInputProcessor.ContextWithInput<Model.ColumnContext, Input.ColumnValue | undefined>): Promise<Result>
 
-	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Context.ManyHasManyInverseContext, Result>
+	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyInverseContext, Result>
 
-	manyHasManyOwning: UpdateInputProcessor.HasManyRelationInputProcessor<Context.ManyHasManyOwningContext, Result>
+	manyHasManyOwning: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyOwningContext, Result>
 
-	manyHasOne: UpdateInputProcessor.HasOneRelationInputProcessor<Context.ManyHasOneContext, Result>
+	manyHasOne: UpdateInputProcessor.HasOneRelationInputProcessor<Model.ManyHasOneContext, Result>
 
-	oneHasMany: UpdateInputProcessor.HasManyRelationInputProcessor<Context.OneHasManyContext, Result>
+	oneHasMany: UpdateInputProcessor.HasManyRelationInputProcessor<Model.OneHasManyContext, Result>
 
-	oneHasOneInverse: UpdateInputProcessor.HasOneRelationInputProcessor<Context.OneHasOneInverseContext, Result>
+	oneHasOneInverse: UpdateInputProcessor.HasOneRelationInputProcessor<Model.OneHasOneInverseContext, Result>
 
-	oneHasOneOwning: UpdateInputProcessor.HasOneRelationInputProcessor<Context.OneHasOneOwningContext, Result>
+	oneHasOneOwning: UpdateInputProcessor.HasOneRelationInputProcessor<Model.OneHasOneOwningContext, Result>
 }
 
 namespace UpdateInputProcessor {

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -1,7 +1,6 @@
 import { Input, Model } from '@contember/schema'
 import { filterObject, isIt } from '../utils'
 import { UpdateInputProcessor } from './UpdateInputProcessor'
-import * as Context from './InputContext'
 import { ImplementationException, UserError } from '../exception'
 
 export class UpdateInputVisitor<Result> implements
@@ -14,7 +13,7 @@ export class UpdateInputVisitor<Result> implements
 		private readonly data: Input.UpdateDataInput,
 	) {}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): Promise<Result> {
+	public visitColumn({ entity, column }: Model.ColumnContext): Promise<Result> {
 		return this.updateInputProcessor.column({
 			entity,
 			column,
@@ -22,96 +21,51 @@ export class UpdateInputVisitor<Result> implements
 		})
 	}
 
-	public visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	) {
-		return this.processManyRelationInput<Context.ManyHasManyInverseContext>(
+	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
+		return this.processManyRelationInput(
 			this.updateInputProcessor.manyHasManyInverse,
-			{ entity, relation, targetEntity, targetRelation },
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	) {
-		return this.processManyRelationInput<Context.ManyHasManyOwningContext>(
+	public visitManyHasManyOwning(context: Model.ManyHasManyOwningContext) {
+		return this.processManyRelationInput(
 			this.updateInputProcessor.manyHasManyOwning,
-			{ entity, relation, targetEntity, targetRelation },
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitManyHasOne(
-		entity: Model.Entity,
-		relation: Model.ManyHasOneRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasManyRelation | null,
-	) {
-		return this.processRelationInput<Context.ManyHasOneContext>(
+	public visitManyHasOne(context: Model.ManyHasOneContext) {
+		return this.processRelationInput(
 			this.updateInputProcessor.manyHasOne,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 
-	public visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	) {
-		return this.processManyRelationInput<Context.OneHasManyContext>(
+	public visitOneHasMany(context: Model.OneHasManyContext) {
+		return this.processManyRelationInput(
 			this.updateInputProcessor.oneHasMany,
-			{ entity, relation, targetEntity, targetRelation },
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	) {
-		return this.processRelationInput<Context.OneHasOneInverseContext>(
+	public visitOneHasOneInverse(context: Model.OneHasOneInverseContext) {
+		return this.processRelationInput(
 			this.updateInputProcessor.oneHasOneInverse,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	) {
-		return this.processRelationInput<Context.OneHasOneOwningContext>(
+	public visitOneHasOneOwning(context: Model.OneHasOneOwningContext) {
+		return this.processRelationInput(
 			this.updateInputProcessor.oneHasOneOwning,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 

package/src/inputProcessing/index.ts

@@ -1,7 +1,6 @@
 export * from './CreateInputProcessor'
 export * from './CreateInputVisitor'
 export * from './FieldNode'
-export * from './InputContext'
 export * from './ObjectNode'
 export * from './UniqueWhereExpander'
 export * from './UpdateInputProcessor'

package/src/introspection/IntrospectionSchemaFactory.ts

@@ -40,7 +40,7 @@ export class IntrospectionSchemaFactory {
 			}
 		}
 		const additionalInfo = acceptEveryFieldVisitor<AdditionalFieldInfo>(this.model, entityName, {
-			visitManyHasManyInverse(entity: Model.Entity, relation: Model.ManyHasManyInverseRelation) {
+			visitManyHasManyInverse({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -49,7 +49,7 @@ export class IntrospectionSchemaFactory {
 					orderBy: relation.orderBy?.map(convertOrderBy),
 				}
 			},
-			visitManyHasManyOwning(entity: Model.Entity, relation: Model.ManyHasManyOwningRelation) {
+			visitManyHasManyOwning({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -58,7 +58,7 @@ export class IntrospectionSchemaFactory {
 					orderBy: relation.orderBy?.map(convertOrderBy),
 				}
 			},
-			visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation) {
+			visitManyHasOne({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -68,7 +68,7 @@ export class IntrospectionSchemaFactory {
 					nullable: relation.nullable,
 				}
 			},
-			visitOneHasMany(entity: Model.Entity, relation: Model.OneHasManyRelation) {
+			visitOneHasMany({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -77,7 +77,7 @@ export class IntrospectionSchemaFactory {
 					orderBy: relation.orderBy?.map(convertOrderBy),
 				}
 			},
-			visitOneHasOneInverse(entity: Model.Entity, relation: Model.OneHasOneInverseRelation) {
+			visitOneHasOneInverse({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -86,7 +86,7 @@ export class IntrospectionSchemaFactory {
 					nullable: relation.nullable,
 				}
 			},
-			visitOneHasOneOwning(entity: Model.Entity, relation: Model.OneHasOneOwningRelation) {
+			visitOneHasOneOwning({ relation }) {
 				return {
 					__typename: '_Relation',
 					targetEntity: relation.target,
@@ -97,7 +97,7 @@ export class IntrospectionSchemaFactory {
 					orphanRemoval: relation.orphanRemoval === true,
 				}
 			},
-			visitColumn(entity: Model.Entity, column: Model.AnyColumn) {
+			visitColumn({ column }) {
 				return {
 					__typename: '_Column',
 					defaultValue: column.default ?? undefined,

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,62 +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>, 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)
+	}
 
-		return await (indexByAlias !== null ? hydrator.hydrateAll(rows, indexByAlias) : hydrator.hydrateAll(rows))
+	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 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)
@@ -134,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
 	}
@@ -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

@@ -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'
@@ -86,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,
@@ -97,6 +97,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 						fieldsVisitorFactory,
 						selectHandlers,
 						pathFactory,
+						relationPath,
 					)
 				}
 			})())