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

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

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

package/src/schema/mutations/CreateEntityRelationInputFieldVisitor.ts

@@ -1,10 +1,9 @@
-import { GraphQLInputObjectType, GraphQLString } from 'graphql'
+import { GraphQLInputFieldConfigMap, GraphQLInputObjectType, GraphQLString } from 'graphql'
 import { Input, Model } from '@contember/schema'
 import { GqlTypeName } from '../utils'
 import { WhereTypeProvider } from '../WhereTypeProvider'
 import { Accessor, Interface } from '../../utils'
 import { EntityInputProvider, EntityInputType } from './EntityInputProvider'
-import { GraphQLInputFieldConfigMap } from 'graphql/type/definition'
 import { CreateEntityRelationAllowedOperationsVisitor } from './CreateEntityRelationAllowedOperationsVisitor'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { ImplementationException } from '../../exception'
@@ -26,29 +25,16 @@ export class CreateEntityRelationInputFieldVisitor implements
 		throw new ImplementationException('CreateEntityRelationInputFieldVisitor: Not applicable for a column')
 	}
 
-	public visitHasOne(
-		entity: Model.Entity,
-		relation: Model.Relation & Model.NullableRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
-	): GraphQLInputObjectType | undefined {
-		return this.createInputObject(entity, relation, targetEntity, targetRelation, false)
+	public visitHasOne(context: Model.ManyHasOneContext): GraphQLInputObjectType | undefined {
+		return this.createInputObject(context, false)
 	}
 
-	public visitHasMany(
-		entity: Model.Entity,
-		relation: Model.Relation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
-	): GraphQLInputObjectType | undefined {
-		return this.createInputObject(entity, relation, targetEntity, targetRelation, true)
+	public visitHasMany(context: Model.OneHasManyContext): GraphQLInputObjectType | undefined {
+		return this.createInputObject(context, true)
 	}
 
 	public createInputObject(
-		entity: Model.Entity,
-		relation: Model.Relation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
+		{ entity, relation, targetEntity, targetRelation }: Model.AnyRelationContext,
 		withAliasField: boolean,
 	): GraphQLInputObjectType | undefined {
 		const targetName = targetRelation ? targetRelation.name : undefined

package/src/schema/mutations/UpdateEntityInputFieldVisitor.ts

@@ -14,7 +14,7 @@ export class UpdateEntityInputFieldVisitor implements
 		private readonly updateEntityRelationInputProvider: UpdateEntityRelationInputProvider,
 	) {}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): GraphQLInputFieldConfig | undefined {
+	public visitColumn({ entity, column }: Model.ColumnContext) {
 		if (entity.primary === column.name) {
 			return undefined
 		}
@@ -27,10 +27,7 @@ export class UpdateEntityInputFieldVisitor implements
 		}
 	}
 
-	public visitHasOne(
-		entity: Model.Entity,
-		relation: Model.Relation & Model.NullableRelation,
-	): GraphQLInputFieldConfig | undefined {
+	public visitHasOne({ entity, relation }: Model.AnyHasOneRelationContext) {
 		const type = this.updateEntityRelationInputProvider.getUpdateEntityRelationInput(entity.name, relation.name)
 		if (type === undefined) {
 			return undefined
@@ -40,7 +37,7 @@ export class UpdateEntityInputFieldVisitor implements
 		}
 	}
 
-	public visitHasMany(entity: Model.Entity, relation: Model.Relation): GraphQLInputFieldConfig | undefined {
+	public visitHasMany({ entity, relation }: Model.AnyHasManyRelationContext) {
 		const type = this.updateEntityRelationInputProvider.getUpdateEntityRelationInput(entity.name, relation.name)
 		if (type === undefined) {
 			return undefined

package/src/schema/mutations/UpdateEntityRelationAllowedOperationsVisitor.ts

@@ -11,23 +11,19 @@ export class UpdateEntityRelationAllowedOperationsVisitor implements
 		throw new Error('UpdateEntityRelationAllowedOperationsVisitor: 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({ targetRelation, targetEntity }: Model.OneHasManyContext) {
 		return this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity) {
+	public visitManyHasOne({ targetEntity, relation, entity }: Model.ManyHasOneContext) {
 		const operations = this.getAllowedOperations(targetEntity, entity, relation)
 		if (relation.nullable) {
 			return operations
@@ -39,12 +35,7 @@ export class UpdateEntityRelationAllowedOperationsVisitor implements
 		return operations.filter(it => !forbiddenOperations.includes(it))
 	}
 
-	public visitOneHasOneInverse(
-		{},
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	) {
+	public visitOneHasOneInverse({ relation, targetEntity, targetRelation }: Model.OneHasOneInverseContext) {
 		const operations = this.getAllowedOperations(targetEntity, targetEntity, targetRelation)
 		if (relation.nullable || targetRelation.nullable) {
 			return operations
@@ -52,12 +43,7 @@ export class UpdateEntityRelationAllowedOperationsVisitor implements
 		return operations.filter(it => it === Input.UpdateRelationOperation.update)
 	}
 
-	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 (relation.nullable || !targetRelation || targetRelation.nullable) {
 			return operations

package/src/schema/mutations/UpdateEntityRelationInputFieldVisitor.ts

@@ -1,10 +1,15 @@
-import { GraphQLBoolean, GraphQLInputObjectType, GraphQLString } from 'graphql'
+import {
+	GraphQLBoolean,
+	GraphQLInputFieldConfig,
+	GraphQLInputFieldConfigMap,
+	GraphQLInputObjectType,
+	GraphQLString,
+} from 'graphql'
 import { Acl, Input, Model } from '@contember/schema'
 import { GqlTypeName } from '../utils'
 import { WhereTypeProvider } from '../WhereTypeProvider'
 import { Accessor, filterObject } from '../../utils'
 import { EntityInputProvider, EntityInputType } from './EntityInputProvider'
-import { GraphQLInputFieldConfig, GraphQLInputFieldConfigMap } from 'graphql/type/definition'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { UpdateEntityRelationAllowedOperationsVisitor } from './UpdateEntityRelationAllowedOperationsVisitor'
 import { Authorizator } from '../../acl'
@@ -27,12 +32,7 @@ export class UpdateEntityRelationInputFieldVisitor implements
 		throw new Error('UpdateEntityRelationInputFieldVisitor: Not applicable for a column')
 	}
 
-	public visitHasOne(
-		entity: Model.Entity,
-		relation: Model.Relation & Model.NullableRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
-	): GraphQLInputObjectType | undefined {
+	public visitHasOne({ targetRelation, targetEntity, relation, entity }: Model.AnyHasOneRelationContext) {
 		const withoutRelation = targetRelation ? targetRelation.name : undefined
 
 		const whereInput = this.createWhereInput(targetEntity)
@@ -84,12 +84,7 @@ export class UpdateEntityRelationInputFieldVisitor implements
 		})
 	}
 
-	public visitHasMany(
-		entity: Model.Entity,
-		relation: Model.Relation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.Relation | null,
-	): GraphQLInputObjectType | undefined {
+	public visitHasMany({ entity, relation, targetEntity, targetRelation }: Model.AnyHasManyRelationContext) {
 		const withoutRelation = targetRelation ? targetRelation.name : undefined
 
 		const whereInput = this.createWhereInput(targetEntity)

package/src/schema/utils.ts

@@ -1,5 +1,5 @@
 import { capitalizeFirstLetter } from '../utils'
-import { GraphQLFieldResolver } from 'graphql/type/definition'
+import { GraphQLFieldResolver } from 'graphql'
 
 export const GqlTypeName = (strings: TemplateStringsArray, ...values: string[]) => {
 	return strings.reduce((combined, string, i) => {

package/src/tsconfig.json

@@ -9,22 +9,22 @@
 			"path": "../../database/src"
 		},
 		{
-			"path": "../../engine-common/src"
+			"path": "../../dic/src"
 		},
 		{
-			"path": "../../schema/src"
+			"path": "../../graphql-utils/src"
 		},
 		{
-			"path": "../../schema-definition/src"
+			"path": "../../logger/src"
 		},
 		{
-			"path": "../../schema-utils/src"
+			"path": "../../schema/src"
 		},
 		{
-			"path": "../../dic/src"
+			"path": "../../schema-definition/src"
 		},
 		{
-			"path": "../../graphql-utils/src"
+			"path": "../../schema-utils/src"
 		}
 	]
 }

package/src/utils/uniqueWhereFields.ts

@@ -8,10 +8,10 @@ export const getFieldsForUniqueWhere = (schema: Model.Schema, entity: Model.Enti
 			visitColumn: () => undefined,
 			visitManyHasManyInverse: () => undefined,
 			visitManyHasManyOwning: () => undefined,
-			visitOneHasMany: ({}, relation) => [relation.name],
+			visitOneHasMany: ({ relation }) => [relation.name],
 			visitManyHasOne: () => undefined,
-			visitOneHasOneInverse: ({}, relation) => [relation.name],
-			visitOneHasOneOwning: ({}, relation) => [relation.name],
+			visitOneHasOneInverse: ({ relation }) => [relation.name],
+			visitOneHasOneOwning: ({ relation }) => [relation.name],
 		}),
 	).filter((it): it is [string] => !!it)
 

package/tests/cases/bugs/bug102.test.ts

@@ -48,12 +48,12 @@ test('Filter by has many with additional join', async () => {
 		executes: [
 			{
 				sql: SQL`
-select "root_"."id" as "root_id", "root_"."short_name" as "root_shortName", "root_"."id" as "root_id"
-from "public"."person" as "root_"
-where exists (select 1
-  from "public"."person_locale" as "sub_"
-    left join "public"."language" as "sub_locale" on "sub_"."locale_id" = "sub_locale"."id"
-  where "root_"."id" = "sub_"."person_id" and "sub_locale"."slug" = ? and not("sub_"."url_slug" is null))`,
+					select "root_"."id" as "root_id", "root_"."short_name" as "root_shortName", "root_"."id" as "root_id"
+					from "public"."person" as "root_"
+					where exists (select 1
+						from "public"."person_locale" as "root_locales"
+						left join  "public"."language" as "root_locales_locale" on  "root_locales"."locale_id" = "root_locales_locale"."id"
+						where "root_"."id" = "root_locales"."person_id" and "root_locales_locale"."slug" = ? and not("root_locales"."url_slug" is null))`,
 				response: { rows: [{ root_id: testUuid(1), root_shortName: 'John' }] },
 				parameters: ['cs'],
 			},

package/tests/cases/integration/graphQlRequests/delete/aclDelete.test.ts

@@ -50,12 +50,12 @@ test('delete post with acl', async () => {
 						],
 					},
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."post"
             where "id" in (select "root_"."id"