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

package/src/mapper/select/WhereBuilder.ts

@@ -4,13 +4,7 @@ import { Input, Model } from '@contember/schema'
 import { Path, PathFactory } from './Path'
 import { JoinBuilder } from './JoinBuilder'
 import { ConditionBuilder } from './ConditionBuilder'
-import {
-	ConditionBuilder as SqlConditionBuilder,
-	Literal,
-	Operator,
-	QueryBuilder,
-	SelectBuilder, wrapIdentifier,
-} from '@contember/database'
+import { ConditionBuilder as SqlConditionBuilder, Literal, Operator, QueryBuilder, SelectBuilder, wrapIdentifier } from '@contember/database'
 import { WhereOptimizationHints, WhereOptimizer } from './optimizer/WhereOptimizer'
 
 export class WhereBuilder {
@@ -40,7 +34,6 @@ export class WhereBuilder {
 		})
 	}
 
-
 	public buildAdvanced<R extends SelectBuilder.Result>(
 		entity: Model.Entity,
 		path: Path,
@@ -61,15 +54,22 @@ export class WhereBuilder {
 	private buildInternal<R extends SelectBuilder.Result>({
 		callback,
 		...args
-	}: { entity: Model.Entity; path: Path; where: Input.OptionalWhere; callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<R>; allowManyJoin: boolean },
-	): SelectBuilder<R> {
+	}: {
+		entity: Model.Entity
+		path: Path
+		where: Input.OptionalWhere
+		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<R>
+		allowManyJoin: boolean
+	}): SelectBuilder<R> {
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildRecursive({
-			conditionBuilder: clause,
-			joinList: joinList,
-			...args,
-		}))
+		const qbWithWhere = callback(clause =>
+			this.buildRecursive({
+				conditionBuilder: clause,
+				joinList: joinList,
+				...args,
+			})
+		)
 		return joinList.reduce<SelectBuilder<R>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join<R>(qb, path, entity, relationName),
 			qbWithWhere,
@@ -83,8 +83,14 @@ export class WhereBuilder {
 		where,
 		joinList,
 		allowManyJoin,
-	}: { conditionBuilder: SqlConditionBuilder; entity: Model.Entity; path: Path; where: Input.OptionalWhere; joinList: WhereJoinDefinition[]; allowManyJoin: boolean },
-	): SqlConditionBuilder {
+	}: {
+		conditionBuilder: SqlConditionBuilder
+		entity: Model.Entity
+		path: Path
+		where: Input.OptionalWhere
+		joinList: WhereJoinDefinition[]
+		allowManyJoin: boolean
+	}): SqlConditionBuilder {
 		const tableName = path.alias
 
 		if (where.and !== undefined && where.and !== null && where.and.length > 0) {
@@ -101,7 +107,7 @@ export class WhereBuilder {
 							allowManyJoin,
 						}),
 					clause,
-				),
+				)
 			)
 		}
 		if (where.or !== undefined && where.or !== null && where.or.length > 0) {
@@ -111,16 +117,18 @@ export class WhereBuilder {
 					(clause2, where) =>
 						!where
 							? clause2
-							: clause2.and(clause3 => this.buildRecursive({
-								conditionBuilder: clause3,
-								entity,
-								path,
-								where,
-								joinList,
-								allowManyJoin,
-							})),
+							: clause2.and(clause3 =>
+								this.buildRecursive({
+									conditionBuilder: clause3,
+									entity,
+									path,
+									where,
+									joinList,
+									allowManyJoin,
+								})
+							),
 					clause,
-				),
+				)
 			)
 		}
 		if (where.not !== undefined && where.not !== null) {
@@ -133,7 +141,7 @@ export class WhereBuilder {
 					where: expr,
 					joinList,
 					allowManyJoin,
-				}),
+				})
 			)
 		}
 
@@ -160,7 +168,7 @@ export class WhereBuilder {
 							conditionBuilder,
 							tableName,
 							relation.joiningColumn.columnName,
-							(targetEntity.fields[targetEntity.primary] as Model.AnyColumn),
+							targetEntity.fields[targetEntity.primary] as Model.AnyColumn,
 							primaryCondition,
 						)
 					}
@@ -178,8 +186,6 @@ export class WhereBuilder {
 				})
 			}
 
-
-
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
 				visitColumn: ({ entity, column }) => {
 					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column, fieldWhere as Input.Condition<Input.ColumnValue>)
@@ -232,8 +238,10 @@ export class WhereBuilder {
 						? SelectBuilder.create()
 							.select(it => it.raw('1'))
 							.from(new Literal(`(select ${wrapIdentifier(tableName)}.${wrapIdentifier(entity.primaryColumn)})`), targetPath.for('tmp_').alias)
-							.leftJoin(context.targetEntity.tableName, targetPath.alias, it =>
-								it.columnsEq([targetPath.for('tmp_').alias, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]),
+							.leftJoin(
+								context.targetEntity.tableName,
+								targetPath.alias,
+								it => it.columnsEq([targetPath.for('tmp_').alias, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]),
 							)
 						: SelectBuilder.create()
 							.select(it => it.raw('1'))
@@ -255,7 +263,6 @@ export class WhereBuilder {
 		return conditionBuilder
 	}
 
-
 	private createManyHasManySubquery(
 		outerColumn: QueryBuilder.ColumnIdentifier,
 		relationWhere: Input.OptionalWhere,
@@ -274,16 +281,15 @@ export class WhereBuilder {
 
 		const primaryCondition = this.transformWhereToPrimaryCondition(relationWhere, targetEntity.primary)
 		if (primaryCondition !== null) {
+			const columnType = targetEntity.fields[targetEntity.primary] as Model.AnyColumn
 
-			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn)
-
-			return qb.where(condition =>
-				this.conditionBuilder.build(condition, junctionPath.alias, toColumn, columnType, primaryCondition),
-			)
+			return qb.where(condition => this.conditionBuilder.build(condition, junctionPath.alias, toColumn, columnType, primaryCondition))
 		}
 
-		const qbJoined = qb.join(targetEntity.tableName, path.alias, clause =>
-			clause.compareColumns([junctionPath.alias, toColumn], Operator.eq, [path.alias, targetEntity.primary]),
+		const qbJoined = qb.join(
+			targetEntity.tableName,
+			path.alias,
+			clause => clause.compareColumns([junctionPath.alias, toColumn], Operator.eq, [path.alias, targetEntity.primary]),
 		)
 		return this.buildInternal({
 			entity: targetEntity,
@@ -359,10 +365,10 @@ export class WhereBuilder {
 		if (cond.isNull !== undefined) {
 			return true
 		}
-		if (cond.and && cond.and.some(it => this.conditionHasIsNull(it))) {
+		if (cond.and?.some(it => this.conditionHasIsNull(it))) {
 			return true
 		}
-		if (cond.or && cond.or.some(it => this.conditionHasIsNull(it))) {
+		if (cond.or?.some(it => this.conditionHasIsNull(it))) {
 			return true
 		}
 		if (cond.not && this.conditionHasIsNull(cond.not)) {

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

@@ -38,7 +38,7 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 			selectFrom += '::text[]'
 		}
 
-		let columnValueGetter: ColumnValueGetter | undefined = undefined
+		let columnValueGetter: ColumnValueGetter | undefined
 		if (entity.view && column.name === entity.primary && column.type === Model.ColumnType.Uuid) {
 			if (entity.view.idSource) {
 				const aliases: string[] = []
@@ -58,7 +58,6 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				columnValueGetter = row => {
 					return row[columnAlias] ?? (this.providers.uuid({ version: this.settings.uuidVersion }))
 				}
-
 			}
 		}
 
@@ -221,7 +220,8 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 	}
 
 	private getRequiredPredicate(entity: Model.Entity, field: Model.AnyField): Acl.Predicate | undefined {
-		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, Acl.Operation.read, field.name)
+		const isRoot = this.relationPath.length === 0
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, Acl.Operation.read, field.name, isRoot)
 		return fieldPredicate.isSameAsPrimary ? undefined : fieldPredicate.predicate
 	}
 }

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

@@ -13,25 +13,18 @@ export class ConditionOptimizer {
 			(Object.entries(condition) as ObjectEntry<typeof condition>[]).map(([key, value]) => {
 				if (value === undefined || value === null) {
 					return undefined
-
 				} else if (key === 'always') {
 					return true
-
 				} else if (key === 'and') {
 					return optimizeAnd(value.map(it => this.optimize(it)))
-
 				} 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))
-
 				} else {
 					return { [key]: value }
 				}

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

@@ -4,12 +4,11 @@ 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
-	}
+type ExtendedRelationContext = {
+	context: Model.AnyRelationContext
+	canEliminate: boolean
+	isLast: boolean
+}
 
 export interface WhereOptimizationHints {
 	relationPath?: Model.AnyRelationContext[]
@@ -18,16 +17,29 @@ export interface WhereOptimizationHints {
 
 type OptimizedOperand = Input.OptionalWhere | undefined | boolean
 
+export type WhereOptimizerOptions = {
+	disable?: boolean
+	maxCrossOptimizationInput?: number
+}
+
 export class WhereOptimizer {
 	private static eliminableRelations = new Set<Model.AnyRelationContext['type']>(['oneHasMany', 'oneHasOneInverse', 'oneHasOneOwning'])
 
 	constructor(
 		private readonly model: Model.Schema,
 		private readonly conditionOptimizer: ConditionOptimizer,
+		private readonly options?: WhereOptimizerOptions,
 	) {
 	}
 
-	public optimize(where: Input.OptionalWhere, entity: Model.Entity, { relationPath = [], evaluatedPredicates = [] }: WhereOptimizationHints = {}): Input.OptionalWhere {
+	public optimize(
+		where: Input.OptionalWhere,
+		entity: Model.Entity,
+		{ relationPath = [], evaluatedPredicates = [] }: WhereOptimizationHints = {},
+	): Input.OptionalWhere {
+		if (this.options?.disable) {
+			return where
+		}
 		let processedRelationPath: ExtendedRelationContext[] = []
 		for (const i in relationPath) {
 			const el = relationPath[i]
@@ -63,7 +75,7 @@ export class WhereOptimizer {
 
 		for (const key in where) {
 			const value = where[key]
-			let operand: OptimizedOperand = undefined
+			let operand: OptimizedOperand
 			if (value === undefined || value === null) {
 				continue
 			} else if (key === 'and') {
@@ -89,17 +101,14 @@ export class WhereOptimizer {
 				if (operand !== true) {
 					operand = this.optimizeOr(innerOperands, entity, relationPath)
 				}
-
 			} else if (key === 'not') {
 				operand = optimizeNot(this.optimizeWhere(value as Input.OptionalWhere, entity, relationPath))
-
 			} else {
 				operand = this.resolveFieldValue(entity, key, value, relationPath)
 			}
 
 			if (operand === false) {
 				return false
-
 			} else if (operand !== undefined) {
 				operands.push(operand)
 			}
@@ -107,7 +116,11 @@ export class WhereOptimizer {
 		return this.optimizeAnd(operands, entity, relationPath)
 	}
 
-	private optimizeOr(operands: readonly OptimizedOperand[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
+	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
@@ -119,7 +132,11 @@ export class WhereOptimizer {
 		return optimizeOr(result)
 	}
 
-	private optimizeAnd(operands: readonly OptimizedOperand[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
+	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
@@ -131,10 +148,15 @@ export class WhereOptimizer {
 		return optimizeAnd(result)
 	}
 
-	private crossOptimize(operands: Input.OptionalWhere[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.OptionalWhere | boolean)[] {
+	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
+		const count = Math.min(result.length, this.options?.maxCrossOptimizationInput ?? 50)
 		for (let i = 0; i < count; i++) {
 			for (let j = 0; j < count; j++) {
 				const a = result[j]

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

@@ -1,7 +1,12 @@
 import { Input, Writable } from '@contember/schema'
 import deepEqual from 'fast-deep-equal'
 
-export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere, opts: { replaceSubOperands?: boolean } = {}): Input.OptionalWhere => {
+export const replaceWhere = (
+	subject: Input.OptionalWhere,
+	find: Input.OptionalWhere,
+	replace: Input.OptionalWhere,
+	opts: { replaceSubOperands?: boolean } = {},
+): Input.OptionalWhere => {
 	if (deepEqual(subject, find)) {
 		return replace
 	}
@@ -42,13 +47,11 @@ export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalW
 					write(key, items)
 				}
 			}
-
 		}
 	}
 	return result
 }
 
-
 const containsAllOperands = (subjectOperands: Input.OptionalWhere[], findOperands: Input.OptionalWhere[]): boolean => {
 	for (const op1 of findOperands) {
 		let found = false

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

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

package/src/mapper/types.ts

@@ -1,10 +1,9 @@
-import { Model, Input, Value } from '@contember/schema'
+import { Input, Model, Value } from '@contember/schema'
 import { CheckedPrimary } from './CheckedPrimary'
 
 export type JoiningColumns = { sourceColumn: Model.JoiningColumn; targetColumn: Model.JoiningColumn }
 
 export namespace MapperInput {
-
 	export interface ConnectRelationInput {
 		connect: Input.UniqueWhere | CheckedPrimary
 	}
@@ -58,11 +57,13 @@ export namespace MapperInput {
 		[column: string]: Value.FieldValue | CreateOneRelationInput | CreateManyRelationInput
 	}
 
-	export type CreateOneRelationInput = { alias?: string } & (
-		| ConnectRelationInput
-		| CreateRelationInput
-		| ConnectOrCreateRelationInput
-	)
+	export type CreateOneRelationInput =
+		& { alias?: string }
+		& (
+			| ConnectRelationInput
+			| CreateRelationInput
+			| ConnectOrCreateRelationInput
+		)
 
 	export type CreateManyRelationInput = Array<CreateOneRelationInput>
 
@@ -92,7 +93,6 @@ export namespace MapperInput {
 		filter?: Input.OptionalWhere
 	}
 
-
 	export type UpdateOneRelationInput =
 		| CreateRelationInput
 		| ConnectRelationInput
@@ -102,16 +102,17 @@ export namespace MapperInput {
 		| UpdateRelationInput
 		| UpsertRelationInput
 
-	export type UpdateManyRelationInputItem = { alias?: string } & (
-		| CreateRelationInput
-		| ConnectRelationInput
-		| ConnectOrCreateRelationInput
-		| DeleteSpecifiedRelationInput
-		| DisconnectSpecifiedRelationInput
-		| UpdateSpecifiedRelationInput
-		| UpsertSpecifiedRelationInput
-	)
+	export type UpdateManyRelationInputItem =
+		& { alias?: string }
+		& (
+			| CreateRelationInput
+			| ConnectRelationInput
+			| ConnectOrCreateRelationInput
+			| DeleteSpecifiedRelationInput
+			| DisconnectSpecifiedRelationInput
+			| UpdateSpecifiedRelationInput
+			| UpsertSpecifiedRelationInput
+		)
 
 	export type UpdateManyRelationInput = Array<UpdateManyRelationInputItem>
-
 }

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -11,7 +11,7 @@ import { MutationResultList } from '../Result'
 import { ManyHasOneUpdateInputProcessor } from './relations/ManyHasOneUpdateInputProcessor'
 import { MapperInput } from '../types'
 
-export type SqlUpdateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue}) => Promise<MutationResultList>)
+export type SqlUpdateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue }) => Promise<MutationResultList>)
 
 export class SqlUpdateInputProcessor implements UpdateInputProcessor<SqlUpdateInputProcessorResult> {
 	private oneHasOneInverseUpdateInputProcessor: OneHasOneInverseUpdateInputProcessor

package/src/mapper/update/UpdateBuilder.ts

@@ -57,93 +57,89 @@ export class UpdateBuilder {
 	}
 
 	public async execute(mapper: Mapper): Promise<UpdateResult> {
-		try {
-			const resolvedData = [...this.rowData.values()]
-			if (Object.keys(resolvedData).length === 0) {
-				return { values: [], affectedRows: null, executed: false }
-			}
-			const oldColSuffix = '_old__'
-
-			const qb = DbUpdateBuilder.create()
-				.with('newData_', qb => {
-					qb = resolvedData.reduce(
-						(qb, value) =>
-							qb
-								.select(
-									expr => expr.selectValue(
+		const resolvedData = [...this.rowData.values()]
+		if (Object.keys(resolvedData).length === 0) {
+			return { values: [], affectedRows: null, executed: false }
+		}
+		const oldColSuffix = '_old__'
+
+		const qb = DbUpdateBuilder.create()
+			.with('newData_', qb => {
+				qb = resolvedData.reduce(
+					(qb, value) =>
+						qb
+							.select(
+								expr =>
+									expr.selectValue(
 										normalizeDbValue(value.value, value.columnType),
 										value.columnType,
 									),
-									value.columnName,
-								)
-								.select(['root_', value.columnName], value.columnName + oldColSuffix),
-						qb,
-					)
-					const columns = new Set(resolvedData.map(it => it.columnName))
-					const allColumns: string[] = Object.values(
-						acceptEveryFieldVisitor(this.schema, this.entity, {
-							visitColumn: ({ column }) => column.columnName,
-							visitManyHasOne: ({ relation }) => relation.joiningColumn.columnName,
-							visitOneHasOneOwning: ({ relation }) => relation.joiningColumn.columnName,
-							visitManyHasManyInverse: () => null,
-							visitManyHasManyOwning: () => null,
-							visitOneHasOneInverse: () => null,
-							visitOneHasMany: () => null,
-						}),
-					).filter((it): it is string => it !== null)
-
-					const remainingColumns = allColumns.filter(it => !columns.has(it))
-					qb = qb.from(this.entity.tableName, 'root_')
-
-					qb = remainingColumns.reduce((qb, columnName) => qb.select(['root_', columnName]), qb)
-
-					qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), {
-						and: [{
-							[this.entity.primary]: { eq: this.primary },
-						}, this.oldWhere],
-					})
-
-					return qb
-				})
-				.table(this.entity.tableName)
-				.values(
-					resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
-						(result: object, item) => ({
-							...result,
-							[item.columnName]: expr => expr.select(['newData_', item.columnName]),
-						}),
-						{},
-					),
+								value.columnName,
+							)
+							.select(['root_', value.columnName], value.columnName + oldColSuffix),
+					qb,
 				)
-				.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
-				.from(qb => {
-					qb = qb.from('newData_')
-					const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
-					const col2 = tuple('newData_', this.entity.primaryColumn)
-					qb = qb.where(expr => expr.compareColumns(col1, Operator.eq, col2))
-					qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([], 'newData_'), this.newWhere)
-					return qb
+				const columns = new Set(resolvedData.map(it => it.columnName))
+				const allColumns: string[] = Object.values(
+					acceptEveryFieldVisitor(this.schema, this.entity, {
+						visitColumn: ({ column }) => column.columnName,
+						visitManyHasOne: ({ relation }) => relation.joiningColumn.columnName,
+						visitOneHasOneOwning: ({ relation }) => relation.joiningColumn.columnName,
+						visitManyHasManyInverse: () => null,
+						visitManyHasManyOwning: () => null,
+						visitOneHasOneInverse: () => null,
+						visitOneHasMany: () => null,
+					}),
+				).filter((it): it is string => it !== null)
+
+				const remainingColumns = allColumns.filter(it => !columns.has(it))
+				qb = qb.from(this.entity.tableName, 'root_')
+
+				qb = remainingColumns.reduce((qb, columnName) => qb.select(['root_', columnName]), qb)
+
+				qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), {
+					and: [{
+						[this.entity.primary]: { eq: this.primary },
+					}, this.oldWhere],
 				})
 
-
-			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData, this.primary)
-			await mapper.eventManager.fire(beforeEvent)
-
-			const result = await qb.execute(mapper.db)
-
-			if (result.length === 1) {
-				const eventData = (resolvedData).map(it => ({
-					...it,
-					old: result[0][it.columnName + oldColSuffix],
-				}))
-				const afterUpdateEvent = new AfterUpdateEvent(this.entity, eventData, this.primary)
-				beforeEvent.afterEvent = afterUpdateEvent
-				await mapper.eventManager.fire(afterUpdateEvent)
-			}
-
-			return { values: resolvedData, affectedRows: result.length, executed: true }
-		} catch (e) {
-			throw e
+				return qb
+			})
+			.table(this.entity.tableName)
+			.values(
+				resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
+					(result: object, item) => ({
+						...result,
+						[item.columnName]: expr => expr.select(['newData_', item.columnName]),
+					}),
+					{},
+				),
+			)
+			.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
+			.from(qb => {
+				qb = qb.from('newData_')
+				const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
+				const col2 = tuple('newData_', this.entity.primaryColumn)
+				qb = qb.where(expr => expr.compareColumns(col1, Operator.eq, col2))
+				qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([], 'newData_'), this.newWhere)
+				return qb
+			})
+
+		const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData, this.primary)
+		await mapper.eventManager.fire(beforeEvent)
+
+		const result = await qb.execute(mapper.db)
+
+		if (result.length === 1) {
+			const eventData = resolvedData.map(it => ({
+				...it,
+				old: result[0][it.columnName + oldColSuffix],
+			}))
+			const afterUpdateEvent = new AfterUpdateEvent(this.entity, eventData, this.primary)
+			beforeEvent.afterEvent = afterUpdateEvent
+			await mapper.eventManager.fire(afterUpdateEvent)
 		}
+
+		return { values: resolvedData, affectedRows: result.length, executed: true }
 	}
 }