@contember/engine-content-api 1.2.0-rc.4 → 1.3.0-alpha.1

package/src/mapper/update/UpdateBuilderFactory.ts

@@ -1,15 +1,24 @@
 import { PathFactory, WhereBuilder } from '../select'
 import { Input, Model } from '@contember/schema'
 import { UpdateBuilder } from './UpdateBuilder'
+import { PredicateFactory } from '../../acl'
 
 export class UpdateBuilderFactory {
 	constructor(
 		private readonly schema: Model.Schema,
 		private readonly whereBuilder: WhereBuilder,
 		private readonly pathFactory: PathFactory,
+		private readonly predicateFactory: PredicateFactory,
 	) {}
 
 	public create(entity: Model.Entity, uniqueWhere: Input.Where): UpdateBuilder {
-		return new UpdateBuilder(this.schema, entity, this.whereBuilder, uniqueWhere, this.pathFactory)
+		return new UpdateBuilder(
+			this.schema,
+			entity,
+			this.whereBuilder,
+			uniqueWhere,
+			this.pathFactory,
+			this.predicateFactory,
+		)
 	}
 }

package/src/mapper/update/Updater.ts

@@ -1,6 +1,6 @@
 import { SqlUpdateInputProcessor } from './SqlUpdateInputProcessor'
-import { UniqueWhereExpander, UpdateInputVisitor } from '../../inputProcessing'
-import { Acl, Input, Model } from '@contember/schema'
+import { UpdateInputVisitor } from '../../inputProcessing'
+import { Input, Model } from '@contember/schema'
 import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
@@ -8,7 +8,6 @@ import { acceptEveryFieldVisitor } from '@contember/schema-utils'
 import { Client } from '@contember/database'
 import {
 	collectResults,
-	MutationEntryNotFoundError,
 	MutationNoResultError,
 	MutationNothingToDo,
 	MutationResultList,
@@ -39,9 +38,8 @@ export class Updater {
 		})
 
 		const predicateFields = Object.keys(data)
-		this.applyPredicates(entity, predicateFields, updateBuilder)
-
-		if (filter) {
+		updateBuilder.addPredicates(predicateFields)
+		if (filter && Object.keys(filter).length > 0) {
 			updateBuilder.addOldWhere(filter)
 		}
 
@@ -51,21 +49,23 @@ export class Updater {
 
 		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, data, values)
 		const mutationResultPromise = Updater.executeUpdate(updateBuilder, mapper.db, okResultFactory)
-
-		return await collectResults(this.schema, mutationResultPromise, Object.values(promises))
+		const otherPromises = Object.values(promises)
+		if (otherPromises.length === 0) {
+			return await mutationResultPromise
+		} else {
+			return await collectResults(this.schema, mutationResultPromise, otherPromises)
+		}
 	}
 
 	public async updateCb(
 		mapper: Mapper,
 		entity: Model.Entity,
 		primaryValue: Input.PrimaryValue,
-		predicateFields: string[],
 		builderCb: (builder: UpdateBuilder) => void,
 	): Promise<MutationResultList> {
 		const updateBuilder = this.updateBuilderFactory.create(entity, {
 			[entity.primary]: { eq: primaryValue },
 		})
-		this.applyPredicates(entity, predicateFields, updateBuilder)
 
 		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, {}, values)
 		builderCb(updateBuilder)
@@ -73,12 +73,6 @@ export class Updater {
 		return Updater.executeUpdate(updateBuilder, mapper.db, okResultFactory)
 	}
 
-	private applyPredicates(entity: Model.Entity, predicateFields: string[], updateBuilder: UpdateBuilder): void {
-		const predicateWhere = this.predicateFactory.create(entity, Acl.Operation.update, predicateFields)
-		updateBuilder.addOldWhere(predicateWhere)
-		updateBuilder.addNewWhere(predicateWhere)
-	}
-
 	private static async executeUpdate(
 		updateBuilder: UpdateBuilder,
 		db: Client,
@@ -97,6 +91,3 @@ export class Updater {
 		return [okResultFactory(rowDataToFieldValues(result.values))]
 	}
 }
-
-export const AbortUpdate = Symbol('AbortUpdate')
-export type AbortUpdate = typeof AbortUpdate

package/src/resolvers/MutationResolver.ts

@@ -432,7 +432,7 @@ export class MutationResolver {
 
 		const result = await mapper.delete(entity, queryAst.args.by, queryAst.args.filter)
 		if (
-			result.length === 1 &&
+			result.length >= 1 &&
 			(result[0].result === MutationResultType.ok || result[0].result === MutationResultType.nothingToDo)
 		) {
 			return { ok: true, errors: [], ...nodes }

package/src/schema/GraphQlSchemaBuilderFactory.ts

@@ -28,6 +28,7 @@ import { PaginatedFieldConfigFactory } from './PaginatedFieldConfigFactory'
 import { PaginatedHasManyFieldProvider } from '../extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
 import { PaginatedHasManyFieldProviderVisitor } from '../extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor'
 import { Builder } from '@contember/dic'
+import { ConnectOrCreateRelationInputProvider } from './mutations/ConnectOrCreateRelationInputProvider'
 
 export class GraphQlSchemaBuilderFactory {
 	constructor() {}
@@ -72,8 +73,10 @@ export class GraphQlSchemaBuilderFactory {
 				new Accessor<EntityInputProvider<EntityInputType.create>>())
 			.addService('createEntityRelationAllowedOperationsVisitor', ({ authorizator }) =>
 				new CreateEntityRelationAllowedOperationsVisitor(authorizator))
-			.addService('createEntityRelationInputFieldVisitor', ({ schema,					whereTypeProvider,					createEntityInputProviderAccessor,					createEntityRelationAllowedOperationsVisitor				}) =>
-				new CreateEntityRelationInputFieldVisitor(schema, whereTypeProvider, createEntityInputProviderAccessor, createEntityRelationAllowedOperationsVisitor))
+			.addService('connectOrCreateRelationInputProvider', ({ schema, whereTypeProvider, createEntityInputProviderAccessor }) =>
+				 new ConnectOrCreateRelationInputProvider(schema, whereTypeProvider, createEntityInputProviderAccessor))
+			.addService('createEntityRelationInputFieldVisitor', ({ schema,	whereTypeProvider, createEntityInputProviderAccessor, createEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider }) =>
+				new CreateEntityRelationInputFieldVisitor(schema, whereTypeProvider, createEntityInputProviderAccessor, createEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider))
 			.addService('createEntityRelationInputProvider', ({ schema, createEntityRelationInputFieldVisitor }) =>
 				new CreateEntityRelationInputProvider(schema, createEntityRelationInputFieldVisitor))
 			.addService('createEntityInputFieldVisitor', ({ schema, authorizator, columnTypeResolver, createEntityRelationInputProvider }) =>
@@ -84,8 +87,8 @@ export class GraphQlSchemaBuilderFactory {
 				new Accessor<EntityInputProvider<EntityInputType.update>>())
 			.addService('updateEntityRelationAllowedOperationsVisitor', ({ authorizator }) =>
 				new UpdateEntityRelationAllowedOperationsVisitor(authorizator))
-			.addService('updateEntityRelationInputFieldVisitor', ({ schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor }) =>
-				new UpdateEntityRelationInputFieldVisitor(schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor))
+			.addService('updateEntityRelationInputFieldVisitor', ({ schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider }) =>
+				new UpdateEntityRelationInputFieldVisitor(schema, authorizator, whereTypeProvider, updateEntityInputProviderAccessor, createEntityInputProvider, updateEntityRelationAllowedOperationsVisitor, connectOrCreateRelationInputProvider))
 			.addService('updateEntityRelationInputProvider', ({ schema, updateEntityRelationInputFieldVisitor }) =>
 				new UpdateEntityRelationInputProvider(schema, updateEntityRelationInputFieldVisitor))
 			.addService('updateEntityInputFieldVisitor', ({ authorizator, columnTypeResolver, updateEntityRelationInputProvider }) =>

package/src/schema/mutations/ConnectOrCreateRelationInputProvider.ts

@@ -0,0 +1,54 @@
+import { Accessor, Interface, singletonFactory } from '../../utils'
+import { GraphQLInputObjectType } from 'graphql'
+import { GqlTypeName } from '../utils'
+import { WhereTypeProvider } from '../WhereTypeProvider'
+import { EntityInputProvider, EntityInputType } from './EntityInputProvider'
+import { Model } from '@contember/schema'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { ImplementationException } from '../../exception'
+
+type Args = {
+	entityName: string
+	relationName: string
+}
+
+export class ConnectOrCreateRelationInputProvider {
+	private inputs = singletonFactory<GraphQLInputObjectType, Args>(id => this.createInput(id.entityName, id.relationName))
+
+	constructor(
+		private readonly schema: Model.Schema,
+		private readonly whereTypeBuilder: WhereTypeProvider,
+		private readonly createEntityInputProviderAccessor: Accessor<Interface<EntityInputProvider<EntityInputType.create>>>,
+	) {
+	}
+
+
+	getInput(entityName: string, relationName: string) {
+		return this.inputs({ entityName, relationName })
+	}
+
+	private createInput(entityName: string, relationName: string) {
+		return acceptFieldVisitor<GraphQLInputObjectType>(this.schema, entityName, relationName, {
+			visitColumn() {
+				throw new ImplementationException()
+			},
+			visitRelation: ({ entity, targetEntity, targetRelation, relation }) => {
+				const uniqueWhere = this.whereTypeBuilder.getEntityUniqueWhereType(targetEntity.name)
+				const targetName = targetRelation ? targetRelation.name : undefined
+				const createInput = this.createEntityInputProviderAccessor.get().getInput(targetEntity.name, targetName)
+				if (!uniqueWhere || !createInput) {
+					throw new ImplementationException()
+				}
+
+				return new GraphQLInputObjectType({
+					name: GqlTypeName`${entity.name}ConnectOrCreate${relation.name}RelationInput`,
+					fields: () => ({
+						connect: { type: uniqueWhere },
+						create: { type: createInput },
+					}),
+				})
+			},
+		})
+
+	}
+}

package/src/schema/mutations/CreateEntityInputFieldVisitor.ts

@@ -23,9 +23,7 @@ export class CreateEntityInputFieldVisitor implements
 			return undefined
 		}
 		const type = this.columnTypeResolver.getType(column)
-		return {
-			type,
-		}
+		return { type }
 	}
 
 	public visitHasOne({ entity, relation }: Model.AnyHasOneRelationContext): GraphQLInputFieldConfig | undefined {
@@ -33,9 +31,7 @@ export class CreateEntityInputFieldVisitor implements
 		if (type === undefined) {
 			return undefined
 		}
-		return {
-			type,
-		}
+		return { type }
 	}
 
 	public visitHasMany({ entity, relation }: Model.AnyHasManyRelationContext): GraphQLInputFieldConfig | undefined {

package/src/schema/mutations/CreateEntityRelationAllowedOperationsVisitor.ts

@@ -58,10 +58,12 @@ export class CreateEntityRelationAllowedOperationsVisitor implements
 		if (canReadTargetEntity && canCreateOwning) {
 			result.push(Input.CreateRelationOperation.connect)
 		}
-
 		if (canCreateTargetEntity && canCreateOwning) {
 			result.push(Input.CreateRelationOperation.create)
 		}
+		if (canReadTargetEntity && canCreateTargetEntity && canCreateOwning) {
+			result.push(Input.CreateRelationOperation.connectOrCreate)
+		}
 
 		return result
 	}

package/src/schema/mutations/CreateEntityRelationInputFieldVisitor.ts

@@ -7,6 +7,7 @@ import { EntityInputProvider, EntityInputType } from './EntityInputProvider'
 import { CreateEntityRelationAllowedOperationsVisitor } from './CreateEntityRelationAllowedOperationsVisitor'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { ImplementationException } from '../../exception'
+import { ConnectOrCreateRelationInputProvider } from './ConnectOrCreateRelationInputProvider'
 
 export class CreateEntityRelationInputFieldVisitor implements
 	Model.ColumnVisitor<never>,
@@ -15,10 +16,9 @@ export class CreateEntityRelationInputFieldVisitor implements
 	constructor(
 		private readonly schema: Model.Schema,
 		private readonly whereTypeBuilder: WhereTypeProvider,
-		private readonly createEntityInputProviderAccessor: Accessor<
-			Interface<EntityInputProvider<EntityInputType.create>>
-		>,
+		private readonly createEntityInputProviderAccessor: Accessor<Interface<EntityInputProvider<EntityInputType.create>>>,
 		private readonly createEntityRelationAllowedOperationsVisitor: CreateEntityRelationAllowedOperationsVisitor,
+		private readonly connectOrCreateRelationInputProvider: ConnectOrCreateRelationInputProvider,
 	) {}
 
 	public visitColumn(): never {
@@ -46,12 +46,10 @@ export class CreateEntityRelationInputFieldVisitor implements
 			this.createEntityRelationAllowedOperationsVisitor,
 		)
 
-		if (allowedOperations.includes(Input.CreateRelationOperation.connect)) {
-			const uniqueWhere = this.whereTypeBuilder.getEntityUniqueWhereType(targetEntity.name)
-			if (uniqueWhere) {
-				fields[Input.CreateRelationOperation.connect] = {
-					type: uniqueWhere,
-				}
+		const uniqueWhere = this.whereTypeBuilder.getEntityUniqueWhereType(targetEntity.name)
+		if (allowedOperations.includes(Input.CreateRelationOperation.connect) && uniqueWhere) {
+			fields[Input.CreateRelationOperation.connect] = {
+				type: uniqueWhere,
 			}
 		}
 
@@ -61,18 +59,25 @@ export class CreateEntityRelationInputFieldVisitor implements
 				type: createInput,
 			}
 		}
+		if (allowedOperations.includes(Input.CreateRelationOperation.connectOrCreate) && uniqueWhere !== undefined && createInput !== undefined) {
+			const connectOrCreateInput = this.connectOrCreateRelationInputProvider.getInput(entity.name, relation.name)
+			if (connectOrCreateInput) {
+				fields[Input.CreateRelationOperation.connectOrCreate] = {
+					type: connectOrCreateInput,
+				}
+			}
+		}
 		if (Object.keys(fields).length === 0) {
 			return undefined
 		}
 		return new GraphQLInputObjectType({
 			name: GqlTypeName`${entity.name}Create${relation.name}EntityRelationInput`,
-			fields: () =>
-				withAliasField
-					? {
-						...fields,
-						alias: { type: GraphQLString },
+			fields: () => withAliasField
+				? {
+					...fields,
+					alias: { type: GraphQLString },
 					  }
-					: fields,
+				: fields,
 		})
 	}
 }

package/src/schema/mutations/EntityInputProvider.ts

@@ -38,9 +38,6 @@ export class EntityInputProvider<Operation extends EntityInputType> {
 		}
 		const entityName = entity.name
 		const withoutSuffix = withoutRelation ? GqlTypeName`Without${withoutRelation}` : ''
-		if (entity.view) {
-			return undefined
-		}
 		const operation: Acl.Operation = (() => {
 			switch (this.operation) {
 				case EntityInputType.create:

package/src/schema/mutations/UpdateEntityInputFieldVisitor.ts

@@ -22,9 +22,7 @@ export class UpdateEntityInputFieldVisitor implements
 			return undefined
 		}
 		const type = this.columnTypeResolver.getType(column)
-		return {
-			type,
-		}
+		return { type }
 	}
 
 	public visitHasOne({ entity, relation }: Model.AnyHasOneRelationContext) {
@@ -32,9 +30,7 @@ export class UpdateEntityInputFieldVisitor implements
 		if (type === undefined) {
 			return undefined
 		}
-		return {
-			type,
-		}
+		return { type }
 	}
 
 	public visitHasMany({ entity, relation }: Model.AnyHasManyRelationContext) {

package/src/schema/mutations/UpdateEntityRelationAllowedOperationsVisitor.ts

@@ -72,7 +72,6 @@ export class UpdateEntityRelationAllowedOperationsVisitor implements
 			result.push(Input.UpdateRelationOperation.connect)
 			result.push(Input.UpdateRelationOperation.disconnect)
 		}
-
 		if (canCreateTargetEntity && canUpdateOwningRelation) {
 			result.push(Input.UpdateRelationOperation.create)
 		}
@@ -85,6 +84,9 @@ export class UpdateEntityRelationAllowedOperationsVisitor implements
 		if (canDeleteTargetEntity && canUpdateOwningRelation) {
 			result.push(Input.UpdateRelationOperation.delete)
 		}
+		if (canReadTargetEntity && canUpdateOwningRelation && canCreateTargetEntity) {
+			result.push(Input.UpdateRelationOperation.connectOrCreate)
+		}
 
 		return result
 	}

package/src/schema/mutations/UpdateEntityRelationInputFieldVisitor.ts

@@ -14,9 +14,9 @@ import { acceptFieldVisitor } from '@contember/schema-utils'
 import { UpdateEntityRelationAllowedOperationsVisitor } from './UpdateEntityRelationAllowedOperationsVisitor'
 import { Authorizator } from '../../acl'
 import { ImplementationException } from '../../exception'
+import { ConnectOrCreateRelationInputProvider } from './ConnectOrCreateRelationInputProvider'
 
-export class UpdateEntityRelationInputFieldVisitor implements
-	Model.ColumnVisitor<never>,
+export class UpdateEntityRelationInputFieldVisitor implements Model.ColumnVisitor<never>,
 	Model.RelationByGenericTypeVisitor<GraphQLInputObjectType | undefined> {
 
 	constructor(
@@ -26,7 +26,9 @@ export class UpdateEntityRelationInputFieldVisitor implements
 		private readonly updateEntityInputProviderAccessor: Accessor<EntityInputProvider<EntityInputType.update>>,
 		private readonly createEntityInputProvider: EntityInputProvider<EntityInputType.create>,
 		private readonly updateEntityRelationAllowedOperationsVisitor: UpdateEntityRelationAllowedOperationsVisitor,
-	) {}
+		private readonly connectOrCreateRelationInputProvider: ConnectOrCreateRelationInputProvider,
+	) {
+	}
 
 	public visitColumn(): never {
 		throw new Error('UpdateEntityRelationInputFieldVisitor: Not applicable for a column')
@@ -36,39 +38,39 @@ export class UpdateEntityRelationInputFieldVisitor implements
 		const withoutRelation = targetRelation ? targetRelation.name : undefined
 
 		const whereInput = this.createWhereInput(targetEntity)
+
 		const createInputType = this.createEntityInputProvider.getInput(targetEntity.name, withoutRelation)
-		const createInput = createInputType
-			? {
-				type: createInputType,
-			  }
-			: undefined
+		const createInput = createInputType ? { type: createInputType } : undefined
+
 		const updateInputType = this.updateEntityInputProviderAccessor.get().getInput(targetEntity.name, withoutRelation)
-		const updateInput = updateInputType
+		const updateInput = updateInputType ? {  type: updateInputType } : undefined
+
+		const upsertInput = updateInput && createInput
 			? {
-				type: updateInputType,
-			  }
-			: undefined
-		const upsertInput =
-			updateInput && createInput
-				? {
-					type: new GraphQLInputObjectType({
-						name: GqlTypeName`${entity.name}Upsert${relation.name}RelationInput`,
-						fields: () => ({
-							update: updateInput,
-							create: createInput,
-						}),
+				type: new GraphQLInputObjectType({
+					name: GqlTypeName`${entity.name}Upsert${relation.name}RelationInput`,
+					fields: () => ({
+						update: updateInput,
+						create: createInput,
 					}),
-				  }
-				: undefined
+				}),
+			}
+			: undefined
+
 		const booleanInput = {
 			type: GraphQLBoolean,
 		}
 
+		const connectOrCreateInput = createInput && whereInput
+			? { type: this.connectOrCreateRelationInputProvider.getInput(entity.name, relation.name) }
+			: undefined
+
 		const fields = {
+			[Input.UpdateRelationOperation.connect]: whereInput,
 			[Input.UpdateRelationOperation.create]: createInput,
+			[Input.UpdateRelationOperation.connectOrCreate]: connectOrCreateInput,
 			[Input.UpdateRelationOperation.update]: updateInput,
 			[Input.UpdateRelationOperation.upsert]: upsertInput,
-			[Input.UpdateRelationOperation.connect]: whereInput,
 			[Input.UpdateRelationOperation.disconnect]: booleanInput,
 			[Input.UpdateRelationOperation.delete]: booleanInput,
 		}
@@ -88,45 +90,37 @@ export class UpdateEntityRelationInputFieldVisitor implements
 		const withoutRelation = targetRelation ? targetRelation.name : undefined
 
 		const whereInput = this.createWhereInput(targetEntity)
+
 		const createInputType = this.createEntityInputProvider.getInput(targetEntity.name, withoutRelation)
-		const createInput = createInputType
-			? {
-				type: createInputType,
-			  }
-			: undefined
+		const createInput = createInputType ? { type: createInputType } : undefined
+
 		const updateInputType = this.updateEntityInputProviderAccessor.get().getInput(targetEntity.name, withoutRelation)
-		const updateInput = updateInputType
+		const updateInput = updateInputType ? { type: updateInputType } : undefined
+
+		const updateSpecifiedInput = updateInput && whereInput
 			? {
-				type: updateInputType,
-			  }
+				type: new GraphQLInputObjectType({
+					name: GqlTypeName`${entity.name}Update${relation.name}RelationInput`,
+					fields: () => ({
+						by: whereInput,
+						data: updateInput,
+					}),
+				}),
+			}
 			: undefined
 
-		const updateSpecifiedInput =
-			updateInput && whereInput
-				? {
-					type: new GraphQLInputObjectType({
-						name: GqlTypeName`${entity.name}Update${relation.name}RelationInput`,
-						fields: () => ({
-							by: whereInput,
-							data: updateInput,
-						}),
-					}),
-				  }
-				: undefined
-
-		const upsertInput =
-			updateInput && createInput && whereInput
-				? {
-					type: new GraphQLInputObjectType({
-						name: GqlTypeName`${entity.name}Upsert${relation.name}RelationInput`,
-						fields: () => ({
-							by: whereInput,
-							update: updateInput,
-							create: createInput,
-						}),
+		const upsertInput = updateInput && createInput && whereInput
+			? {
+				type: new GraphQLInputObjectType({
+					name: GqlTypeName`${entity.name}Upsert${relation.name}RelationInput`,
+					fields: () => ({
+						by: whereInput,
+						update: updateInput,
+						create: createInput,
 					}),
-				  }
-				: undefined
+				}),
+			}
+			: undefined
 
 		const fields = {
 			[Input.UpdateRelationOperation.create]: createInput,
@@ -136,6 +130,7 @@ export class UpdateEntityRelationInputFieldVisitor implements
 			[Input.UpdateRelationOperation.disconnect]: whereInput,
 			[Input.UpdateRelationOperation.delete]: whereInput,
 		}
+
 		const filteredFields = this.filterAllowedOperations(entity, relation, fields)
 		if (Object.keys(filteredFields).length === 0) {
 			return undefined

package/tests/cases/integration/graphQlDb/update/deferedConstraints.test.ts

@@ -60,10 +60,10 @@ test('delete without deferring constraints', async () => {
 		return: {
 			transaction: {
 				ok: false,
-				errorMessage: 'Execution has failed:\nupdatePost.attachments.0: ForeignKeyConstraintViolation (Cannot delete row 123e4567-e89b-12d3-a456-000000000002 of entity Attachment, because it is still referenced from Reference::attachment. This is possibly caused by ACL denial or by missing "on delete cascade")',
+				errorMessage: 'Execution has failed:\nupdatePost.attachments.0: ForeignKeyConstraintViolation (Cannot delete 123e4567-e89b-12d3-a456-000000000002 row(s) of entity Attachment, because it is still referenced from 123e4567-e89b-12d3-a456-000000000003 row(s) of entity Reference in relation attachment. OnDelete behaviour of this relation is set to "restrict". You might consider changing it to "setNull" or "cascade".)',
 				updatePost: {
 					ok: false,
-					errorMessage: 'Execution has failed:\nattachments.0: ForeignKeyConstraintViolation (Cannot delete row 123e4567-e89b-12d3-a456-000000000002 of entity Attachment, because it is still referenced from Reference::attachment. This is possibly caused by ACL denial or by missing "on delete cascade")',
+					errorMessage: 'Execution has failed:\nattachments.0: ForeignKeyConstraintViolation (Cannot delete 123e4567-e89b-12d3-a456-000000000002 row(s) of entity Attachment, because it is still referenced from 123e4567-e89b-12d3-a456-000000000003 row(s) of entity Reference in relation attachment. OnDelete behaviour of this relation is set to "restrict". You might consider changing it to "setNull" or "cascade".)',
 				},
 			},
 		},

package/tests/cases/integration/graphQlDb/update/failedDelete.test.ts

@@ -37,7 +37,7 @@ test('fails when deleting entity without proper cascade', async () => {
         }`,
 		return: {
 			deletePost: {
-				errorMessage: 'Execution has failed:\nunknown field: ForeignKeyConstraintViolation (Cannot delete row 123e4567-e89b-12d3-a456-000000000001 of entity Post, because it is still referenced from PostLocales::post. This is possibly caused by ACL denial or by missing "on delete cascade")',
+				errorMessage: 'Execution has failed:\nunknown field: ForeignKeyConstraintViolation (Cannot delete 123e4567-e89b-12d3-a456-000000000001 row(s) of entity Post, because it is still referenced from 123e4567-e89b-12d3-a456-000000000002 row(s) of entity PostLocales in relation post. OnDelete behaviour of this relation is set to "restrict". You might consider changing it to "setNull" or "cascade".)',
 				node: null,
 			},
 		},

package/tests/cases/integration/graphQlDb/update/nullChecksNotNull.test.ts

@@ -69,7 +69,7 @@ test('update site & try to create contact page which however exists', async () =
 				ok: false,
 				errors: [
 					{
-						type: 'UniqueConstraintViolation',
+						type: 'NotNullConstraintViolation',
 					},
 				],
 			},

package/tests/cases/integration/graphQlDb/update/nullChecksNullable.test.ts

@@ -68,9 +68,6 @@ test('update site & try to create contact page which however exists', async () =
 					{
 						type: 'NotNullConstraintViolation',
 					},
-					{
-						type: 'UniqueConstraintViolation',
-					},
 				],
 			},
 		},

package/tests/cases/integration/graphQlRequests/delete/aclDelete.test.ts

@@ -1,11 +1,11 @@
 import { test } from 'vitest'
-import { execute, sqlDeferred, sqlTransaction } from '../../../../src/test'
+import { execute, failedTransaction } from '../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Acl, Model } from '@contember/schema'
+import { Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../src/tags'
 import { testUuid } from '../../../../src/testUuid'
 
-test('delete post with acl', async () => {
+test('delete post with acl (denied)', async () => {
 	await execute({
 		schema: new SchemaBuilder()
 			.entity('Post', entity => entity.column('locale', c => c.type(Model.ColumnType.String)))
@@ -13,9 +13,8 @@ test('delete post with acl', async () => {
 		query: GQL`
         mutation {
           deletePost(by: {id: "${testUuid(1)}"}) {
-            node {
-              id
-            }
+            ok
+            errorMessage
           }
         }`,
 		permissions: {
@@ -35,45 +34,27 @@ test('delete post with acl', async () => {
 			locale_variable: { in: ['cs'] },
 		},
 		executes: [
-			...sqlTransaction([
-				{
-					sql: SQL`select
-                     "root_"."id" as "root_id"
-                     from "public"."post" as "root_"
-                   where "root_"."id" = ?`,
-					parameters: [testUuid(1)],
-					response: {
-						rows: [
-							{
-								root_id: testUuid(1),
-							},
-						],
-					},
-				},
+			...failedTransaction([
 				{
 					sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
 					parameters: [testUuid(1)],
 					response: { rows: [{ id: testUuid(1) }] },
 				},
-				...sqlDeferred([
-					{
-						sql: SQL`delete from "public"."post"
-            where "id" in (select "root_"."id"
-                           from "public"."post" as "root_"
-                           where "root_"."id" = ? and "root_"."locale" in (?))
-            returning "id"`,
-						parameters: [testUuid(1), 'cs'],
-						response: { rows: [{ id: testUuid(1) }] },
+				{
+					sql: SQL`select "root_"."id" as "id", "root_"."locale" in (?) as "allowed" from "public"."post" as "root_" where "root_"."id" = ?`,
+					parameters: ['cs', testUuid(1)],
+					response: {
+						rows: [{ id: testUuid(1), allowed: false }],
 					},
-				]),
+				},
 			]),
 		],
 		return: {
 			data: {
 				deletePost: {
-					node: {
-						id: testUuid(1),
-					},
+					ok: false,
+					errorMessage: 'Execution has failed:\n' +
+						'unknown field: NotFoundOrDenied (for input {"id":{"in":["123e4567-e89b-12d3-a456-000000000001"]}})',
 				},
 			},
 		},