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

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

@@ -12,6 +12,7 @@ import * as Database from '@contember/database'
 import { UniqueWhereError } from '../inputProcessing'
 import { Model } from '@contember/schema'
 import { isOwningRelation, isRelation, NamingHelper } from '@contember/schema-utils'
+import { logger } from '@contember/logger'
 import RelationType = Model.RelationType
 
 
@@ -108,8 +109,7 @@ export const convertError = (schema: Model.Schema, e: any): MutationResult => {
 		return new MutationSqlError([], e.originalMessage, [MutationResultHint.subSequentSqlError])
 	}
 	if (e instanceof Database.QueryError) {
-		// eslint-disable-next-line no-console
-		console.error(e)
+		logger.error(e, { loc: 'convertError' })
 		return new MutationSqlError([], e.originalMessage, [MutationResultHint.sqlError])
 	}
 	throw e

package/src/mapper/JunctionTableManager.ts

@@ -87,7 +87,7 @@ export class JunctionTableManager {
 		}
 
 		const owningPredicate = this.predicateFactory.create(owningEntity, Acl.Operation.update, [relation.name])
-		let inversePredicate: Input.Where = {}
+		let inversePredicate: Input.OptionalWhere = {}
 		if (relation.inversedBy) {
 			inversePredicate = this.predicateFactory.create(inverseEntity, Acl.Operation.update, [relation.inversedBy])
 		}
@@ -99,11 +99,11 @@ export class JunctionTableManager {
 		if (hasNoPredicates) {
 			return await handler.executeSimple({ db, joiningTable, owningPrimary, inversePrimary, okResultFactory })
 		} else {
-			const owningWhere: Input.Where = {
+			const owningWhere: Input.OptionalWhere = {
 				and: [owningPredicate, { [owningEntity.primary]: { eq: owningPrimary } }],
 			}
 
-			const inverseWhere: Input.Where = {
+			const inverseWhere: Input.OptionalWhere = {
 				and: [inversePredicate, { [inverseEntity.primary]: { eq: inversePrimary } }],
 			}
 

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) {