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

package/src/index.ts

@@ -9,7 +9,6 @@ export * from './ExecutionContainer'
 export { graphql } from 'graphql'
 export { UserError } from './exception'
 export {
-	type DataModificationEvent,
 	AfterCommitEvent,
 	AfterInsertEvent,
 	AfterJunctionUpdateEvent,
@@ -19,16 +18,18 @@ export {
 	BeforeInsertEvent,
 	BeforeJunctionUpdateEvent,
 	BeforeUpdateEvent,
+	type DataModificationEvent,
 	EventManager,
-	Mapper,
-	MapperFactory,
 	type ExecutionContainer,
+	type ExecutionContainerArgs,
 	type ExecutionContainerBuilder,
-	Path,
-	WhereBuilder,
-	PathFactory,
 	ExecutionContainerFactory,
 	type ExecutionContainerHook,
-	type ExecutionContainerArgs,
+	type JoinBuilder,
+	Mapper,
+	MapperFactory,
+	Path,
+	PathFactory,
+	type WhereBuilder,
 } from './mapper'
 export * from './utils/uniqueWhereFields'

package/src/input-validation/ValidationEvaluation.ts

@@ -83,8 +83,7 @@ const validatorEvaluators: {
 		return acceptContextVisitor(context, {
 			visitNodeContext: fixedResult(false),
 			visitNodeListContext: (context: ValidationContext.NodeListContext) => context.nodes.length === 0,
-			visitValueContext: (context: ValidationContext.ValueContext) =>
-				context.value === undefined || context.value === null || context.value === '',
+			visitValueContext: (context: ValidationContext.ValueContext) => context.value === undefined || context.value === null || context.value === '',
 			visitUndefinedContext: fixedResult(true),
 		})
 	},
@@ -92,8 +91,7 @@ const validatorEvaluators: {
 		return acceptContextVisitor(context, {
 			visitNodeContext: fixedResult(true),
 			visitNodeListContext: fixedResult(true),
-			visitValueContext: (context: ValidationContext.ValueContext) =>
-				context.value !== undefined && context.value !== null,
+			visitValueContext: (context: ValidationContext.ValueContext) => context.value !== undefined && context.value !== null,
 			visitUndefinedContext: fixedResult(false),
 		})
 	},
@@ -135,8 +133,7 @@ const validatorEvaluators: {
 		min: Validation.LiteralArgument<number | null>,
 		max: Validation.LiteralArgument<number | null>,
 	) => {
-		const doesMatchRange = (value: number) =>
-			(min.value === null || min.value <= value) && (max.value === null || max.value >= value)
+		const doesMatchRange = (value: number) => (min.value === null || min.value <= value) && (max.value === null || max.value >= value)
 		return acceptContextVisitor(context, {
 			visitNodeContext: cannotApplyOnNode('length range', 'node'),
 			visitNodeListContext: (context: ValidationContext.NodeListContext) => {

package/src/input-validation/dependencies/DependencyCollector.ts

@@ -32,9 +32,9 @@ export class DependencyCollector {
 		const result: DependenciesList = []
 		for (const arg of validator.args) {
 			switch (arg.type) {
-				//case Validation.ArgumentType.path:
-				//	result.push([...prefix, ...arg.path])
-				//	break
+				// case Validation.ArgumentType.path:
+				// 	result.push([...prefix, ...arg.path])
+				// 	break
 				case Validation.ArgumentType.validator:
 					result.push(...DependencyCollector.doCollect(arg.validator, prefix))
 					break

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

@@ -48,7 +48,7 @@ export class InputPreValidator {
 			? {
 				...data,
 				[overRelation.name]: { create: {} },
-			  }
+			}
 			: data
 		const context = this.createContextForCreate(entity, dataWithRelation)
 
@@ -114,8 +114,8 @@ export class InputPreValidator {
 				}
 				if ('delete' in value) {
 					if (
-						isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn') &&
-						relation.joiningColumn.onDelete === Model.OnDelete.cascade
+						isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn')
+						&& relation.joiningColumn.onDelete === Model.OnDelete.cascade
 					) {
 						return true
 					}
@@ -150,7 +150,7 @@ export class InputPreValidator {
 				tuple(
 					field,
 					fieldRules.find(it => evaluateValidation(context, InputValidation.rules.on(field, it.validator)) === false),
-				),
+				)
 			)
 			.filter((arg): arg is [string, Validation.ValidationRule] => !!arg[1])
 			.map(([field, { message }]) => ({ path: [...path, { field }], message }))
@@ -174,9 +174,7 @@ export class InputPreValidator {
 						field,
 						changedFields.includes(field)
 							? fieldRules
-							: fieldRules.filter(rule =>
-								Object.keys(DependencyCollector.collect(rule.validator)).find(it => changedFields.includes(it)),
-							  ),
+							: fieldRules.filter(rule => Object.keys(DependencyCollector.collect(rule.validator)).find(it => changedFields.includes(it))),
 					)
 				})
 				.filter(([, it]) => it.length > 0),
@@ -187,7 +185,7 @@ export class InputPreValidator {
 		const baseFieldsAsDeps = Object.keys(rules).reduce((acc, field) => ({ ...acc, [field]: {} }), {})
 
 		return Object.values(rules)
-			.flatMap(it => it)
+			.flat()
 			.map(it => DependencyCollector.collect(it.validator))
 			.concat(baseFieldsAsDeps)
 			.reduce((acc, dependecy) => DependencyMerger.merge(acc, dependecy), {})

package/src/inputProcessing/CreateInputProcessor.ts

@@ -16,7 +16,6 @@ interface CreateInputProcessor<Result = void> {
 }
 
 namespace CreateInputProcessor {
-
 	export interface HasOneRelationProcessor<Context, Result> {
 		nothing?: (context: Context & { input: undefined }) => Promise<Result>
 		connect: (context: Context & { input: Input.UniqueWhere | CheckedPrimary }) => Promise<Result>
@@ -31,4 +30,4 @@ namespace CreateInputProcessor {
 	}
 }
 
-export { type CreateInputProcessor }
+export type { CreateInputProcessor }

package/src/inputProcessing/CreateInputVisitor.ts

@@ -4,10 +4,7 @@ import { CreateInputProcessor } from './CreateInputProcessor'
 import { ImplementationException, UserError } from '../exception'
 import { MapperInput } from '../mapper'
 
-export class CreateInputVisitor<Result> implements
-	Model.ColumnVisitor<Promise<Result[]>>,
-	Model.RelationByTypeVisitor<Promise<Result[]>> {
-
+export class CreateInputVisitor<Result> implements Model.ColumnVisitor<Promise<Result[]>>, Model.RelationByTypeVisitor<Promise<Result[]>> {
 	constructor(
 		private readonly createInputProcessor: CreateInputProcessor<Result>,
 		private readonly schema: Model.Schema,
@@ -15,10 +12,12 @@ export class CreateInputVisitor<Result> implements
 	) {}
 
 	public async visitColumn(context: Model.ColumnContext): Promise<Result[]> {
-		return [await this.createInputProcessor.column({
-			...context,
-			input: this.data[context.column.name] as Input.ColumnValue,
-		})]
+		return [
+			await this.createInputProcessor.column({
+				...context,
+				input: this.data[context.column.name] as Input.ColumnValue,
+			}),
+		]
 	}
 
 	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {

package/src/inputProcessing/UpdateInputProcessor.ts

@@ -2,7 +2,6 @@ import { Input, Model } from '@contember/schema'
 import { CheckedPrimary } from '../mapper/CheckedPrimary'
 import { MapperInput } from '../mapper'
 
-
 interface UpdateInputProcessor<Result = void> {
 	column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<Result>
 
@@ -61,4 +60,4 @@ namespace UpdateInputProcessor {
 	}
 }
 
-export { type UpdateInputProcessor }
+export type { UpdateInputProcessor }

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -4,10 +4,7 @@ import { UpdateInputProcessor } from './UpdateInputProcessor'
 import { ImplementationException, UserError } from '../exception'
 import { MapperInput } from '../mapper'
 
-export class UpdateInputVisitor<Result> implements
-	Model.ColumnVisitor<Promise<Result[]>>,
-	Model.RelationByTypeVisitor<Promise<Result[]>> {
-
+export class UpdateInputVisitor<Result> implements Model.ColumnVisitor<Promise<Result[]>>, Model.RelationByTypeVisitor<Promise<Result[]>> {
 	constructor(
 		private readonly updateInputProcessor: UpdateInputProcessor<Result>,
 		private readonly schema: Model.Schema,
@@ -15,11 +12,13 @@ export class UpdateInputVisitor<Result> implements
 	) {}
 
 	public async visitColumn({ entity, column }: Model.ColumnContext): Promise<Result[]> {
-		return [await this.updateInputProcessor.column({
-			entity,
-			column,
-			input: this.data[column.name] as Input.ColumnValue,
-		})]
+		return [
+			await this.updateInputProcessor.column({
+				entity,
+				column,
+				input: this.data[column.name] as Input.ColumnValue,
+			}),
+		]
 	}
 
 	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
@@ -74,7 +73,7 @@ export class UpdateInputVisitor<Result> implements
 		processor: UpdateInputProcessor.HasOneRelationInputProcessor<Context, Result>,
 		context: Context,
 		input: MapperInput.UpdateOneRelationInput | undefined,
-	): Promise< Result[]> {
+	): Promise<Result[]> {
 		if (input === undefined || input === null) {
 			return Promise.resolve([])
 		}

package/src/introspection/IntrospectionSchemaFactory.ts

@@ -33,10 +33,9 @@ export class IntrospectionSchemaFactory {
 		const convertOrderBy = ({ path, direction }: Model.OrderBy): ContentSchema._OrderBy => {
 			return {
 				path,
-				direction:
-					direction === Model.OrderDirection.desc
-						? ContentSchema._OrderByDirection.Desc
-						: ContentSchema._OrderByDirection.Asc,
+				direction: direction === Model.OrderDirection.desc
+					? ContentSchema._OrderByDirection.Desc
+					: ContentSchema._OrderByDirection.Asc,
 			}
 		}
 		const additionalInfo = acceptEveryFieldVisitor<AdditionalFieldInfo>(this.model, entityName, {

package/src/introspection/content-schema.types.ts

@@ -61,7 +61,7 @@ export type _LiteralArgument = {
 export enum _OnDeleteBehaviour {
 	Cascade = 'cascade',
 	Restrict = 'restrict',
-	SetNull = 'setNull'
+	SetNull = 'setNull',
 }
 
 export type _OrderBy = {
@@ -72,7 +72,7 @@ export type _OrderBy = {
 
 export enum _OrderByDirection {
 	Asc = 'asc',
-	Desc = 'desc'
+	Desc = 'desc',
 }
 
 export type _PathArgument = {
@@ -98,7 +98,7 @@ export type _Relation = _Field & {
 
 export enum _RelationSide {
 	Inverse = 'inverse',
-	Owning = 'owning'
+	Owning = 'owning',
 }
 
 export type _Rule = {

package/src/introspection/introspection.schema.ts

@@ -174,7 +174,6 @@ const _Schema = new GraphQLObjectType({
 	},
 })
 
-
 export const createSchemaConfig = (resolver?: GraphQLFieldResolver<any, any>): GraphQLSchemaConfig => {
 	return {
 		query: new GraphQLObjectType({
@@ -190,5 +189,4 @@ export const createSchemaConfig = (resolver?: GraphQLFieldResolver<any, any>): G
 	}
 }
 
-
 export default new GraphQLSchema(createSchemaConfig())

package/src/mapper/ColumnValue.ts

@@ -7,7 +7,6 @@ export type ColumnValue = {
 	columnType: string
 }
 
-
 export const rowDataToFieldValues = (values: ColumnValue[]): Record<string, Value.FieldValue> =>
 	Object.fromEntries(values.map(it => [it.fieldName, it.value]))
 

package/src/mapper/ErrorUtils.ts

@@ -15,7 +15,6 @@ import { acceptFieldVisitor, tryGetColumnName } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
 import { DatabaseMetadata } from '@contember/database'
 
-
 type UniqueConstraintResult = {
 	entity: Model.Entity
 	fields: string[]
@@ -23,7 +22,12 @@ type UniqueConstraintResult = {
 
 const getEntityByTableName = (model: Model.Schema, tableName: string) => Object.values(model.entities).find(it => it.tableName === tableName)
 
-const findUniqueConstraint = (model: Model.Schema, databaseMetadata: DatabaseMetadata, tableName: string, constraintName: string): UniqueConstraintResult | null => {
+const findUniqueConstraint = (
+	model: Model.Schema,
+	databaseMetadata: DatabaseMetadata,
+	tableName: string,
+	constraintName: string,
+): UniqueConstraintResult | null => {
 	const constraint = databaseMetadata.uniqueConstraints.filter({ tableName, constraintName }).first()
 	if (!constraint) {
 		return null
@@ -51,7 +55,12 @@ type RelationInfo = {
 	targetEntity: Model.Entity
 }
 
-const findForeignConstraint = (model: Model.Schema, databaseMetadata: DatabaseMetadata, tableName: string, constraintName: string): RelationInfo | null => {
+const findForeignConstraint = (
+	model: Model.Schema,
+	databaseMetadata: DatabaseMetadata,
+	tableName: string,
+	constraintName: string,
+): RelationInfo | null => {
 	const constraint = databaseMetadata.foreignKeys.filter({ fromTable: tableName, constraintName }).first()
 	if (!constraint) {
 		return null
@@ -92,7 +101,6 @@ export const convertError = (
 	databaseMetadata: DatabaseMetadata,
 	e: any,
 ): MutationResult => {
-
 	if (e instanceof Database.NotNullViolationError) {
 		return new MutationConstraintViolationError([], ConstraintType.notNull, e.originalMessage, [
 			MutationResultHint.sqlError,
@@ -116,8 +124,8 @@ export const convertError = (
 		const matchResult = violationDetail.match(/^Key \(.+\)=\((.+)\) already exists\.$/)
 		const values = matchResult?.[1]
 		const message = constraint
-			? `${values ? `Value (${values})` : 'Unknown value'}` +
-			  ` already exists in unique columns (${constraint.fields.join(', ')}) on entity ${constraint.entity.name}`
+			? `${values ? `Value (${values})` : 'Unknown value'}`
+				+ ` already exists in unique columns (${constraint.fields.join(', ')}) on entity ${constraint.entity.name}`
 			: e.originalMessage
 		const paths = constraint ? constraint.fields.map(it => [{ field: it }]) : []
 		return new MutationConstraintViolationError(paths, ConstraintType.uniqueKey, message, [MutationResultHint.sqlError])
@@ -141,7 +149,11 @@ export const convertError = (
 	throw e
 }
 
-export const tryMutation = async (schema: Model.Schema, databaseMetadata: DatabaseMetadata, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
+export const tryMutation = async (
+	schema: Model.Schema,
+	databaseMetadata: DatabaseMetadata,
+	cb: () => Promise<MutationResultList>,
+): Promise<MutationResultList> => {
 	try {
 		return await cb()
 	} catch (e) {

package/src/mapper/EventManager.ts

@@ -25,7 +25,6 @@ export class AfterInsertEvent {
 	}
 }
 
-
 export class BeforeUpdateEvent {
 	public type = 'BeforeUpdateEvent' as const
 
@@ -81,7 +80,6 @@ export class BeforeJunctionUpdateEvent {
 	}
 }
 
-
 export class AfterJunctionUpdateEvent {
 	public type = 'AfterJunctionUpdateEvent' as const
 

package/src/mapper/JunctionTableManager.ts

@@ -1,15 +1,7 @@
 import { getEntity } from '@contember/schema-utils'
 import { PathFactory, WhereBuilder } from './select'
 import { PredicateFactory } from '../acl'
-import {
-	Client,
-	ConflictActionType,
-	DeleteBuilder,
-	InsertBuilder,
-	Literal,
-	Operator,
-	SelectBuilder,
-} from '@contember/database'
+import { Client, ConflictActionType, DeleteBuilder, InsertBuilder, Literal, Operator, SelectBuilder } from '@contember/database'
 import { Acl, Input, Model } from '@contember/schema'
 import {
 	MutationJunctionUpdateOk,
@@ -58,7 +50,14 @@ export class JunctionTableManager {
 			this.connectJunctionHandler,
 		)
 		if (result.result !== MutationResultType.noResultError) {
-			const afterEvent = new AfterJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'connect', result.result === MutationResultType.ok)
+			const afterEvent = new AfterJunctionUpdateEvent(
+				owningEntity,
+				relation,
+				owningUnique,
+				inverseUnique,
+				'connect',
+				result.result === MutationResultType.ok,
+			)
 			await mapper.eventManager.fire(afterEvent)
 		}
 		return [result]
@@ -82,14 +81,20 @@ export class JunctionTableManager {
 			this.disconnectJunctionHandler,
 		)
 		if (result.result !== MutationResultType.noResultError) {
-			const afterEvent = new AfterJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'disconnect', result.result === MutationResultType.ok)
+			const afterEvent = new AfterJunctionUpdateEvent(
+				owningEntity,
+				relation,
+				owningUnique,
+				inverseUnique,
+				'disconnect',
+				result.result === MutationResultType.ok,
+			)
 			beforeEvent.afterEvent = afterEvent
 			await mapper.eventManager.fire(afterEvent)
 		}
 		return [result]
 	}
 
-
 	private async executeJunctionModification(
 		db: Client,
 		owningEntity: Model.Entity,
@@ -112,8 +117,7 @@ export class JunctionTableManager {
 
 		const hasNoPredicates = Object.keys(owningPredicate).length === 0 && Object.keys(inversePredicate).length === 0
 
-		const okResultFactory = () =>
-			new MutationJunctionUpdateOk([], owningEntity, relation, owningPrimary, inversePrimary)
+		const okResultFactory = () => new MutationJunctionUpdateOk([], owningEntity, relation, owningPrimary, inversePrimary)
 		if (hasNoPredicates) {
 			return await handler.executeSimple({ db, joiningTable, owningPrimary, inversePrimary, okResultFactory })
 		} else {
@@ -134,7 +138,6 @@ export class JunctionTableManager {
 					)
 					.select(expr => expr.raw('true'), 'selected')
 					.from(new Literal('(values (null))'), 't')
-
 					.join(owningEntity.tableName, 'owning', condition => condition.raw('true'))
 					.join(inverseEntity.tableName, 'inverse', condition => condition.raw('true'))
 				qb = this.whereBuilder.build(qb, owningEntity, this.pathFactory.create([], 'owning'), owningWhere)
@@ -200,8 +203,7 @@ export class JunctionConnectHandler implements JunctionHandler {
 			.into(joiningTable.tableName)
 			.values({
 				[joiningTable.joiningColumn.columnName]: expr => expr.select(['data', joiningTable.joiningColumn.columnName]),
-				[joiningTable.inverseJoiningColumn.columnName]: expr =>
-					expr.select(['data', joiningTable.inverseJoiningColumn.columnName]),
+				[joiningTable.inverseJoiningColumn.columnName]: expr => expr.select(['data', joiningTable.inverseJoiningColumn.columnName]),
 			})
 			.returning(new Literal('true as inserted'))
 			.from(qb => qb.from('data'))

package/src/mapper/Mapper.ts

@@ -82,7 +82,11 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		return await hydrator.hydrateAll(rows, indexByAlias)
 	}
 
-	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>, relationPath: Model.AnyRelationContext[]): Promise<SelectResultObject[]> {
+	public async select(
+		entity: Model.Entity,
+		input: ObjectNode<Input.ListQueryInput>,
+		relationPath: Model.AnyRelationContext[],
+	): Promise<SelectResultObject[]> {
 		const hydrator = new SelectHydrator()
 		const qb: SelectBuilder<SelectBuilder.Result> = SelectBuilder.create()
 
@@ -135,7 +139,12 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		const augmentedBuilder = qb.from(entity.tableName, path.alias).meta('path', [...input.path, input.alias])
 
 		const selector = this.selectBuilderFactory.create(augmentedBuilder, hydrator, relationPath)
-		const filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {}, relationPath[relationPath.length - 1])
+		const filterWithPredicates = this.predicatesInjector.inject(
+			entity,
+			inputWithOrder.args.filter || {},
+			relationPath[relationPath.length - 1],
+			relationPath,
+		)
 		const inputWithPredicates = inputWithOrder.withArg('filter', filterWithPredicates)
 		selector.select(this, entity, inputWithPredicates, path, groupBy)
 		return await selector.execute(this.db)
@@ -164,7 +173,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			.select(expr => expr.raw('count(*)'), 'row_count')
 			.select([path.alias, relation.joiningColumn.columnName])
 			.groupBy([path.alias, relation.joiningColumn.columnName])
-		const withPredicates = this.predicatesInjector.inject(entity, filter, relationPath[relationPath.length - 1])
+		const withPredicates = this.predicatesInjector.inject(entity, filter, relationPath[relationPath.length - 1], relationPath)
 		const qbWithWhere = this.whereBuilder.build(qb, entity, path, withPredicates, { relationPath })
 		const rows = await qbWithWhere.getResult(this.db)
 		const result = new Map<string, number>()
@@ -183,9 +192,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			throw new ImplementationException()
 		}
 		await this.setupSystemVariables()
-		return tryMutation(this.schema, this.schemaDatabaseMetadata, () =>
-			this.insertInternal(entity, data, builderCb),
-		)
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, () => this.insertInternal(entity, data, builderCb))
 	}
 
 	public async update(

package/src/mapper/MapperFactory.ts

@@ -13,7 +13,6 @@ import { Providers } from '@contember/schema-utils'
 export type MapperFactoryHook = (mapper: Mapper) => void
 
 export class MapperFactory {
-
 	public readonly hooks: MapperFactoryHook[] = []
 
 	constructor(

package/src/mapper/Result.ts

@@ -178,7 +178,7 @@ export class MutationEntryNotFoundError implements MutationResultInterface {
 	hints: MutationResultHint[] = []
 	message: string
 
-	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere | Input.Where) {
+	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere | Input.OptionalWhere) {
 		this.message = 'for input ' + JSON.stringify(where)
 	}
 }
@@ -202,6 +202,6 @@ export const prependPath = (path: Path, results: MutationResultList): MutationRe
 	}))
 
 export const getInsertPrimary = (result: MutationResultList) =>
-	result[0] && result[0].result === MutationResultType.ok && result[0].type === ModificationType.create
+	!result.some(it => it.error) && result[0] && result[0].result === MutationResultType.ok && result[0].type === ModificationType.create
 		? result[0].primary
 		: undefined

package/src/mapper/delete/DeleteExecutor.ts

@@ -158,7 +158,6 @@ export class DeleteExecutor {
 		return await this.processDeleteResult(state, mapper, entity, result, orphanRemovals)
 	}
 
-
 	private async collectOnDeleteInfo(state: DeleteState, mapper: Mapper, entity: Model.Entity, values: Input.PrimaryValue[]): Promise<void> {
 		if (values.length === 0) {
 			return
@@ -210,7 +209,6 @@ export class DeleteExecutor {
 		await this.processDeleteResult(state, mapper, entity, result, orphanRemovals)
 	}
 
-
 	private async collectSetNullResult(
 		state: DeleteState,
 		mapper: Mapper,
@@ -240,7 +238,6 @@ export class DeleteExecutor {
 		state.pushFailResult(new MutationConstraintViolationError([], ConstraintType.foreignKey, message))
 	}
 
-
 	private async collectRestrictResult(
 		state: DeleteState,
 		mapper: Mapper,
@@ -278,7 +275,6 @@ export class DeleteExecutor {
 			const entity = getEntity(this.schema, orphanRemoval[0])
 			const orphanResult = await this.collectDeleteInfo(state, mapper, entity, { [entity.primary]: { in: orphanRemoval[1] } })
 			deleteQueue.push([entity, orphanResult])
-
 		} while (true)
 	}
 
@@ -294,7 +290,11 @@ export class DeleteExecutor {
 		return orphanColumns.reduce((qb, column) => qb.select(['root_', column], `_${column}`), qb)
 	}
 
-	private createFetchByIdQueryBuilder(entity: Model.Entity, relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation, values: Input.PrimaryValue[]) {
+	private createFetchByIdQueryBuilder(
+		entity: Model.Entity,
+		relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation,
+		values: Input.PrimaryValue[],
+	) {
 		return SelectBuilder.create<EntityReferenceRow>()
 			.from(entity.tableName, 'root_')
 			.select(['root_', entity.primaryColumn], 'id')
@@ -302,11 +302,10 @@ export class DeleteExecutor {
 			.where(expr => expr.in(['root_', relation.joiningColumn.columnName], values))
 	}
 
-	private filterPlannedForDelete<R extends {id: Input.PrimaryValue}>(state: DeleteState, entity: Model.Entity, values: R[]): R[] {
+	private filterPlannedForDelete<R extends { id: Input.PrimaryValue }>(state: DeleteState, entity: Model.Entity, values: R[]): R[] {
 		return values.filter(it => !state.isPlannedDelete(entity.name, it.id))
 	}
 
-
 	private async processDeleteResult(
 		state: DeleteState,
 		mapper: Mapper,

package/src/mapper/delete/DeleteState.ts

@@ -33,7 +33,6 @@ export class DeleteState {
 		this.failResult.push(...Array.isArray(result) ? result : [result])
 	}
 
-
 	public isPlannedDelete(entityName: string, primary: Input.PrimaryValue): boolean {
 		return this.plannedDelete.isDeleted(entityName, primary)
 	}

package/src/mapper/delete/helpers.ts

@@ -11,8 +11,7 @@ export const findRelationsWithOrphanRemoval = (schema: Model.Schema, entity: Mod
 			visitManyHasManyOwning: () => null,
 			visitOneHasOneInverse: () => null,
 			visitOneHasMany: () => null,
-			visitOneHasOneOwning: ({ relation, targetEntity }) =>
-				relation.orphanRemoval ? [targetEntity, relation] : null,
+			visitOneHasOneOwning: ({ relation, targetEntity }) => relation.orphanRemoval ? [targetEntity, relation] : null,
 			visitManyHasOne: () => null,
 		}),
 	).filter((it): it is OneHasOneOwningRelationTuple => it !== null)
@@ -31,7 +30,7 @@ export const findOwningRelations = (schema: Model.Schema, entity: Model.Entity):
 				visitOneHasMany: () => null,
 				visitOneHasOneOwning: ({ relation }): EntityOwningRelationTuple => [entity, relation],
 				visitManyHasOne: ({ relation }): EntityOwningRelationTuple => [entity, relation],
-			}),
+			})
 		)
 		.reduce<EntityOwningRelationTuple[]>(
 			(acc, value) => [