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

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -13,9 +13,10 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		private readonly whereBuilder: WhereBuilder,
 		private readonly mapper: Mapper,
 		private readonly executionContext: SelectExecutionHandlerContext,
+		private readonly relationPath: Model.AnyRelationContext[],
 	) {}
 
-	visitColumn(entity: Model.Entity, column: Model.AnyColumn): void {
+	visitColumn({ entity, column }: Model.ColumnContext): void {
 		const columnPath = this.executionContext.path
 		this.executionContext.addColumn(qb => {
 			const tableAlias = columnPath.back().alias
@@ -49,27 +50,20 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		})
 	}
 
-	public visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): void {
+	public visitManyHasManyInverse(relationContext: Model.ManyHasManyInverseContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
 		this.executionContext.addData(
-			entity.primary,
+			relationContext.entity.primary,
 			async ids =>
 				this.relationFetcher.fetchManyHasManyGroups(
 					{
 						mapper: this.mapper,
 						field: field,
-						targetEntity: targetEntity,
-						sourceRelation: relation,
-						targetRelation,
-						directionFrom: 'inverse',
+						relationContext,
+						relationPath: this.relationPath,
 						ids: ids,
 					},
 				),
@@ -77,65 +71,48 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	): void {
+	public visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
 
 		this.executionContext.addData(
-			entity.primary,
+			relationContext.entity.primary,
 			async ids =>
 				this.relationFetcher.fetchManyHasManyGroups({
 					mapper: this.mapper,
 					field: field,
-					targetEntity: targetEntity,
-					sourceRelation: relation,
-					targetRelation,
-					directionFrom: 'owning',
+					relationContext,
+					relationPath: this.relationPath,
 					ids: ids,
 				}),
 			[],
 		)
 	}
 
-	public visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	): void {
+	public visitOneHasMany(relationContext: Model.OneHasManyContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
 
 		this.executionContext.addData(
-			entity.primary,
+			relationContext.entity.primary,
 			async ids =>
 				this.relationFetcher.fetchOneHasManyGroups({
 					mapper: this.mapper,
 					objectNode: field,
-					targetEntity: targetEntity,
-					relation: relation,
-					targetRelation: targetRelation,
+					relationContext,
+					relationPath: this.relationPath,
 					ids: ids,
 				}),
 			[],
 		)
 	}
 
-	public visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	): void {
+	public visitOneHasOneInverse(relationContext: Model.OneHasOneInverseContext): void {
+		const { entity, targetRelation, targetEntity } = relationContext
 		this.executionContext.addData(
 			entity.primary,
 			async ids => {
@@ -155,18 +132,17 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = field.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetRelation.name)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetRelation.name)
 			},
 			null,
 		)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	): void {
+	public visitOneHasOneOwning(relationContext: Model.OneHasOneOwningContext): void {
+		const { relation, targetEntity } = relationContext
 		this.executionContext.addData(
 			relation.name,
 			async ids => {
@@ -184,13 +160,17 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetEntity.primary)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetEntity.primary)
 			},
 			null,
 		)
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity, targetRelation: Model.OneHasManyRelation | null): void {
+	public visitManyHasOne(relationContext: Model.ManyHasOneContext): void {
+		const { relation, targetEntity } = relationContext
 		this.executionContext.addData(
 			relation.name,
 			async ids => {
@@ -208,7 +188,10 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation, targetEntity.primary)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetEntity.primary)
 			},
 			null,
 		)

package/src/mapper/select/handlers/FieldsVisitorFactory.ts

@@ -22,6 +22,7 @@ export class FieldsVisitorFactory {
 			this.whereBuilder,
 			mapper,
 			context,
+			context.relationPath,
 		)
 	}
 }

package/src/mapper/select/optimizer/ConditionOptimizer.ts

@@ -23,6 +23,12 @@ export class ConditionOptimizer {
 				} else if (key === 'or') {
 					return optimizeOr(value.map(it => this.optimize(it)))
 
+				} else if (key === 'in' && value.length === 0) {
+					return false
+
+				} else if (key === 'notIn' && value.length === 0) {
+					return true
+
 				} else if (key === 'not') {
 					return optimizeNot(this.optimize(value))
 

package/src/mapper/select/optimizer/WhereOptimizer.ts

@@ -4,15 +4,34 @@ import { acceptFieldVisitor } from '@contember/schema-utils'
 import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
 import { replaceWhere } from './WhereReplacer'
 
+type ExtendedRelationContext =
+	& Model.AnyRelationContext
+	& {
+		canEliminate: boolean
+		isLast: boolean
+	}
+
 export class WhereOptimizer {
+	private static eliminableRelations = new Set<Model.AnyRelationContext['type']>(['oneHasMany', 'oneHasOneInverse', 'oneHasOneOwning'])
+
 	constructor(
 		private readonly model: Model.Schema,
 		private readonly conditionOptimizer: ConditionOptimizer,
 	) {
 	}
 
-	public optimize(where: Input.OptionalWhere, entity: Model.Entity): Input.Where {
-		const result = this.optimizeWhere(where, entity)
+	public optimize(where: Input.OptionalWhere, entity: Model.Entity, relationPath: Model.AnyRelationContext[] = []): Input.Where {
+		let processedRelationPath: ExtendedRelationContext[] = []
+		for (const i in relationPath) {
+			const el = relationPath[i]
+			if (!WhereOptimizer.eliminableRelations.has(el.type)) {
+				processedRelationPath = []
+			} else {
+				processedRelationPath.push({ ...el, canEliminate: true, isLast: Number(i) === relationPath.length })
+			}
+			processedRelationPath.push({ ...el, canEliminate: true, isLast: Number(i) === relationPath.length })
+		}
+		const result = this.optimizeWhere(where, entity, processedRelationPath)
 
 		if (typeof result === 'boolean') {
 			return { [entity.primary]: { [result ? 'always' : 'never']: true } }
@@ -21,61 +40,66 @@ export class WhereOptimizer {
 		return result
 	}
 
-	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity): Input.Where | boolean {
+	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
 		return this.optimizeAnd(
 			Object.entries(where).map(([key, value]) => {
 				if (value === undefined || value === null) {
 					return undefined
 
 				} else if (key === 'and') {
-					return this.optimizeAnd((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity)), entity)
+					return this.optimizeAnd((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
 
 				} else if (key === 'or') {
-					return this.optimizeOr((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity)), entity)
+					return this.optimizeOr((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
 
 				} else if (key === 'not') {
-					return optimizeNot(this.optimizeWhere(value as Input.Where, entity))
+					return optimizeNot(this.optimizeWhere(value as Input.Where, entity, relationPath))
 
 				} else {
-					return this.resolveFieldValue(entity, key, value)
+					return this.resolveFieldValue(entity, key, value, relationPath)
 				}
 			}),
 			entity,
+			relationPath,
 		)
 	}
 
-	private optimizeOr(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity): Input.Where | boolean {
+	private optimizeOr(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
 		const optimized = optimizeOr(operands)
 		if (typeof optimized === 'boolean' || !Array.isArray(optimized.or)) {
 			return optimized
 		}
-		const result = this.crossOptimize(optimized.or, entity, { never: true })
-		return optimizeOr(result.map(it => this.optimizeWhere(it, entity)))
+		const result = this.crossOptimize(optimized.or, entity, { never: true }, relationPath)
+		return optimizeOr(result)
 	}
 
-	private optimizeAnd(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity): Input.Where | boolean {
+	private optimizeAnd(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
 		const optimized = optimizeAnd(operands)
 		if (typeof optimized === 'boolean' || !Array.isArray(optimized.and)) {
 			return optimized
 		}
-		const result = this.crossOptimize(optimized.and, entity, { always: true })
-		return optimizeAnd(result.map(it => this.optimizeWhere(it, entity)))
+		const result = this.crossOptimize(optimized.and, entity, { always: true }, relationPath)
+		return optimizeAnd(result)
 	}
 
-	private crossOptimize(operands: Input.Where[], entity: Model.Entity, replacement: Input.Condition): Input.Where[] {
-		const result = [...operands]
+	private crossOptimize(operands: Input.Where[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.Where | boolean)[] {
+		const result: (Input.Where | boolean)[] = [...operands]
 		const count = result.length
 		for (let i = 0; i < count; i++) {
 			for (let j = 0; j < count; j++) {
-				if (i !== j) {
-					result[j] = replaceWhere(result[j], result[i], { [entity.primary]: replacement })
+				const a = result[j]
+				const b = result[i]
+				if (i !== j && typeof a !== 'boolean' && typeof b !== 'boolean') {
+					const tracker = { count: 0 }
+					const elResult = replaceWhere(a, b, { [entity.primary]: replacement }, tracker)
+					result[j] = tracker.count > 0 ? this.optimizeWhere(elResult, entity, relationPath) : elResult
 				}
 			}
 		}
 		return result
 	}
 
-	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string]) {
+	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string], relationPath: ExtendedRelationContext[]) {
 		return acceptFieldVisitor<Input.Where | boolean>(this.model, entity, key, {
 			visitColumn: () => {
 				const optimizedCondition = this.conditionOptimizer.optimize(value as Input.Condition)
@@ -86,8 +110,22 @@ export class WhereOptimizer {
 
 				return { [key]: optimizedCondition }
 			},
-			visitRelation: (entity, relation, targetEntity) => {
-				const optimizedWhere = this.optimizeWhere(value as Input.Where, targetEntity)
+			visitRelation: context => {
+				const { targetEntity, relation } = context
+				let where = value as Input.Where
+				const newRelationPath: ExtendedRelationContext[] = [...relationPath]
+				if (relationPath.length && relationPath[relationPath.length - 1].targetRelation?.name === relation.name) {
+					const item = newRelationPath.pop()
+					if (item?.canEliminate && (item.type === 'oneHasMany' || item.type === 'oneHasOneOwning' || item.type === 'oneHasOneInverse')) {
+						where = replaceWhere(where, { [targetEntity.primary]: { isNull: true } }, { [targetEntity.primary]: { never: true } })
+						where = replaceWhere(where, { [targetEntity.primary]: { isNull: false } }, { [targetEntity.primary]: { always: true } })
+					}
+				} else {
+					// first level relation - we are sure root exists
+					const canEliminate = relationPath.length === 0 || relationPath[relationPath.length - 1].isLast
+					newRelationPath.push({ ...context, isLast: false, canEliminate })
+				}
+				const optimizedWhere = this.optimizeWhere(where, targetEntity, newRelationPath)
 
 				if (typeof optimizedWhere === 'boolean') {
 					return optimizedWhere

package/src/mapper/select/optimizer/WhereReplacer.ts

@@ -1,17 +1,22 @@
 import { Input, Writable } from '@contember/schema'
 import deepEqual from 'fast-deep-equal'
 
-export const replaceWhere = (subject: Input.Where, find: Input.Where, replace: Input.Where): Input.Where => {
+export interface ReplaceWhereResult {
+	count: number
+}
+
+export const replaceWhere = (subject: Input.Where, find: Input.Where, replace: Input.Where, resultTracker: ReplaceWhereResult = { count: 0 }): Input.Where => {
 	if (deepEqual(subject, find)) {
+		resultTracker.count++
 		return replace
 	}
 	const result: Writable<Input.Where> = {}
 	for (const [key, value] of Object.entries(subject)) {
 		if (key === 'not') {
-			result['not'] = replaceWhere(value as Input.Where, find, replace)
+			result['not'] = replaceWhere(value as Input.Where, find, replace, resultTracker)
 
 		} else if (key === 'and' || key === 'or') {
-			result[key] = (value as Input.Where[]).map(it => replaceWhere(it, find, replace))
+			result[key] = (value as Input.Where[]).map(it => replaceWhere(it, find, replace, resultTracker))
 
 		} else {
 			result[key] = value

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -26,7 +26,7 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationRes
 		private readonly mapper: Mapper,
 	) {}
 
-	public column({ entity, column }: Context.ColumnContext) {
+	public column({ entity, column }: Model.ColumnContext) {
 		if (this.data[column.name] !== undefined) {
 			this.updateBuilder.addFieldValue(column.name, this.data[column.name] as Value.AtomicValue)
 		}

package/src/mapper/update/UpdateBuilder.ts

@@ -74,9 +74,9 @@ export class UpdateBuilder {
 					const columns = new Set(resolvedData.map(it => it.columnName))
 					const allColumns: string[] = Object.values(
 						acceptEveryFieldVisitor(this.schema, this.entity, {
-							visitColumn: (entity, column) => column.columnName,
-							visitManyHasOne: (entity, relation) => relation.joiningColumn.columnName,
-							visitOneHasOneOwning: (entity, relation) => relation.joiningColumn.columnName,
+							visitColumn: ({ column }) => column.columnName,
+							visitManyHasOne: ({ relation }) => relation.joiningColumn.columnName,
+							visitOneHasOneOwning: ({ relation }) => relation.joiningColumn.columnName,
 							visitManyHasManyInverse: () => null,
 							visitManyHasManyOwning: () => null,
 							visitOneHasOneInverse: () => null,

package/src/resolvers/MutationResolver.ts

@@ -457,7 +457,7 @@ export class MutationResolver {
 				throw new Error('MutationResolver: expected ObjectNode')
 			}
 			const objectWithArgs = singleNodeQuery.withArgs({ by: where })
-			nodes[singleNodeQuery.alias] = await mapper.selectUnique(entity, objectWithArgs, null)
+			nodes[singleNodeQuery.alias] = await mapper.selectUnique(entity, objectWithArgs, [])
 		}
 		return nodes
 	}

package/src/resolvers/ReadHelpers.ts

@@ -15,7 +15,7 @@ export const paginate = async (
 	const totalCount = paginationHelper.requiresTotalCount
 		? await mapper.count(entity, queryAst.args.filter || {})
 		: undefined
-	const nodes = paginationHelper.nodeField ? await mapper.select(entity, paginationHelper.nodeField, null) : undefined
+	const nodes = paginationHelper.nodeField ? await mapper.select(entity, paginationHelper.nodeField, []) : undefined
 
 	return paginationHelper.createResponse(totalCount, nodes)
 }
@@ -37,9 +37,9 @@ export const executeReadOperations = async (
 		trxResult[field.alias] = await (() => {
 			switch (meta.operation) {
 				case Operation.get:
-					return mapper.selectUnique(meta.entity, field, null)
+					return mapper.selectUnique(meta.entity, field, [])
 				case Operation.list:
-					return mapper.select(meta.entity, field, null)
+					return mapper.select(meta.entity, field, [])
 				case Operation.paginate:
 					return paginate(mapper, meta.entity, field)
 				case Operation.create:

package/src/resolvers/ReadResolver.ts

@@ -33,12 +33,12 @@ export class ReadResolver {
 
 	public async resolveListQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.ListQueryInput> = this.queryAstFactory.create(info)
-		return await this.mapperFactory(this.db).select(entity, queryAst, null)
+		return await this.mapperFactory(this.db).select(entity, queryAst, [])
 	}
 
 	public async resolveGetQuery(entity: Model.Entity, info: GraphQLResolveInfo) {
 		const queryAst: ObjectNode<Input.UniqueQueryInput> = this.queryAstFactory.create(info)
-		return await this.mapperFactory(this.db).selectUnique(entity, queryAst, null)
+		return await this.mapperFactory(this.db).selectUnique(entity, queryAst, [])
 	}
 
 	public async resolvePaginationQuery(entity: Model.Entity, info: GraphQLResolveInfo) {

package/src/schema/FieldAccessVisitor.ts

@@ -7,11 +7,11 @@ export class FieldAccessVisitor implements Model.ColumnVisitor<boolean>, Model.R
 		private readonly authorizator: Authorizator,
 	) {}
 
-	visitColumn(entity: Model.Entity, column: Model.AnyColumn) {
+	visitColumn({ column, entity }: Model.ColumnContext) {
 		return this.authorizator.getFieldPermissions(this.operation, entity.name, column.name) !== 'no'
 	}
 
-	visitRelation({}, {}, targetEntity: Model.Entity) {
+	visitRelation({ targetEntity }: Model.AnyRelationContext) {
 		return this.authorizator.getEntityPermission(this.operation, targetEntity.name) !== 'no'
 	}
 }

package/src/schema/OrderByTypeProvider.ts

@@ -51,7 +51,7 @@ export class OrderByTypeProvider {
 
 			const field = acceptFieldVisitor(this.schema, name, fieldName, {
 				visitColumn: () => ({ type: this.orderDirectionEnum }),
-				visitHasOne: (entity, relation) => ({ type: this.getEntityOrderByType(relation.target) }),
+				visitHasOne: ({ relation }) => ({ type: this.getEntityOrderByType(relation.target) }),
 				visitHasMany: () => undefined,
 			} as Model.FieldVisitor<GraphQLInputFieldConfig | undefined>)
 

package/src/schema/WhereTypeProvider.ts

@@ -74,7 +74,7 @@ export class WhereTypeProvider {
 					continue
 				}
 				fields[field] = acceptFieldVisitor<GraphQLInputFieldConfig>(this.schema, entity, field, {
-					visitRelation: (entity, relation, targetEntity) => {
+					visitRelation: ({ targetEntity }) => {
 						// if (!isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn')) {
 						// 	throw new Error('Only column or owning relation can be a part of unique key')
 						// }
@@ -84,7 +84,7 @@ export class WhereTypeProvider {
 						}
 						return { type: uniqueWhere }
 					},
-					visitColumn: (entity, column) => ({ type: this.columnTypeResolver.getType(column) }),
+					visitColumn: ({ column }) => ({ type: this.columnTypeResolver.getType(column) }),
 				})
 			}
 		}
@@ -104,8 +104,8 @@ export class WhereTypeProvider {
 				continue
 			}
 			fields[fieldName] = acceptFieldVisitor(this.schema, name, fieldName, {
-				visitColumn: (entity, column) => ({ type: this.conditionTypeProvider.getCondition(column) }),
-				visitRelation: (entity, relation) => ({ type: this.getEntityWhereType(relation.target) }),
+				visitColumn: ({ column }) => ({ type: this.conditionTypeProvider.getCondition(column) }),
+				visitRelation: ({ relation }) => ({ type: this.getEntityWhereType(relation.target) }),
 			} as Model.FieldVisitor<GraphQLInputFieldConfig>)
 		}
 

package/src/schema/entities/FieldArgsVisitor.ts

@@ -15,11 +15,11 @@ export class FieldArgsVisitor implements
 		this.whereTypeProvider = whereTypeProvider
 	}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn) {
+	public visitColumn() {
 		return undefined
 	}
 
-	public visitHasMany(entity: Model.Entity, relation: Model.Relation) {
+	public visitHasMany({ relation }: Model.AnyHasManyRelationContext) {
 		const filter = this.getWhereArg(relation)
 		const orderBy = this.getOrderByArgs(relation)
 		return {
@@ -30,7 +30,7 @@ export class FieldArgsVisitor implements
 		}
 	}
 
-	public visitHasOne(entity: Model.Entity, relation: Model.Relation) {
+	public visitHasOne({ relation }: Model.ManyHasOneContext) {
 		const filter = this.getWhereArg(relation)
 		return { filter }
 	}

package/src/schema/entities/FieldTypeVisitor.ts

@@ -13,7 +13,7 @@ export class FieldTypeVisitor implements Model.ColumnVisitor<GraphQLOutputType>,
 	) {
 	}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): GraphQLOutputType {
+	public visitColumn({ column, entity }: Model.ColumnContext): GraphQLOutputType {
 		const basicType = this.columnTypeResolver.getType(column)
 		const fieldPredicate = this.authorizator.getFieldPredicate(Acl.Operation.read, entity.name, column.name)
 		const idPredicate = this.authorizator.getFieldPredicate(Acl.Operation.read, entity.name, entity.primary)
@@ -26,12 +26,12 @@ export class FieldTypeVisitor implements Model.ColumnVisitor<GraphQLOutputType>,
 		return basicType
 	}
 
-	public visitHasMany(entity: Model.Entity, relation: Model.Relation): GraphQLOutputType {
+	public visitHasMany({ relation }: Model.AnyHasManyRelationContext): GraphQLOutputType {
 		const entityType = this.entityTypeProvider.getEntity(relation.target)
 		return new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(entityType)))
 	}
 
-	public visitHasOne(entity: Model.Entity, relation: Model.Relation & Model.NullableRelation): GraphQLOutputType {
+	public visitHasOne({ relation }: Model.AnyHasOneRelationContext): GraphQLOutputType {
 		return this.entityTypeProvider.getEntity(relation.target)
 	}
 }

package/src/schema/mutations/CreateEntityInputFieldVisitor.ts

@@ -15,7 +15,7 @@ export class CreateEntityInputFieldVisitor implements
 		private readonly createEntityRelationInputProvider: CreateEntityRelationInputProvider,
 	) {}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): GraphQLInputFieldConfig | undefined {
+	public visitColumn({ entity, column }: Model.ColumnContext): GraphQLInputFieldConfig | undefined {
 		if (entity.primary === column.name && !this.authorizator.isCustomPrimaryAllowed(entity.name)) {
 			return undefined
 		}
@@ -28,10 +28,7 @@ export class CreateEntityInputFieldVisitor implements
 		}
 	}
 
-	public visitHasOne(
-		entity: Model.Entity,
-		relation: Model.Relation & Model.NullableRelation,
-	): GraphQLInputFieldConfig | undefined {
+	public visitHasOne({ entity, relation }: Model.AnyHasOneRelationContext): GraphQLInputFieldConfig | undefined {
 		const type = this.createEntityRelationInputProvider.getCreateEntityRelationInput(entity.name, relation.name)
 		if (type === undefined) {
 			return undefined
@@ -41,7 +38,7 @@ export class CreateEntityInputFieldVisitor implements
 		}
 	}
 
-	public visitHasMany(entity: Model.Entity, relation: Model.Relation): GraphQLInputFieldConfig | undefined {
+	public visitHasMany({ entity, relation }: Model.AnyHasManyRelationContext): GraphQLInputFieldConfig | undefined {
 		const type = this.createEntityRelationInputProvider.getCreateEntityRelationInput(entity.name, relation.name)
 		if (type === undefined) {
 			return undefined

package/src/schema/mutations/CreateEntityRelationAllowedOperationsVisitor.ts

@@ -12,32 +12,23 @@ export class CreateEntityRelationAllowedOperationsVisitor implements
 		throw new ImplementationException('CreateEntityRelationAllowedOperationsVisitor: Not applicable for a column')
 	}
 
-	public visitManyHasManyInverse({}, {}, targetEntity: Model.Entity, targetRelation: Model.ManyHasManyOwningRelation) {
+	public visitManyHasManyInverse({ targetEntity, targetRelation }: Model.ManyHasManyInverseContext) {
 		return this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-	) {
+	public visitManyHasManyOwning({ entity, targetEntity, relation }: Model.ManyHasManyOwningContext) {
 		return this.getAllowedOperations(targetEntity, entity, relation)
 	}
 
-	public visitOneHasMany({}, {}, targetEntity: Model.Entity, targetRelation: Model.ManyHasOneRelation) {
+	public visitOneHasMany({ targetEntity, targetRelation }: Model.OneHasManyContext) {
 		return this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity) {
+	public visitManyHasOne({ targetEntity, entity, relation }: Model.ManyHasOneContext) {
 		return this.getAllowedOperations(targetEntity, entity, relation)
 	}
 
-	public visitOneHasOneInverse(
-		{},
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	) {
+	public visitOneHasOneInverse({ targetEntity, targetRelation, relation }: Model.OneHasOneInverseContext) {
 		const operations = this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 		if (relation.nullable || targetRelation.nullable) {
 			return operations
@@ -45,12 +36,7 @@ export class CreateEntityRelationAllowedOperationsVisitor implements
 		return operations.filter(it => it === Input.CreateRelationOperation.create)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	) {
+	public visitOneHasOneOwning({ targetEntity, entity, relation, targetRelation }: Model.OneHasOneOwningContext) {
 		const operations = this.getAllowedOperations(targetEntity, entity, relation)
 		if (!targetRelation || targetRelation.nullable || relation.nullable) {
 			return operations