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

package/src/mapper/EventManager.ts

@@ -1,7 +1,6 @@
 import { Input, Model, Value } from '@contember/schema'
-import { ResolvedColumnValue } from './ColumnValue'
 import { Mapper } from './Mapper'
-import { logger } from '@contember/logger'
+import { ColumnValue } from './ColumnValue'
 
 export class BeforeInsertEvent {
 	public type = 'BeforeInsertEvent' as const
@@ -10,7 +9,7 @@ export class BeforeInsertEvent {
 
 	constructor(
 		public readonly entity: Model.Entity,
-		public readonly data: ResolvedColumnValue[],
+		public readonly data: ColumnValue[],
 	) {
 	}
 }
@@ -20,7 +19,7 @@ export class AfterInsertEvent {
 
 	constructor(
 		public readonly entity: Model.Entity,
-		public readonly data: ResolvedColumnValue[],
+		public readonly data: ColumnValue[],
 		public readonly id: Input.PrimaryValue,
 	) {
 	}
@@ -34,7 +33,7 @@ export class BeforeUpdateEvent {
 
 	constructor(
 		public readonly entity: Model.Entity,
-		public readonly data: ResolvedColumnValue[],
+		public readonly data: ColumnValue[],
 		public readonly id: Input.PrimaryValue,
 	) {
 	}
@@ -47,13 +46,13 @@ export class AfterUpdateEvent {
 
 	constructor(
 		public readonly entity: Model.Entity,
-		public readonly data: (ResolvedColumnValue & { old: Value.FieldValue })[],
+		public readonly data: (ColumnValue & { old: Value.FieldValue })[],
 		public readonly id: Input.PrimaryValue,
 	) {
 	}
 	get hasChanges() {
 		// todo: deep equals
-		return this._hasChanges = this.data.some(it => it.resolvedValue !== it.old)
+		return this._hasChanges = this.data.some(it => it.value !== it.old)
 	}
 }
 
@@ -148,11 +147,8 @@ export class EventManager {
 	}
 
 	public async fire<K extends keyof EventMap>(event: EventMap[K]) {
-		(await Promise.allSettled(this.listeners[event.type].map(it => (it as EventListener<K>)(event, this.mapper))))
-			.map(it => {
-				if (it.status === 'rejected') {
-					logger.error(it.reason)
-				}
-			})
+		for (const listener of this.listeners[event.type]) {
+			await listener(event, this.mapper)
+		}
 	}
 }

package/src/mapper/Mapper.ts

@@ -23,9 +23,9 @@ import { Mutex } from '../utils'
 import { CheckedPrimary } from './CheckedPrimary'
 import { ImplementationException } from '../exception'
 import { EventManager } from './EventManager'
+import { MapperInput } from './types'
 
 export class Mapper<ConnectionType extends Connection.ConnectionLike = Connection.ConnectionLike> {
-	private primaryKeyCache: Record<string, Promise<string> | string> = {}
 	private systemVariablesSetupDone: Promise<void> | undefined
 	public readonly deletedEntities = new DeletedEntitiesStorage()
 	public readonly mutex = new Mutex()
@@ -175,7 +175,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 
 	public async insert(
 		entity: Model.Entity,
-		data: Input.CreateDataInput,
+		data: MapperInput.CreateDataInput,
 		builderCb: (builder: InsertBuilder) => void = () => {},
 	): Promise<MutationResultList> {
 		if (entity.view) {
@@ -189,8 +189,8 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 
 	public async update(
 		entity: Model.Entity,
-		by: Input.UniqueWhere,
-		data: Input.UpdateDataInput,
+		by: Input.UniqueWhere | CheckedPrimary,
+		data: MapperInput.UpdateDataInput,
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		if (entity.view) {
@@ -198,10 +198,9 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		}
 		await this.setupSystemVariables()
 		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-			const primaryValue = await this.getPrimaryValue(entity, by)
-			if (primaryValue === undefined) {
-				return [new MutationEntryNotFoundError([], by)]
-			}
+			const [primaryValue, err] = await this.getPrimaryValue(entity, by)
+			if (err) return [err]
+
 			return await this.updater.update(this, entity, primaryValue, data, filter)
 		})
 	}
@@ -216,18 +215,17 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		}
 		await this.setupSystemVariables()
 		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-			const primaryValue = await this.getPrimaryValue(entity, by)
-			if (primaryValue === undefined) {
-				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
-			}
+			const [primaryValue, err] = await this.getPrimaryValue(entity, by)
+			if (err) return [err]
+
 			return await this.updater.updateCb(this, entity, primaryValue, builderCb)
 		})
 	}
 	public async upsert(
 		entity: Model.Entity,
-		by: Input.UniqueWhere,
-		update: Input.UpdateDataInput,
-		create: Input.CreateDataInput,
+		by: Input.UniqueWhere | CheckedPrimary,
+		update: MapperInput.UpdateDataInput,
+		create: MapperInput.CreateDataInput,
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		if (entity.view) {
@@ -235,7 +233,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		}
 		await this.setupSystemVariables()
 		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-			const primaryValue = await this.getPrimaryValue(entity, by)
+			const [primaryValue] = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return await this.insertInternal(entity, create)
 			}
@@ -243,10 +241,8 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		})
 	}
 
-	private insertInternal(entity: Model.Entity, data: Input.CreateDataInput, builderCb: (builder: InsertBuilder) => void = () => {}) {
+	private insertInternal(entity: Model.Entity, data: MapperInput.CreateDataInput, builderCb: (builder: InsertBuilder) => void = () => {}) {
 		return this.inserter.insert(this, entity, data, id => {
-			const where = { [entity.primary]: id }
-			this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
 		}, builderCb)
 	}
 
@@ -317,26 +313,12 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 	public async getPrimaryValue(
 		entity: Model.Entity,
 		where: Input.UniqueWhere | CheckedPrimary,
-	): Promise<Input.PrimaryValue | undefined> {
+	): Promise<[Input.PrimaryValue, undefined] | [undefined, MutationEntryNotFoundError]> {
 		if (where instanceof CheckedPrimary) {
-			return where.primaryValue
-		}
-		const hash = this.hashWhere(entity.name, where)
-		if (this.primaryKeyCache[hash]) {
-			return this.primaryKeyCache[hash]
+			return [where.primaryValue, undefined]
 		}
-		const primaryPromise = this.selectField(entity, where, entity.primary)
-		this.primaryKeyCache[hash] = primaryPromise
-		const primaryValue = await primaryPromise
-		const uniqueFields = Object.keys(where)
-		if (primaryValue && (uniqueFields.length !== 1 || uniqueFields[0] !== entity.primary)) {
-			this.primaryKeyCache[this.hashWhere(entity.name, { [entity.primary]: primaryValue })] = primaryValue
-		}
-		return primaryValue
-	}
-
-	private hashWhere(entityName: string, where: Input.UniqueWhere): string {
-		return JSON.stringify([entityName, where])
+		const result = await this.selectField(entity, where, entity.primary)
+		return result ? [result, undefined] : [undefined, new MutationEntryNotFoundError([], where)]
 	}
 
 	private async setupSystemVariables() {

package/src/mapper/MutationProcessorHelper.ts

@@ -1,22 +1,30 @@
 import { MutationResultList, prependPath } from './Result'
 import { Model } from '@contember/schema'
 
-export const hasManyProcessor = <Context extends { relation: Model.AnyRelation; index: number; alias?: string }>(
-	innerProcessor: (context: Context) => Promise<MutationResultList>,
+export const hasManyProcessor = <Context extends { relation: Model.AnyRelation; index: number; alias?: string }, Args>(
+	innerProcessor: (context: Context) => Promise<MutationResultList | ((args: Args) => Promise<MutationResultList>)>,
 ) => {
-	return async (context: Context): Promise<MutationResultList> => {
+	return async (context: Context): Promise<MutationResultList | ((args: Args) => Promise<MutationResultList>)> => {
 		const { relation, index, alias } = context
 		const path = [{ field: relation.name }, { index, alias }]
-		return prependPath(path, await innerProcessor(context))
+		const innerResult = await innerProcessor(context)
+		if (typeof innerResult === 'function') {
+			return async (it: Args) => prependPath(path, await innerResult(it))
+		}
+		return prependPath(path, innerResult)
 	}
 }
 
-export const hasOneProcessor = <Context extends { relation: Model.AnyRelation }>(
-	innerProcessor: (context: Context) => Promise<MutationResultList>,
+export const hasOneProcessor = <Context extends { relation: Model.AnyRelation }, Args>(
+	innerProcessor: (context: Context) => Promise<MutationResultList | ((args: Args) => Promise<MutationResultList>)>,
 ) => {
-	return async (context: Context): Promise<MutationResultList> => {
+	return async (context: Context): Promise<MutationResultList | ((args: Args) => Promise<MutationResultList>)> => {
 		const { relation } = context
 		const path = [{ field: relation.name }]
-		return prependPath(path, await innerProcessor(context))
+		const innerResult = await innerProcessor(context)
+		if (typeof innerResult === 'function') {
+			return async (it: Args) => prependPath(path, await innerResult(it))
+		}
+		return prependPath(path, innerResult)
 	}
 }

package/src/mapper/Result.ts

@@ -1,8 +1,5 @@
 import { Input, Model, Value } from '@contember/schema'
-import { convertError } from './ErrorUtils'
-import { getFulfilledValues, getRejections } from '../utils'
-import { DatabaseMetadata, SerializationFailureError } from '@contember/database'
-import { logger } from '@contember/logger'
+import { MapperInput } from './types'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -44,6 +41,7 @@ export type MutationResultList = MutationResult[]
 type Path = ({ field: string } | { index: number; alias?: string })[]
 
 interface MutationResultInterface {
+	error: boolean
 	result: MutationResultType
 	paths: Path[]
 	message?: string
@@ -53,6 +51,7 @@ interface MutationResultInterface {
 export type RowValues = { [fieldName: string]: Value.FieldValue }
 
 export class MutationUpdateOk implements MutationResultInterface {
+	error = false
 	result = MutationResultType.ok as const
 	type = ModificationType.update as const
 	hints: MutationResultHint[] = []
@@ -61,13 +60,14 @@ export class MutationUpdateOk implements MutationResultInterface {
 		public readonly paths: Path[],
 		public readonly entity: Model.Entity,
 		public readonly primary: Value.PrimaryValue,
-		public readonly input: Input.UpdateDataInput,
+		public readonly input: MapperInput.UpdateDataInput,
 		public readonly values: RowValues,
 		public readonly oldValues?: RowValues,
 	) {}
 }
 
 export class MutationCreateOk implements MutationResultInterface {
+	error = false
 	result = MutationResultType.ok as const
 	type = ModificationType.create as const
 	hints: MutationResultHint[] = []
@@ -76,12 +76,13 @@ export class MutationCreateOk implements MutationResultInterface {
 		public readonly paths: Path[],
 		public readonly entity: Model.Entity,
 		public readonly primary: Value.PrimaryValue,
-		public readonly input: Input.CreateDataInput,
+		public readonly input: MapperInput.CreateDataInput,
 		public readonly values: RowValues,
 	) {}
 }
 
 export class MutationDeleteOk implements MutationResultInterface {
+	error = false
 	result = MutationResultType.ok as const
 	type = ModificationType.delete as const
 	hints: MutationResultHint[] = []
@@ -94,6 +95,7 @@ export class MutationDeleteOk implements MutationResultInterface {
 }
 
 export class MutationJunctionUpdateOk implements MutationResultInterface {
+	error = false
 	result = MutationResultType.ok as const
 	type = ModificationType.junctionUpdate as const
 	hints: MutationResultHint[] = []
@@ -116,6 +118,7 @@ export enum NothingToDoReason {
 }
 
 export class MutationNothingToDo implements MutationResultInterface {
+	error = false
 	result = MutationResultType.nothingToDo as const
 	hints: MutationResultHint[] = []
 
@@ -128,6 +131,7 @@ export enum InputErrorKind {
 }
 
 export class MutationInputError implements MutationResultInterface {
+	error = true
 	result = MutationResultType.inputError as const
 
 	constructor(
@@ -139,6 +143,7 @@ export class MutationInputError implements MutationResultInterface {
 }
 
 export class MutationSqlError implements MutationResultInterface {
+	error = true
 	result = MutationResultType.sqlError as const
 
 	constructor(
@@ -155,6 +160,7 @@ export enum ConstraintType {
 }
 
 export class MutationConstraintViolationError implements MutationResultInterface {
+	error = true
 	result = MutationResultType.constraintViolationError as const
 
 	constructor(
@@ -167,6 +173,7 @@ export class MutationConstraintViolationError implements MutationResultInterface
 
 // maybe denied by acl
 export class MutationEntryNotFoundError implements MutationResultInterface {
+	error = true
 	result = MutationResultType.notFoundError as const
 	hints: MutationResultHint[] = []
 	message: string
@@ -178,6 +185,7 @@ export class MutationEntryNotFoundError implements MutationResultInterface {
 
 // possibly denied by acl
 export class MutationNoResultError implements MutationResultInterface {
+	error = true
 	result = MutationResultType.noResultError as const
 
 	constructor(
@@ -197,46 +205,3 @@ export const getInsertPrimary = (result: MutationResultList) =>
 	result[0] && result[0].result === MutationResultType.ok && result[0].type === ModificationType.create
 		? result[0].primary
 		: undefined
-
-export const getUpdatePrimary = (result: MutationResultList) =>
-	result[0] && result[0].result === MutationResultType.ok && result[0].type === ModificationType.update
-		? result[0].primary
-		: undefined
-
-export const flattenResult = (result: (MutationResultList | MutationResultList[])[]): MutationResultList =>
-	result
-		.reduce<(MutationResult | MutationResult[])[]>((acc, it) => [...acc, ...it], [])
-		.reduce<MutationResultList>((acc, it) => (Array.isArray(it) ? [...acc, ...it] : [...acc, it]), [])
-
-export type ResultListNotFlatten = MutationResultList | MutationResultList[]
-
-export const collectResults = async (
-	schema: Model.Schema,
-	schemaDatabaseMetadata: DatabaseMetadata,
-	mainPromise: Promise<ResultListNotFlatten | undefined> | undefined,
-	otherPromises: (Promise<ResultListNotFlatten | undefined> | undefined)[],
-): Promise<MutationResultList> => {
-	let index = 0
-	const allPromises: Promise<{ index: number; value: ResultListNotFlatten }>[] = [mainPromise, ...otherPromises]
-		.filter((it): it is Promise<ResultListNotFlatten> => !!it)
-		.map(it =>
-			it //
-				.catch(e => [convertError(schema, schemaDatabaseMetadata, e)])
-				.then(value => ({ value, index: index++ })),
-		)
-	const results = await Promise.allSettled(allPromises)
-	const failures = getRejections(results)
-	if (failures.length > 0) {
-		if (failures.length > 1 && !failures.every(it => it instanceof SerializationFailureError)) {
-			failures.slice(1).map(e => logger.error(e))
-		}
-		throw failures[0]
-	}
-
-	const values = getFulfilledValues(results)
-	const sortedValues = [values[0], ...values.slice(1).sort((a, b) => a.index - b.index)]
-
-	return flattenResult(
-		sortedValues.map(it => it.value).filter((it): it is MutationResultList | MutationResultList[] => !!it),
-	)
-}

package/src/mapper/delete/DeleteExecutor.ts

@@ -50,10 +50,8 @@ export class DeleteExecutor {
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		return mapper.mutex.execute(async () => {
-			const primaryValue = await mapper.getPrimaryValue(entity, by)
-			if (!primaryValue) {
-				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
-			}
+			const [primaryValue, err] = await mapper.getPrimaryValue(entity, by)
+			if (err) return [err]
 
 			if (mapper.deletedEntities.isDeleted(entity.name, primaryValue)) {
 				return [new MutationNothingToDo([], NothingToDoReason.alreadyDeleted)]
@@ -79,8 +77,7 @@ export class DeleteExecutor {
 						columnName: Object.keys(entry.values)[0],
 						fieldName: Object.keys(entry.input)[0],
 						columnType: 'text',
-						resolvedValue: null,
-						value: Promise.resolve(null),
+						value: null,
 					}], entry.primary)
 					entryToEventMap.set(entry, beforeUpdateEvent)
 					await mapper.eventManager.fire(beforeUpdateEvent)
@@ -99,8 +96,7 @@ export class DeleteExecutor {
 						columnName: Object.keys(entry.values)[0],
 						fieldName: Object.keys(entry.input)[0],
 						columnType: 'text',
-						resolvedValue: null,
-						value: Promise.resolve(null),
+						value: null,
 						old: Object.values(entry.oldValues ?? {})[0],
 					}]
 					const afterEvent = new AfterUpdateEvent(entry.entity, data, entry.primary)

package/src/mapper/insert/InsertBuilder.ts

@@ -1,28 +1,20 @@
 import { Acl, Input, Model, Value } from '@contember/schema'
-import { Client, InsertBuilder as DbInsertBuilder, QueryBuilder, Value as DbValue } from '@contember/database'
+import { InsertBuilder as DbInsertBuilder, QueryBuilder, Value as DbValue } from '@contember/database'
 import { PathFactory, WhereBuilder } from '../select'
 import { getColumnName, getColumnType } from '@contember/schema-utils'
-import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
-import { ImplementationException } from '../../exception'
+import { ColumnValue, normalizeDbValue } from '../ColumnValue'
 import { PredicateFactory } from '../../acl'
-import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
-import { AfterInsertEvent, BeforeInsertEvent, EventManager } from '../EventManager'
+import { AfterInsertEvent, BeforeInsertEvent } from '../EventManager'
 import { Mapper } from '../Mapper'
 
 export interface InsertResult {
-	values: ResolvedColumnValue[]
+	values: ColumnValue[]
 	executed: boolean
-	aborted: boolean
 	primaryValue: Value.PrimaryValue | null
 }
 
-export class InsertBuilder implements DataManipulationBuilder {
-	private resolver: (value: Value.PrimaryValue | null) => void = () => {
-		throw new ImplementationException('InsertBuilder: Resolver called too soon')
-	}
-	public readonly insert: Promise<Value.PrimaryValue | null> = new Promise(resolve => (this.resolver = resolve))
-
-	private rowData: Map<string, ColumnValue<AbortDataManipulation | undefined>> = new Map()
+export class InsertBuilder {
+	private rowData: Map<string, ColumnValue> = new Map()
 	private where: { and: Input.OptionalWhere[] } = { and: [] }
 
 	constructor(
@@ -35,13 +27,14 @@ export class InsertBuilder implements DataManipulationBuilder {
 
 	public addFieldValue(
 		fieldName: string,
-		value: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,
-	): Promise<Value.AtomicValue<AbortDataManipulation | undefined>> {
+		value: Value.FieldValue | undefined,
+	): void {
+		if (value === undefined) {
+			return
+		}
 		const columnName = getColumnName(this.schema, this.entity, fieldName)
 		const columnType = getColumnType(this.schema, this.entity, fieldName)
-		const resolvedValue = resolveGenericValue(value)
-		this.rowData.set(columnName, { columnName, value: resolvedValue, columnType, fieldName })
-		return resolvedValue
+		this.rowData.set(columnName, { columnName, value, columnType, fieldName })
 	}
 
 	public addPredicates(fields: string[]): void {
@@ -53,17 +46,9 @@ export class InsertBuilder implements DataManipulationBuilder {
 		this.where.and.push(where)
 	}
 
-	public async getResolvedData(): Promise<ResolvedColumnValue<AbortDataManipulation>[]> {
-		return resolveRowData([...this.rowData.values()])
-	}
-
 	public async execute(mapper: Mapper): Promise<InsertResult> {
 		try {
-			const resolvedData = await this.getResolvedData()
-			if (resolvedData.find(it => it.resolvedValue === AbortDataManipulation)) {
-				this.resolver(null)
-				return { aborted: true, executed: false, primaryValue: null, values: [] }
-			}
+			const resolvedData = [...this.rowData.values()]
 
 			const insertData = resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
 				(result, item) => ({ ...result, [item.columnName]: expr => expr.select(['root_', item.columnName]) }),
@@ -73,7 +58,13 @@ export class InsertBuilder implements DataManipulationBuilder {
 				.with('root_', qb => {
 					return resolvedData.reduce(
 						(qb, value) =>
-							qb.select(expr => expr.selectValue(value.resolvedValue as DbValue, value.columnType), value.columnName),
+							qb.select(
+								expr => expr.selectValue(
+									normalizeDbValue(value.value, value.columnType),
+									value.columnType,
+								),
+								value.columnName,
+							),
 						qb,
 					)
 				})
@@ -85,20 +76,18 @@ export class InsertBuilder implements DataManipulationBuilder {
 				})
 				.returning(this.entity.primaryColumn)
 
-			const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData as ResolvedColumnValue[])
+			const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData)
 			await mapper.eventManager.fire(beforeInsertEvent)
 
 			const returning = (await qb.execute(mapper.db)).map(it => it[this.entity.primaryColumn])
 			const result = returning.length === 1 ? returning[0] : null
 
-			const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData as ResolvedColumnValue[], result)
+			const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData, result)
 			beforeInsertEvent.afterEvent = afterInsertEvent
 			await mapper.eventManager.fire(afterInsertEvent)
 
-			this.resolver(result)
-			return { values: resolvedData as ResolvedColumnValue[], executed: true, primaryValue: result, aborted: false }
+			return { values: resolvedData, executed: true, primaryValue: result }
 		} catch (e) {
-			this.resolver(null)
 			throw e
 		}
 	}

package/src/mapper/insert/Inserter.ts

@@ -1,22 +1,14 @@
-import {
-	collectResults,
-	MutationCreateOk,
-	MutationNoResultError,
-	MutationNothingToDo,
-	MutationResultList,
-	NothingToDoReason,
-	RowValues,
-} from '../Result'
+import { MutationCreateOk, MutationNoResultError, MutationResultList } from '../Result'
 import { CreateInputVisitor } from '../../inputProcessing'
-import { SqlCreateInputProcessor } from './SqlCreateInputProcessor'
+import { SqlCreateInputProcessor, SqlCreateInputProcessorResult } from './SqlCreateInputProcessor'
 import { Mapper } from '../Mapper'
-import { Input, Model, Value } from '@contember/schema'
-import { acceptEveryFieldVisitor, Providers } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+import { acceptFieldVisitor, Providers } from '@contember/schema-utils'
 import { InsertBuilderFactory } from './InsertBuilderFactory'
 import { InsertBuilder } from './InsertBuilder'
-import { tryMutation } from '../ErrorUtils'
 import { rowDataToFieldValues } from '../ColumnValue'
 import { DatabaseMetadata } from '@contember/database'
+import { MapperInput } from '../types'
 
 export class Inserter {
 	constructor(
@@ -29,50 +21,72 @@ export class Inserter {
 	public async insert(
 		mapper: Mapper,
 		entity: Model.Entity,
-		data: Input.CreateDataInput,
+		data: MapperInput.CreateDataInput,
 		insertIdCallback: (id: string) => void,
 		builderCb: (builder: InsertBuilder) => void,
 	): Promise<MutationResultList> {
 		const insertBuilder = this.insertBuilderFactory.create(entity)
-		// eslint-disable-next-line promise/catch-or-return
-		insertBuilder.insert.then(id => id && insertIdCallback(String(id)))
 
 		insertBuilder.addPredicates(Object.keys(data))
-		const visitor = new CreateInputVisitor<MutationResultList>(
+
+		const visitor = new CreateInputVisitor<SqlCreateInputProcessorResult>(
 			new SqlCreateInputProcessor(insertBuilder, mapper, this.providers),
 			this.schema,
 			data,
 		)
-		const promises = acceptEveryFieldVisitor<Promise<MutationResultList | MutationResultList[] | undefined>>(
-			this.schema,
-			entity,
-			visitor,
-		)
-		builderCb(insertBuilder)
 
-		const okResultFactory = (primary: Value.PrimaryValue, values: RowValues) =>
-			new MutationCreateOk([], entity, primary, data, values)
-		const insertPromise = this.executeInsert(insertBuilder, mapper, okResultFactory)
+		const resultList: MutationResultList = []
+		const postInserts: Exclude<SqlCreateInputProcessorResult, MutationResultList>[] = []
 
-		return await collectResults(this.schema, this.schemaDatabaseMetadata, insertPromise, Object.values(promises))
-	}
+		const keys = new Set([
+			entity.primary,
+			...Object.keys(data),
+			...Object.keys(entity.fields),
+		])
 
-	private async executeInsert(
-		insertBuilder: InsertBuilder,
-		mapper: Mapper,
-		okResultFactory: (primary: Value.PrimaryValue, values: RowValues) => MutationCreateOk,
-	): Promise<MutationResultList> {
-		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-			const result = await insertBuilder.execute(mapper)
-			if (result.aborted) {
-				return [new MutationNothingToDo([], NothingToDoReason.aborted)]
+		for (const key of keys.values()) {
+			const resultSet = await acceptFieldVisitor(
+				this.schema,
+				entity,
+				key,
+				visitor,
+			)
+			for (const result of resultSet) {
+				if (typeof result === 'function') {
+					postInserts.push(result)
+				} else {
+					for (const resultItem of await result) {
+						resultList.push(resultItem)
+						if (resultItem.error) {
+							return resultList
+						}
+					}
+				}
 			}
+		}
+
+		builderCb(insertBuilder)
+		const insertResult = await insertBuilder.execute(mapper)
 
-			if (result.primaryValue === null) {
-				return [new MutationNoResultError([])]
+		if (insertResult.primaryValue === null) {
+			return [new MutationNoResultError([]), ...resultList]
+		}
+		insertIdCallback(String(insertResult.primaryValue))
+
+		const okResult = new MutationCreateOk([], entity, insertResult.primaryValue, data, rowDataToFieldValues(insertResult.values))
+		resultList.unshift(okResult)
+
+		for (const postInsert of postInserts) {
+			const postInsertResult = await postInsert({ primary: insertResult.primaryValue })
+			for (const result of postInsertResult) {
+				resultList.push(result)
+				if (result.error) {
+					return resultList
+				}
 			}
-			return [okResultFactory(result.primaryValue, rowDataToFieldValues(result.values))]
-		})
+		}
+
+		return resultList
 	}
 }