@contember/engine-content-api 2.0.0-alpha.20 → 2.0.0-alpha.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "2.0.0-alpha.20",
+  "version": "2.0.0-alpha.21",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -26,18 +26,18 @@
     "generate": "gql-gen --config graphql.codegen.yml"
   },
   "dependencies": {
-    "@contember/database": "2.0.0-alpha.20",
-    "@contember/dic": "2.0.0-alpha.20",
-    "@contember/graphql-utils": "2.0.0-alpha.20",
-    "@contember/logger": "2.0.0-alpha.20",
-    "@contember/schema": "2.0.0-alpha.20",
-    "@contember/schema-definition": "2.0.0-alpha.20",
-    "@contember/schema-utils": "2.0.0-alpha.20",
+    "@contember/database": "2.0.0-alpha.21",
+    "@contember/dic": "2.0.0-alpha.21",
+    "@contember/graphql-utils": "2.0.0-alpha.21",
+    "@contember/logger": "2.0.0-alpha.21",
+    "@contember/schema": "2.0.0-alpha.21",
+    "@contember/schema-definition": "2.0.0-alpha.21",
+    "@contember/schema-utils": "2.0.0-alpha.21",
     "fast-deep-equal": "^3.1.3"
   },
   "devDependencies": {
-    "@contember/database-tester": "2.0.0-alpha.20",
-    "@contember/schema-definition": "2.0.0-alpha.20",
+    "@contember/database-tester": "2.0.0-alpha.21",
+    "@contember/schema-definition": "2.0.0-alpha.21",
     "@types/node": "^20.16.11",
     "graphql": "^16.9.0",
     "pg": "^8.12.0"

package/src/input-validation/preValidation/InputPreValidator.ts

@@ -158,14 +158,12 @@ export class InputPreValidator {
 
 	private async validateRelations(
 		entity: Model.Entity,
-		visitor: Model.FieldVisitor<Promise<ValidationResult | ValidationResult[] | undefined>>,
-	): Promise<FieldValidationResult[]> {
+		visitor: Model.FieldVisitor<Promise<ValidationResult[]>>,
+	): Promise<ValidationResult> {
 		const validateRelationsResult = acceptEveryFieldVisitor(this.model, entity, visitor)
 
 		return (await Promise.all(Object.values(validateRelationsResult)))
-			.filter((value): value is FieldValidationResult[] | FieldValidationResult[][] => value !== undefined)
-			.reduce<(FieldValidationResult[] | FieldValidationResult)[]>((res, it) => [...res, ...it], [])
-			.reduce<FieldValidationResult[]>((res, it) => [...res, ...(Array.isArray(it) ? it : [it])], [])
+			.flatMap(it => it.flat())
 	}
 
 	private getApplicableRules(changedFields: string[], entityRules: Validation.EntityRules): Validation.EntityRules {

package/src/inputProcessing/CreateInputVisitor.ts

@@ -6,8 +6,8 @@ import { UserError } from '../exception'
 import { ImplementationException } from '../exception'
 
 export class CreateInputVisitor<Result> implements
-	Model.ColumnVisitor<Promise<Result | Result[] | undefined>>,
-	Model.RelationByTypeVisitor<Promise<Result | Result[] | undefined>> {
+	Model.ColumnVisitor<Promise<Result[]>>,
+	Model.RelationByTypeVisitor<Promise<Result[]>> {
 
 	constructor(
 		private readonly createInputProcessor: CreateInputProcessor<Result>,
@@ -15,11 +15,11 @@ export class CreateInputVisitor<Result> implements
 		private readonly data: Input.CreateDataInput,
 	) {}
 
-	public visitColumn(context: Model.ColumnContext): Promise<Result> {
-		return this.createInputProcessor.column({
+	public async visitColumn(context: Model.ColumnContext): Promise<Result[]> {
+		return [await this.createInputProcessor.column({
 			...context,
 			input: this.data[context.column.name] as Input.ColumnValue,
-		})
+		})]
 	}
 
 	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
@@ -70,27 +70,27 @@ export class CreateInputVisitor<Result> implements
 		)
 	}
 
-	private processRelationInput<Context>(
+	private async processRelationInput<Context>(
 		processor: CreateInputProcessor.HasOneRelationProcessor<Context, Result>,
 		context: Context,
 		input: Input.CreateOneRelationInput | undefined,
-	): Promise<undefined | Result> {
+	): Promise<Result[]> {
 		if (input === undefined || input === null) {
 			if (processor.nothing) {
-				return processor.nothing({ ...context, input: undefined })
+				return [await processor.nothing({ ...context, input: undefined })]
 			}
-			return Promise.resolve(undefined)
+			return Promise.resolve([])
 		}
 		input = filterObject(input, (k, v) => v !== null && v !== undefined)
 		this.verifyOperations(input)
 		if (isIt<Input.ConnectRelationInput>(input, 'connect')) {
-			return processor.connect({ ...context, input: input.connect })
+			return [await processor.connect({ ...context, input: input.connect })]
 		}
 		if (isIt<Input.CreateRelationInput>(input, 'create')) {
-			return processor.create({ ...context, input: input.create })
+			return [await processor.create({ ...context, input: input.create })]
 		}
 		if (isIt<Input.ConnectOrCreateRelationInput>(input, 'connectOrCreate')) {
-			return processor.connectOrCreate({ ...context, input: input.connectOrCreate })
+			return [await processor.connectOrCreate({ ...context, input: input.connectOrCreate })]
 		}
 		throw new ImplementationException()
 	}
@@ -99,9 +99,9 @@ export class CreateInputVisitor<Result> implements
 		processor: CreateInputProcessor.HasManyRelationProcessor<Context, Result>,
 		context: Context,
 		input: Input.CreateManyRelationInput | undefined,
-	): Promise<undefined | Result[]> {
+	): Promise<Result[]> {
 		if (input === undefined || input === null) {
-			return Promise.resolve(undefined)
+			return Promise.resolve([])
 		}
 		const results: Result[] = []
 		let i = 0

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -4,8 +4,8 @@ import { UpdateInputProcessor } from './UpdateInputProcessor'
 import { ImplementationException, UserError } from '../exception'
 
 export class UpdateInputVisitor<Result> implements
-	Model.ColumnVisitor<Promise<Result | Result[] | undefined>>,
-	Model.RelationByTypeVisitor<Promise<Result | Result[] | undefined>> {
+	Model.ColumnVisitor<Promise<Result[]>>,
+	Model.RelationByTypeVisitor<Promise<Result[]>> {
 
 	constructor(
 		private readonly updateInputProcessor: UpdateInputProcessor<Result>,
@@ -13,12 +13,12 @@ export class UpdateInputVisitor<Result> implements
 		private readonly data: Input.UpdateDataInput,
 	) {}
 
-	public visitColumn({ entity, column }: Model.ColumnContext): Promise<Result> {
-		return this.updateInputProcessor.column({
+	public async visitColumn({ entity, column }: Model.ColumnContext): Promise<Result[]> {
+		return [await this.updateInputProcessor.column({
 			entity,
 			column,
 			input: this.data[column.name] as Input.ColumnValue,
-		})
+		})]
 	}
 
 	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
@@ -69,36 +69,36 @@ export class UpdateInputVisitor<Result> implements
 		)
 	}
 
-	private processRelationInput<Context>(
+	private async processRelationInput<Context>(
 		processor: UpdateInputProcessor.HasOneRelationInputProcessor<Context, Result>,
 		context: Context,
 		input: Input.UpdateOneRelationInput | undefined,
-	): Promise<undefined | Result> {
+	): Promise< Result[]> {
 		if (input === undefined || input === null) {
-			return Promise.resolve(undefined)
+			return Promise.resolve([])
 		}
 		input = filterObject(input, (k, v) => v !== null && v !== undefined)
 		this.verifyOperations(input)
 		if (isIt<Input.ConnectRelationInput>(input, 'connect')) {
-			return processor.connect({ ...context, input: input.connect })
+			return [await processor.connect({ ...context, input: input.connect })]
 		}
 		if (isIt<Input.CreateRelationInput>(input, 'create')) {
-			return processor.create({ ...context, input: input.create })
+			return [await processor.create({ ...context, input: input.create })]
 		}
 		if (isIt<Input.ConnectOrCreateRelationInput>(input, 'connectOrCreate')) {
-			return processor.connectOrCreate({ ...context, input: input.connectOrCreate })
+			return [await processor.connectOrCreate({ ...context, input: input.connectOrCreate })]
 		}
 		if (isIt<Input.DeleteRelationInput>(input, 'delete')) {
-			return processor.delete({ ...context, input: undefined })
+			return [await processor.delete({ ...context, input: undefined })]
 		}
 		if (isIt<Input.DisconnectRelationInput>(input, 'disconnect')) {
-			return processor.disconnect({ ...context, input: undefined })
+			return [await processor.disconnect({ ...context, input: undefined })]
 		}
 		if (isIt<Input.UpdateRelationInput>(input, 'update')) {
-			return processor.update({ ...context, input: input.update })
+			return [await processor.update({ ...context, input: input.update })]
 		}
 		if (isIt<Input.UpsertRelationInput>(input, 'upsert')) {
-			return processor.upsert({ ...context, input: input.upsert })
+			return [await processor.upsert({ ...context, input: input.upsert })]
 		}
 		throw new ImplementationException()
 	}
@@ -107,9 +107,9 @@ export class UpdateInputVisitor<Result> implements
 		processor: UpdateInputProcessor.HasManyRelationInputProcessor<Context, Result>,
 		context: Context,
 		input: Input.UpdateManyRelationInput | undefined,
-	): Promise<undefined | Result[]> {
+	): Promise<Result[]> {
 		if (input === undefined || input === null) {
-			return Promise.resolve(undefined)
+			return Promise.resolve([])
 		}
 		const results: Array<Result> = []
 		let i = 0

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,4 @@
 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'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -44,6 +40,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 +50,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[] = []
@@ -68,6 +66,7 @@ export class MutationUpdateOk implements MutationResultInterface {
 }
 
 export class MutationCreateOk implements MutationResultInterface {
+	error = false
 	result = MutationResultType.ok as const
 	type = ModificationType.create as const
 	hints: MutationResultHint[] = []
@@ -82,6 +81,7 @@ export class MutationCreateOk implements MutationResultInterface {
 }
 
 export class MutationDeleteOk implements MutationResultInterface {
+	error = false
 	result = MutationResultType.ok as const
 	type = ModificationType.delete as const
 	hints: MutationResultHint[] = []
@@ -94,6 +94,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 +117,7 @@ export enum NothingToDoReason {
 }
 
 export class MutationNothingToDo implements MutationResultInterface {
+	error = false
 	result = MutationResultType.nothingToDo as const
 	hints: MutationResultHint[] = []
 
@@ -128,6 +130,7 @@ export enum InputErrorKind {
 }
 
 export class MutationInputError implements MutationResultInterface {
+	error = true
 	result = MutationResultType.inputError as const
 
 	constructor(
@@ -139,6 +142,7 @@ export class MutationInputError implements MutationResultInterface {
 }
 
 export class MutationSqlError implements MutationResultInterface {
+	error = true
 	result = MutationResultType.sqlError as const
 
 	constructor(
@@ -155,6 +159,7 @@ export enum ConstraintType {
 }
 
 export class MutationConstraintViolationError implements MutationResultInterface {
+	error = true
 	result = MutationResultType.constraintViolationError as const
 
 	constructor(
@@ -167,6 +172,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 +184,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 +204,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/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 { 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[]
 	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<undefined>> = new Map()
 	private where: { and: Input.OptionalWhere[] } = { and: [] }
 
 	constructor(
@@ -35,8 +27,8 @@ export class InsertBuilder implements DataManipulationBuilder {
 
 	public addFieldValue(
 		fieldName: string,
-		value: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,
-	): Promise<Value.AtomicValue<AbortDataManipulation | undefined>> {
+		value: Value.GenericValueLike<Value.AtomicValue<undefined>>,
+	): Promise<Value.AtomicValue<undefined>> {
 		const columnName = getColumnName(this.schema, this.entity, fieldName)
 		const columnType = getColumnType(this.schema, this.entity, fieldName)
 		const resolvedValue = resolveGenericValue(value)
@@ -53,17 +45,13 @@ export class InsertBuilder implements DataManipulationBuilder {
 		this.where.and.push(where)
 	}
 
-	public async getResolvedData(): Promise<ResolvedColumnValue<AbortDataManipulation>[]> {
+	public async getResolvedData(): Promise<ResolvedColumnValue[]> {
 		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 insertData = resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
 				(result, item) => ({ ...result, [item.columnName]: expr => expr.select(['root_', item.columnName]) }),
@@ -95,10 +83,8 @@ export class InsertBuilder implements DataManipulationBuilder {
 			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 as ResolvedColumnValue[], executed: true, primaryValue: result }
 		} catch (e) {
-			this.resolver(null)
 			throw e
 		}
 	}

package/src/mapper/insert/Inserter.ts

@@ -1,20 +1,11 @@
-import {
-	collectResults,
-	MutationCreateOk,
-	MutationNoResultError,
-	MutationNothingToDo,
-	MutationResultList,
-	NothingToDoReason,
-	RowValues,
-} from '../Result'
+import { MutationCreateOk, MutationNoResultError, MutationNothingToDo, MutationResultList, NothingToDoReason } 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 { Input, 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'
 
@@ -34,45 +25,67 @@ export class Inserter {
 		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
 	}
 }