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

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

@@ -2,48 +2,160 @@ import { Input, Model } from '@contember/schema'
 import { ConditionOptimizer } from './ConditionOptimizer'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
+import { replaceWhere } from './WhereReplacer'
+
+type ExtendedRelationContext =
+	& {
+		context: Model.AnyRelationContext
+		canEliminate: boolean
+		isLast: boolean
+	}
+
+export interface WhereOptimizationHints {
+	relationPath?: Model.AnyRelationContext[]
+	evaluatedPredicates?: Input.OptionalWhere[]
+}
+
+type OptimizedOperand = Input.OptionalWhere | undefined | 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 = [], evaluatedPredicates = [] }: WhereOptimizationHints = {}): Input.OptionalWhere {
+		let processedRelationPath: ExtendedRelationContext[] = []
+		for (const i in relationPath) {
+			const el = relationPath[i]
+			if (!WhereOptimizer.eliminableRelations.has(el.type)) {
+				processedRelationPath = []
+			} else {
+				processedRelationPath.push({ context: el, canEliminate: true, isLast: Number(i) === relationPath.length })
+			}
+		}
+		let result = this.optimizeWhere(where, entity, processedRelationPath)
 
 		if (typeof result === 'boolean') {
 			return { [entity.primary]: { [result ? 'always' : 'never']: true } }
 		}
+		let changed = false
+		for (const evaluated of evaluatedPredicates) {
+			const evaluatedPredicate = this.optimize(evaluated, entity)
+			const newResult = replaceWhere(result, evaluatedPredicate, { [entity.primary]: { always: true } })
+			if (newResult !== result) {
+				result = newResult
+				changed = true
+			}
+		}
+		if (changed) {
+			return this.optimize(result, entity)
+		}
 
 		return result
 	}
 
-	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity): Input.Where | boolean {
-		return optimizeAnd(
-			Object.entries(where).map(([key, value]) => {
-				if (value === undefined || value === null) {
-					return undefined
+	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
+		const operands: OptimizedOperand[] = []
 
-				} else if (key === 'and') {
-					return optimizeAnd((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity)))
+		for (const key in where) {
+			const value = where[key]
+			let operand: OptimizedOperand = undefined
+			if (value === undefined || value === null) {
+				continue
+			} else if (key === 'and') {
+				const innerOperands: (Input.OptionalWhere | boolean)[] = []
+				for (const innerValue of value as readonly Input.OptionalWhere[]) {
+					const innerOperand = this.optimizeWhere(innerValue, entity, relationPath)
+					if (innerOperand === false) {
+						return false
+					}
+					innerOperands.push(innerOperand)
+				}
+				operand = this.optimizeAnd(innerOperands, entity, relationPath)
+			} else if (key === 'or') {
+				const innerOperands: (Input.OptionalWhere | boolean)[] = []
+				for (const innerValue of value as readonly Input.OptionalWhere[]) {
+					const innerOperand = this.optimizeWhere(innerValue, entity, relationPath)
+					if (innerOperand === true) {
+						operand = true
+						break
+					}
+					innerOperands.push(innerOperand)
+				}
+				if (operand !== true) {
+					operand = this.optimizeOr(innerOperands, entity, relationPath)
+				}
 
-				} else if (key === 'or') {
-					return optimizeOr((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity)))
+			} else if (key === 'not') {
+				operand = optimizeNot(this.optimizeWhere(value as Input.OptionalWhere, entity, relationPath))
 
-				} else if (key === 'not') {
-					return optimizeNot(this.optimizeWhere(value as Input.Where, entity))
+			} else {
+				operand = this.resolveFieldValue(entity, key, value, relationPath)
+			}
 
-				} else {
-					return this.resolveFieldValue(entity, key, value)
+			if (operand === false) {
+				return false
+
+			} else if (operand !== undefined) {
+				operands.push(operand)
+			}
+		}
+		return this.optimizeAnd(operands, entity, relationPath)
+	}
+
+	private optimizeOr(operands: readonly OptimizedOperand[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
+		const optimized = optimizeOr(operands)
+		if (typeof optimized === 'boolean' || !Array.isArray(optimized.or)) {
+			return optimized
+		}
+		const result = this.crossOptimize(optimized.or, entity, { never: true }, relationPath)
+		if (result === optimized.or) {
+			return optimized
+		}
+		return optimizeOr(result)
+	}
+
+	private optimizeAnd(operands: readonly OptimizedOperand[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
+		const optimized = optimizeAnd(operands)
+		if (typeof optimized === 'boolean' || !Array.isArray(optimized.and)) {
+			return optimized
+		}
+		const result = this.crossOptimize(optimized.and, entity, { always: true }, relationPath)
+		if (result === optimized.and) {
+			return optimized
+		}
+		return optimizeAnd(result)
+	}
+
+	private crossOptimize(operands: Input.OptionalWhere[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.OptionalWhere | boolean)[] {
+		let result: (Input.OptionalWhere | boolean)[] = operands
+		let copied = false
+		const count = result.length
+		for (let i = 0; i < count; i++) {
+			for (let j = 0; j < count; j++) {
+				const a = result[j]
+				const b = result[i]
+				if (i !== j && typeof a !== 'boolean' && typeof b !== 'boolean') {
+					const elResult = replaceWhere(a, b, { [entity.primary]: replacement })
+					if (elResult !== a) {
+						if (!copied) {
+							result = [...result]
+							copied = true
+						}
+						result[j] = this.optimizeWhere(elResult, entity, relationPath)
+					}
 				}
-			}),
-		)
+			}
+		}
+		return result
 	}
 
-	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string]) {
-		return acceptFieldVisitor<Input.Where | boolean>(this.model, entity, key, {
+	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string], relationPath: ExtendedRelationContext[]) {
+		return acceptFieldVisitor<Input.OptionalWhere | boolean>(this.model, entity, key, {
 			visitColumn: () => {
 				const optimizedCondition = this.conditionOptimizer.optimize(value as Input.Condition)
 
@@ -53,8 +165,23 @@ export class WhereOptimizer {
 
 				return { [key]: optimizedCondition }
 			},
-			visitRelation: (entity, relation, targetEntity) => {
-				const optimizedWhere = this.optimizeWhere(value as Input.Where, targetEntity)
+			visitRelation: context => {
+				let where = value as Input.OptionalWhere
+				const newRelationPath: ExtendedRelationContext[] = [...relationPath]
+				const length = relationPath.length
+				if (length > 0 && relationPath[length - 1].context.targetRelation?.name === context.relation.name) {
+					const item = newRelationPath.pop()
+					const type = item!.context.type
+					if (item?.canEliminate && (type === 'oneHasMany' || type === 'oneHasOneOwning' || type === 'oneHasOneInverse')) {
+						where = replaceWhere(where, { [context.targetEntity.primary]: { isNull: true } }, { [context.targetEntity.primary]: { never: true } })
+						where = replaceWhere(where, { [context.targetEntity.primary]: { isNull: false } }, { [context.targetEntity.primary]: { always: true } })
+					}
+				} else {
+					// first level relation - we are sure root exists
+					const canEliminate = length === 0 || relationPath[length - 1].isLast
+					newRelationPath.push({ context, isLast: false, canEliminate })
+				}
+				const optimizedWhere = this.optimizeWhere(where, context.targetEntity, newRelationPath)
 
 				if (typeof optimizedWhere === 'boolean') {
 					return optimizedWhere

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

@@ -0,0 +1,39 @@
+import { Input, Writable } from '@contember/schema'
+import deepEqual from 'fast-deep-equal'
+
+export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere): Input.OptionalWhere => {
+	if (deepEqual(subject, find)) {
+		return replace
+	}
+	let result: Writable<Input.OptionalWhere> = subject
+	let copied = false
+	for (const key in subject) {
+		const value = subject[key]
+		if (key === 'not') {
+			const newNot = replaceWhere(value as Input.OptionalWhere, find, replace)
+			if (newNot !== value) {
+				if (!copied) {
+					result = { ...result }
+				}
+				result['not'] = newNot
+			}
+		} else if (key === 'and' || key === 'or') {
+			const items: Input.OptionalWhere[] = []
+			let itemChanged = false
+			for (const el of value as Input.OptionalWhere[]) {
+				const newEl = replaceWhere(el, find, replace)
+				if (newEl !== el) {
+					itemChanged = true
+				}
+				items.push(newEl)
+			}
+			if (itemChanged) {
+				if (!copied) {
+					result = { ...result }
+				}
+				result[key] = items
+			}
+		}
+	}
+	return result
+}

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

@@ -1,10 +1,12 @@
-export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly (P | boolean)[]): P | { or?: P[] } | boolean => {
+export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly (P | boolean | undefined)[]): P | { or?: P[] } | boolean => {
 	const normalized: P[] = []
-
+	let hasNever = false
 	for (const operand of operands) {
 		if (operand === true) {
 			return true
-		} else if (operand !== false) {
+		} else if (operand === false) {
+			hasNever = true
+		} else if (operand !== undefined)  {
 			normalized.push(...Array.isArray(operand.or) ? operand.or : [operand])
 		}
 	}
@@ -13,6 +15,8 @@ export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly
 		return { or: normalized }
 	} else if (normalized.length === 1) {
 		return normalized[0]
+	} else if (hasNever) {
+		return false
 	} else {
 		return {}
 	}

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -2,7 +2,6 @@ import { Input, Model, Value } from '@contember/schema'
 import { Mapper } from '../Mapper'
 import { UpdateBuilder } from './UpdateBuilder'
 import { UpdateInputProcessor } from '../../inputProcessing'
-import * as Context from '../../inputProcessing'
 import {
 	ConstraintType,
 	getInsertPrimary,
@@ -17,6 +16,7 @@ import { hasManyProcessor, hasOneProcessor } from '../MutationProcessorHelper'
 import { AbortUpdate } from './Updater'
 import { ImplementationException } from '../../exception'
 import { CheckedPrimary } from '../CheckedPrimary'
+import { logger } from '@contember/logger'
 
 export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationResultList> {
 	constructor(
@@ -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)
 		}
@@ -228,10 +228,7 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationRes
 				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
 			}
 			if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
-				// eslint-disable-next-line no-console
-				console.error(
-					'[DEPRECATED] You are deleting an entity over the relation where onDelete behaviour is set to restrict. This will fail in next version.',
-				)
+				logger.warn('You are deleting an entity over the relation where onDelete behaviour is set to restrict. This will fail in next version.', { loc: 'SqlUpdateInputProcessor' })
 				this.updateBuilder.addFieldValue(relation.name, null)
 			}
 			const inversePrimary = await this.mapper.selectField(
@@ -490,10 +487,7 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationRes
 				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
 			}
 			if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
-				// eslint-disable-next-line no-console
-				console.error(
-					'[DEPRECATED] You are deleting an entity over the relation where onDelete behaviour is set to restrict. This will fail in next version.',
-				)
+				logger.warn('You are deleting an entity over the relation where onDelete behaviour is set to restrict. This will fail in next version.', { loc: 'SqlUpdateInputProcessor' })
 				this.updateBuilder.addFieldValue(relation.name, null)
 			}
 			const targetPrimary = await this.mapper.selectField(

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

@@ -15,7 +15,7 @@ import {
 import { ValidationResolver } from './ValidationResolver'
 import { Providers } from '@contember/schema-utils'
 import { GraphQlQueryAstFactory } from './GraphQlQueryAstFactory'
-import { getArgumentValues } from 'graphql/execution/values'
+import { getArgumentValues } from 'graphql'
 import { createMapperContainer } from '../mapper'
 
 export interface ExecutionContainer {

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -2,17 +2,18 @@ import { isIt, ResolveInfoUtils } from '../utils'
 import {
 	FieldNode as GraphQlFieldNode,
 	FragmentSpreadNode,
+	getArgumentValues,
 	GraphQLObjectType,
 	GraphQLOutputType,
 	GraphQLResolveInfo,
 	isListType,
 	isNonNullType,
-	isObjectType, Kind,
+	isObjectType,
+	Kind,
+	SelectionSetNode,
 } from 'graphql'
-import { SelectionSetNode } from 'graphql/language/ast'
-import { getArgumentValues } from 'graphql/execution/values'
 import { FieldNode, ObjectNode } from '../inputProcessing'
-import { isDeepStrictEqual } from 'util'
+import { isDeepStrictEqual } from 'node:util'
 
 type NodeFilter = (node: GraphQlFieldNode, path: string[]) => boolean
 type AnyNode = ObjectNode | FieldNode

package/src/resolvers/MutationResolver.ts

@@ -2,13 +2,13 @@ import { Input, Model, Result, Value } from '@contember/schema'
 import {
 	ConstraintType,
 	getInsertPrimary,
-	getUpdatePrimary,
 	InputErrorKind,
 	Mapper,
 	MapperFactory,
 	MutationResultHint,
 	MutationResultList,
-	MutationResultType, tryMutation,
+	MutationResultType,
+	tryMutation,
 } from '../mapper'
 import { ValidationResolver } from './ValidationResolver'
 import { GraphQLResolveInfo } from 'graphql'
@@ -20,6 +20,7 @@ import { assertNever } from '../utils'
 import { InputPreValidator } from '../input-validation'
 import { ObjectNode } from '../inputProcessing'
 import { executeReadOperations } from './ReadHelpers'
+import { logger } from '@contember/logger'
 
 type WithoutNode<T extends { node: any }> = Pick<T, Exclude<keyof T, 'node'>>
 
@@ -61,6 +62,7 @@ export class MutationResolver {
 
 		return this.transaction(async (mapper, trx) => {
 			if (options?.deferForeignKeyConstraints) {
+				logger.debug('MutationResolver: deferring foreign constraints')
 				await mapper.constraintHelper.setFkConstraintsDeferred()
 			}
 			const validationResult: Record<string, Result.MutationFieldResult> = {}
@@ -144,7 +146,7 @@ export class MutationResolver {
 				}
 
 				const meta = readOperationMeta(fieldConfig.extensions)
-
+				logger.debug('MutationResolver: Resolving a field', { field: field.alias })
 				const result: {
 					ok: boolean
 					validation?: Result.ValidationResult
@@ -168,6 +170,7 @@ export class MutationResolver {
 				})()
 
 				if (!result.ok) {
+					logger.debug('MutationResolver: Field evaluation failed', { result, field: field.alias })
 					const validationErrors = result.validation ? prefixErrors(result.validation.errors, field.alias) : []
 					const executionErrors = prefixErrors(result.errors, field.alias)
 					return {
@@ -192,12 +195,14 @@ export class MutationResolver {
 				trxResult[field.alias] = result
 			}
 			if (options?.deferForeignKeyConstraints) {
+				logger.debug('MutationResolver: validating fk constraints')
 				const constraintsResult = await tryMutation(this.schema, async () => {
 					await mapper.constraintHelper.setFkConstraintsImmediate()
 					return []
 				})
 				const errorResponse = this.createErrorResponse(constraintsResult)
 				if (errorResponse) {
+					logger.debug('MutationResolver: deferred fk validation failed', { errorResponse })
 					return { ...errorResponse, ...validationResult }
 				}
 			}
@@ -457,7 +462,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
 	}
@@ -468,17 +473,22 @@ export class MutationResolver {
 		return await retryTransaction(
 			async () => {
 				return await this.db.transaction(async trx => {
+					logger.debug('MutationResolver: Starting mutation transaction')
 					await trx.connection.query(Connection.REPEATABLE_READ)
 					await this.systemVariablesSetup(trx)
 					const mapper = this.mapperFactory(trx)
 
 					const result = await cb(mapper, trx)
 					if (!result.ok) {
+						logger.debug('MutationResolver: Transaction failed, rolling back', { result })
 						await trx.connection.rollback()
+					} else {
+						logger.debug('MutationResolver: Transaction ok, committing')
 					}
 					return result
 				})
 			},
+			message => logger.warn(message),
 			{
 				maxAttempts: 15,
 				minTimeout: 10,

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

@@ -1,8 +1,6 @@
-import { GraphQLEnumType } from 'graphql'
-import { GraphQLEnumValueConfigMap } from 'graphql/type/definition'
+import { GraphQLEnumType, GraphQLEnumValueConfigMap } from 'graphql'
 import { Model } from '@contember/schema'
-import { singletonFactory } from '../utils'
-import { capitalizeFirstLetter } from '../utils'
+import { capitalizeFirstLetter, singletonFactory } from '../utils'
 
 export class EnumsProvider {
 	private schema: Model.Schema

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

@@ -1,11 +1,18 @@
-import { GraphQLInputFieldConfig, GraphQLInputFieldConfigMap, GraphQLInputType } from 'graphql/type/definition'
+import {
+	GraphQLBoolean,
+	GraphQLEnumType,
+	GraphQLInputFieldConfig,
+	GraphQLInputFieldConfigMap,
+	GraphQLInputObjectType,
+	GraphQLInputType,
+	GraphQLInt,
+} from 'graphql'
 import { Acl, Model } from '@contember/schema'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { singletonFactory } from '../utils'
 import { GqlTypeName } from './utils'
 import { Authorizator } from '../acl'
 import { FieldAccessVisitor } from './FieldAccessVisitor'
-import { GraphQLBoolean, GraphQLEnumType, GraphQLInputObjectType, GraphQLInt } from 'graphql'
 
 export class OrderByTypeProvider {
 	private orderBySingleton = singletonFactory(name => this.createEntityOrderByType(name))
@@ -51,7 +58,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

@@ -1,7 +1,6 @@
 import { Acl, Model } from '@contember/schema'
 import { acceptFieldVisitor, getEntity } from '@contember/schema-utils'
-import { GraphQLInputObjectType, GraphQLList } from 'graphql'
-import { GraphQLInputFieldConfig, GraphQLInputFieldConfigMap } from 'graphql/type/definition'
+import { GraphQLInputFieldConfig, GraphQLInputFieldConfigMap, GraphQLInputObjectType, GraphQLList } from 'graphql'
 import { capitalizeFirstLetter, getFieldsForUniqueWhere, singletonFactory } from '../utils'
 import { ColumnTypeResolver } from './ColumnTypeResolver'
 import { ConditionTypeProvider } from './ConditionTypeProvider'
@@ -74,7 +73,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 +83,7 @@ export class WhereTypeProvider {
 						}
 						return { type: uniqueWhere }
 					},
-					visitColumn: (entity, column) => ({ type: this.columnTypeResolver.getType(column) }),
+					visitColumn: ({ column }) => ({ type: this.columnTypeResolver.getType(column) }),
 				})
 			}
 		}
@@ -104,8 +103,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

@@ -1,8 +1,7 @@
 import { Model } from '@contember/schema'
 import { WhereTypeProvider } from '../WhereTypeProvider'
-import { GraphQLFieldConfigArgumentMap } from 'graphql/type/definition'
+import { GraphQLFieldConfigArgumentMap, GraphQLInt, GraphQLList, GraphQLNonNull } from 'graphql'
 import { OrderByTypeProvider } from '../OrderByTypeProvider'
-import { GraphQLInt, GraphQLList, GraphQLNonNull } from 'graphql'
 
 export class FieldArgsVisitor implements
 	Model.ColumnVisitor<GraphQLFieldConfigArgumentMap | undefined>,
@@ -15,11 +14,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 +29,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)
 	}
 }