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

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

@@ -13,132 +13,87 @@ 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
-			const columnAlias = columnPath.alias
+		const tableAlias = columnPath.back().alias
+		const columnAlias = columnPath.alias
 
-			const fieldPredicate = this.predicateFactory.shouldApplyCellLevelPredicate(
-				entity,
-				Acl.Operation.read,
-				column.name,
-			)
-				? this.predicateFactory.create(entity, Acl.Operation.read, [column.name])
-				: undefined
-
-			if (!fieldPredicate || Object.keys(fieldPredicate).length === 0) {
-				return qb.select([tableAlias, column.columnName], columnAlias)
-			}
-			return this.whereBuilder.buildAdvanced(entity, columnPath.back(), fieldPredicate, cb =>
-				qb.select(
-					expr =>
-						expr.case(caseExpr =>
-							caseExpr
-								.when(
-									whenExpr => whenExpr.selectCondition(cb),
-									thenExpr => thenExpr.select([tableAlias, column.columnName]),
-								)
-								.else(elseExpr => elseExpr.raw('null')),
-						),
-					columnAlias,
-				),
-			)
+		this.executionContext.addColumn({
+			query: qb => qb.select([tableAlias, column.columnName], columnAlias),
+			predicate: this.getRequiredPredicate(entity, column),
 		})
 	}
 
-	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,
-			async ids =>
-				this.relationFetcher.fetchManyHasManyGroups(
-					{
-						mapper: this.mapper,
-						field: field,
-						targetEntity: targetEntity,
-						sourceRelation: relation,
-						targetRelation,
-						directionFrom: 'inverse',
-						ids: ids,
-					},
-				),
-			[],
-		)
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
+				this.relationFetcher.fetchManyHasManyGroups({
+					mapper: this.mapper,
+					field: field,
+					relationContext,
+					relationPath: this.relationPath,
+					ids: ids,
+				}),
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	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,
-			async ids =>
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
 				this.relationFetcher.fetchManyHasManyGroups({
 					mapper: this.mapper,
 					field: field,
-					targetEntity: targetEntity,
-					sourceRelation: relation,
-					targetRelation,
-					directionFrom: 'owning',
+					relationContext,
+					relationPath: this.relationPath,
 					ids: ids,
 				}),
-			[],
-		)
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	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,
-			async ids =>
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
 				this.relationFetcher.fetchOneHasManyGroups({
 					mapper: this.mapper,
 					objectNode: field,
-					targetEntity: targetEntity,
-					relation: relation,
-					targetRelation: targetRelation,
+					relationContext,
+					relationPath: this.relationPath,
 					ids: ids,
 				}),
-			[],
-		)
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	public visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	): void {
-		this.executionContext.addData(
-			entity.primary,
-			async ids => {
+	public visitOneHasOneInverse(relationContext: Model.OneHasOneInverseContext): void {
+		const { entity, targetRelation, targetEntity } = relationContext
+		this.executionContext.addData({
+			field: entity.primary,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetRelation.name]: {
 						[entity.primary]: {
@@ -155,21 +110,21 @@ 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,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	): void {
-		this.executionContext.addData(
-			relation.name,
-			async ids => {
+	public visitOneHasOneOwning(relationContext: Model.OneHasOneOwningContext): void {
+		const { relation, targetEntity } = relationContext
+		this.executionContext.addData({
+			field: relation.name,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetEntity.primary]: {
 						in: ids,
@@ -184,16 +139,21 @@ 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,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity, targetRelation: Model.OneHasManyRelation | null): void {
-		this.executionContext.addData(
-			relation.name,
-			async ids => {
+	public visitManyHasOne(relationContext: Model.ManyHasOneContext): void {
+		const { relation, targetEntity } = relationContext
+		this.executionContext.addData({
+			field: relation.name,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetEntity.primary]: {
 						in: ids,
@@ -208,9 +168,18 @@ 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,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
+	}
+
+	private getRequiredPredicate(entity: Model.Entity, field: Model.AnyField): Acl.Predicate | undefined {
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, Acl.Operation.read, field.name)
+		return fieldPredicate.isSameAsPrimary ? undefined : fieldPredicate.predicate
 	}
 }

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

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

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

@@ -32,25 +32,14 @@ export class MetaHandler implements SelectExecutionHandler<{}> {
 		metaPath: Path,
 		operation: Acl.Operation.read | Acl.Operation.update,
 	): void {
-		const { entity, path } = context
+		const { entity } = context
 		if (entity.primary === fieldName) {
 			return
 		}
-		const fieldPredicate = this.predicateFactory.create(entity, operation, [fieldName])
-		context.addColumn(qb => {
-			return this.whereBuilder.buildAdvanced(entity, path.back(), fieldPredicate, cb =>
-				qb.select(
-					expr =>
-						expr.selectCondition(condition => {
-							condition = cb(condition)
-							if (condition.isEmpty()) {
-								return condition.raw('true')
-							}
-							return condition
-						}),
-					metaPath.alias,
-				),
-			)
-		}, metaPath)
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, operation, fieldName)
+		context.addColumn({
+			path: metaPath,
+			valueGetter: context.addPredicate(fieldPredicate.predicate),
+		})
 	}
 }

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

@@ -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,4 +1,4 @@
-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) {
@@ -6,7 +6,7 @@ export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly
 			return true
 		} else if (operand === false) {
 			hasNever = true
-		} else  {
+		} else if (operand !== undefined)  {
 			normalized.push(...Array.isArray(operand.or) ? operand.or : [operand])
 		}
 	}

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