@contember/engine-content-api 0.12.0-beta.1 → 1.0.0-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "0.12.0-beta.1",
+  "version": "1.0.0-alpha.2",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -9,24 +9,24 @@
     "test": "uvu dist/tests/cases/ \\.js$"
   },
   "dependencies": {
-    "@contember/database": "^0.12.0-beta.1",
-    "@contember/dic": "^0.12.0-beta.1",
-    "@contember/engine-common": "^0.12.0-beta.1",
-    "@contember/graphql-utils": "^0.12.0-beta.1",
-    "@contember/schema": "^0.12.0-beta.1",
-    "@contember/schema-utils": "^0.12.0-beta.1",
+    "@contember/database": "^1.0.0-alpha.2",
+    "@contember/dic": "^1.0.0-alpha.2",
+    "@contember/engine-common": "^1.0.0-alpha.2",
+    "@contember/graphql-utils": "^1.0.0-alpha.2",
+    "@contember/schema": "^1.0.0-alpha.2",
+    "@contember/schema-utils": "^1.0.0-alpha.2",
     "@graphql-tools/schema": "^7.1.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^0.12.0-beta.1",
-    "@contember/engine-api-tester": "^0.12.0-beta.1",
-    "@contember/schema-definition": "^0.12.0-beta.1",
+    "@contember/database-tester": "^1.0.0-alpha.2",
+    "@contember/engine-api-tester": "^1.0.0-alpha.2",
+    "@contember/schema-definition": "^1.0.0-alpha.2",
     "@graphql-codegen/cli": "^1.15.2",
     "@graphql-codegen/typescript": "^1.15.2",
     "@graphql-codegen/typescript-operations": "^1.15.2",
     "@graphql-codegen/typescript-resolvers": "^1.15.2",
-    "@types/node": "^15.12.5",
+    "@types/node": "^17.0.5",
     "graphql": "^15.4.0",
     "pg": "^8.5.0",
     "uvu": "^0.5.1"

package/src/acl/PermissionFactory.ts

@@ -106,6 +106,9 @@ export class PermissionFactory {
 	private mergeEntityPermissions(left: Acl.EntityPermissions, right: Acl.EntityPermissions): Acl.EntityPermissions {
 		let predicates: Acl.PredicateMap = {}
 		const operations: Acl.EntityOperations = {}
+		if (left.operations.customPrimary || right.operations.customPrimary) {
+			operations.customPrimary = true
+		}
 
 		const operationNames: (keyof Pick<Acl.EntityOperations, 'create' | 'read' | 'update'>)[] = [
 			'create',

package/src/acl/VariableUtils.ts

@@ -1,17 +1,41 @@
 import { Acl } from '@contember/schema'
+import { getRoleVariables } from '@contember/schema-utils'
 
 type Memberships = readonly { role: string; variables: readonly { name: string; values: readonly string[] }[] }[]
 
-export const flattenVariables = (memberships: Memberships): Acl.VariablesMap => {
-	return memberships.reduce(
-		(acc, membership) => ({
-			...acc,
-			...membership.variables.reduce(
-				(acc, { name, values }) => ({ ...acc, [prefixVariable(membership.role, name)]: values }),
-				{},
-			),
-		}),
-		{},
+export const createAclVariables = (
+	aclSchema: Acl.Schema,
+	identity: {
+		identityId: string
+		personId: string | null
+		memberships: Memberships
+	},
+): Acl.VariablesMap => {
+
+	const variablesEntries = identity.memberships.flatMap(
+		membership => {
+			const roleVariables = getRoleVariables(membership.role, aclSchema)
+			const membershipVariablesMap = Object.fromEntries(membership.variables.map(it => [it.name, it.values]))
+
+			return Object.entries(roleVariables).map(([name, def]) => {
+				const prefixed = prefixVariable(membership.role, name)
+
+				switch (def.type) {
+					case Acl.VariableType.entity:
+						return [prefixed, membershipVariablesMap[name] ?? []]
+					case Acl.VariableType.predefined:
+						switch (def.value) {
+							case 'identityID':
+								return [prefixed, [identity.identityId]]
+							case 'personID':
+								return [prefixed, identity.personId ? [identity.personId] : []]
+						}
+				}
+			})
+		},
 	)
+
+	return Object.fromEntries(variablesEntries)
 }
+
 export const prefixVariable = (role: string, variableName: string) => `${role}__${variableName}`

package/src/bridges/system/index.ts

@@ -1,2 +1 @@
-export * from './ContentEventApplier'
 export * from './EntitiesSelector'

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

@@ -141,6 +141,10 @@ export type _ValidatorArgument = {
 export type ResolverTypeWrapper<T> = Promise<T> | T
 
 
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
+}
+
 export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
 	fragment: string
 	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
@@ -153,6 +157,7 @@ export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
 export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>
 export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
   | ResolverFn<TResult, TParent, TContext, TArgs>
+  | ResolverWithResolve<TResult, TParent, TContext, TArgs>
   | StitchingResolver<TResult, TParent, TContext, TArgs>
 
 export type ResolverFn<TResult, TParent, TContext, TArgs> = (

package/src/mapper/ColumnValue.ts

@@ -22,7 +22,7 @@ export const resolveGenericValue = <T>(value: Value.GenericValueLike<T>): Promis
 export const resolveRowData = async <E>(
 	values: ColumnValue<E>[],
 ): Promise<ResolvedColumnValue<Exclude<E, undefined>>[]> => {
-	const valuePromises = values.map(async it => ({ ...it, resolvedValue: await it.value }))
+	const valuePromises = values.map(async (it): Promise<ResolvedColumnValue<E | undefined>> => ({ ...it, resolvedValue: await it.value }))
 	const settledValues = await Promise.allSettled(valuePromises)
 	const failed = getRejections(settledValues)
 	if (failed.length > 0) {

package/src/mapper/ErrorUtils.ts

@@ -11,64 +11,87 @@ import {
 import * as Database from '@contember/database'
 import { UniqueWhereError } from '../inputProcessing'
 import { Model } from '@contember/schema'
-import { ResolvedColumnValue } from './ColumnValue'
-import { isOwningRelation, NamingHelper } from '@contember/schema-utils'
+import { isOwningRelation, isRelation, NamingHelper } from '@contember/schema-utils'
 import RelationType = Model.RelationType
 
-export class EnrichedError {
-	constructor(
-		public readonly entity: Model.Entity,
-		public readonly values: ResolvedColumnValue[] | null,
-		public readonly originalError: any,
-	) {}
-}
 
-const findConstraint = (entity: Model.Entity, constraintName: string): Model.UniqueConstraint | null => {
-	for (const constraint of Object.values(entity.unique)) {
-		if (constraint.name === constraintName) {
-			return constraint
+const findUniqueConstraint = (schema: Model.Schema, constraintName: string): [Model.Entity, Model.UniqueConstraint] | [null, null] => {
+	for (const entity of Object.values(schema.entities)) {
+		for (const constraint of Object.values(entity.unique)) {
+			if (constraint.name === constraintName) {
+				return [entity, constraint]
+			}
 		}
 	}
-	for (const field of Object.values(entity.fields)) {
-		if (
-			field.type === RelationType.OneHasOne &&
-			isOwningRelation(field) &&
-			NamingHelper.createUniqueConstraintName(entity.name, [field.name]) === constraintName
-		) {
-			return { name: constraintName, fields: [field.name] }
+	for (const entity of Object.values(schema.entities)) {
+		for (const field of Object.values(entity.fields)) {
+			if (
+				field.type === RelationType.OneHasOne &&
+				isOwningRelation(field) &&
+				NamingHelper.createUniqueConstraintName(entity.name, [field.name]) === constraintName
+			) {
+				return [entity, { name: constraintName, fields: [field.name] }]
+			}
 		}
 	}
-	return null
+	return [null, null]
+}
+
+type RelationInfo = {
+	owningEntity: Model.Entity
+	owningRelation: Model.Relation
+	targetEntity: Model.Entity
 }
 
-export const convertError = (e: any): MutationResult => {
-	let entity: Model.Entity | null = null
-	let values: ResolvedColumnValue[] | null = null
-	if (e instanceof EnrichedError) {
-		entity = e.entity
-		values = e.values
-		e = e.originalError
+const findForeignConstraint = (schema: Model.Schema, constraintName: string): RelationInfo | null => {
+	for (const owningEntity of Object.values(schema.entities)) {
+		for (const field of Object.values(owningEntity.fields)) {
+			if (!isRelation(field) || !isOwningRelation(field) || !('joiningColumn' in field)) {
+				continue
+			}
+			const targetEntity = schema.entities[field.target]
+			const fkName = NamingHelper.createForeignKeyName(
+				owningEntity.tableName,
+				field.joiningColumn.columnName,
+				targetEntity.tableName,
+				targetEntity.primaryColumn,
+			)
+			if (fkName === constraintName) {
+				return { owningEntity, targetEntity, owningRelation: field }
+			}
+		}
 	}
+	return null
+}
+
+export const convertError = (schema: Model.Schema, e: any): MutationResult => {
+
 	if (e instanceof Database.NotNullViolationError) {
 		return new MutationConstraintViolationError([], ConstraintType.notNull, e.originalMessage, [
 			MutationResultHint.sqlError,
 		])
 	}
 	if (e instanceof Database.ForeignKeyViolationError) {
-		return new MutationConstraintViolationError([], ConstraintType.foreignKey, e.originalMessage, [
-			MutationResultHint.sqlError,
-		])
+		const relationInfo = e.constraint ? findForeignConstraint(schema, e.constraint) : null
+		const violationDetail: string = 'detail' in e.previous ? e.previous.detail : ''
+		const matchResult = violationDetail.match(/^Key \(.+\)=\((.+)\) is still referenced from table/)
+		const message = relationInfo
+			? `Cannot delete ${matchResult ? `row ${matchResult[1]}` : 'unknown row'}`
+				+ ` of entity ${relationInfo.targetEntity.name},`
+				+ ` because it is still referenced from ${relationInfo.owningEntity.name}::${relationInfo.owningRelation.name}.`
+				+ ' This is possibly caused by ACL denial or by missing "on delete cascade"'
+			: e.originalMessage
+		return new MutationConstraintViolationError([], ConstraintType.foreignKey, message, [MutationResultHint.sqlError])
 	}
 	if (e instanceof Database.UniqueViolationError) {
-		const constraint = entity && e.constraint ? findConstraint(entity, e.constraint) : null
-		const valuesInConstraint = constraint
-			? constraint.fields.map(it => values?.find(v => v.fieldName === it)?.resolvedValue)
-			: []
-		const message = constraint
-			? `Value (${valuesInConstraint.map(it => JSON.stringify(it)).join(', ')})` +
-			  ` of unique constraint (${constraint.fields.join(', ')}) already exists`
+		const [entity, constraint] = e.constraint ? findUniqueConstraint(schema, e.constraint) : [null, null]
+		const violationDetail: string = 'detail' in e.previous ? e.previous.detail : ''
+		const matchResult = violationDetail.match(/^Key \(.+\)=\((.+)\) already exists\.$/)
+		const values = matchResult?.[1]
+		const message = constraint && entity
+			? `${values ? `Value (${values})` : 'Unknown value'}` +
+			  ` already exists in unique columns (${constraint.fields.join(', ')}) on entity ${entity.name}`
 			: e.originalMessage
-
 		const paths = constraint ? constraint.fields.map(it => [{ field: it }]) : []
 		return new MutationConstraintViolationError(paths, ConstraintType.uniqueKey, message, [MutationResultHint.sqlError])
 	}
@@ -92,10 +115,10 @@ export const convertError = (e: any): MutationResult => {
 	throw e
 }
 
-export const tryMutation = async (cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
+export const tryMutation = async (schema: Model.Schema, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
 	try {
 		return await cb()
 	} catch (e) {
-		return [convertError(e)]
+		return [convertError(schema, e)]
 	}
 }

package/src/mapper/Mapper.ts

@@ -163,7 +163,7 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(() =>
+		return tryMutation(this.schema, () =>
 			this.inserter.insert(this, entity, data, id => {
 				const where = { [entity.primary]: id }
 				this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
@@ -180,7 +180,7 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(async () => {
+		return tryMutation(this.schema, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return [new MutationEntryNotFoundError([], by)]
@@ -195,7 +195,7 @@ export class Mapper {
 		predicateFields: string[],
 		builderCb: (builder: UpdateBuilder) => void,
 	): Promise<MutationResultList> {
-		return tryMutation(async () => {
+		return tryMutation(this.schema, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return [new MutationEntryNotFoundError([], by)]
@@ -214,7 +214,7 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(async () => {
+		return tryMutation(this.schema, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return await this.inserter.insert(this, entity, create, id => {
@@ -234,7 +234,7 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(() => this.deleteExecutor.execute(this, entity, by, filter))
+		return tryMutation(this.schema, () => this.deleteExecutor.execute(this, entity, by, filter))
 	}
 
 	public async connectJunction(

package/src/mapper/Result.ts

@@ -177,10 +177,12 @@ export class MutationEntryNotFoundError implements MutationResultInterface {
 // possibly denied by acl
 export class MutationNoResultError implements MutationResultInterface {
 	result = MutationResultType.noResultError as const
-	hints: MutationResultHint[] = []
-	message = undefined
 
-	constructor(public readonly paths: Path[]) {}
+	constructor(
+		public readonly paths: Path[],
+		public readonly message?: string,
+		public readonly hints: MutationResultHint[] = [],
+	) {}
 }
 
 export const prependPath = (path: Path, results: MutationResultList): MutationResultList =>
@@ -207,6 +209,7 @@ export const flattenResult = (result: (MutationResultList | MutationResultList[]
 export type ResultListNotFlatten = MutationResultList | MutationResultList[]
 
 export const collectResults = async (
+	schema: Model.Schema,
 	mainPromise: Promise<ResultListNotFlatten | undefined> | undefined,
 	otherPromises: (Promise<ResultListNotFlatten | undefined> | undefined)[],
 ): Promise<MutationResultList> => {
@@ -215,7 +218,7 @@ export const collectResults = async (
 		.filter((it): it is Promise<ResultListNotFlatten> => !!it)
 		.map(it =>
 			it //
-				.catch(e => [convertError(e)])
+				.catch(e => [convertError(schema, e)])
 				.then(value => ({ value, index: index++ })),
 		)
 	const results = await Promise.allSettled(allPromises)

package/src/mapper/delete/DeleteExecutor.ts

@@ -10,6 +10,7 @@ import {
 	MutationEntryNotFoundError,
 	MutationNoResultError,
 	MutationNothingToDo,
+	MutationResultHint,
 	MutationResultList,
 	NothingToDoReason,
 } from '../Result'
@@ -35,7 +36,6 @@ export class DeleteExecutor {
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		return mapper.mutex.execute(async () => {
-			const db = mapper.db
 			await mapper.constraintHelper.setFkConstraintsDeferred()
 			const primaryValue = await mapper.getPrimaryValue(entity, by)
 			if (!primaryValue) {
@@ -50,15 +50,8 @@ export class DeleteExecutor {
 				return [new MutationNoResultError([])]
 			}
 
-			try {
-				await mapper.constraintHelper.setFkConstraintsImmediate()
-				return [new MutationDeleteOk([], entity, primaryValue)]
-			} catch (e) {
-				if (e instanceof ForeignKeyViolationError) {
-					return [new MutationNoResultError([])]
-				}
-				throw e
-			}
+			await mapper.constraintHelper.setFkConstraintsImmediate()
+			return [new MutationDeleteOk([], entity, primaryValue)]
 		})
 	}
 

package/src/mapper/insert/InsertBuilder.ts

@@ -5,7 +5,6 @@ import { getColumnName, getColumnType } from '@contember/schema-utils'
 import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
 import { ImplementationException } from '../../exception'
 import { AbortInsert } from './Inserter'
-import { EnrichedError } from '../ErrorUtils'
 
 export interface InsertResult {
 	values: ResolvedColumnValue[]
@@ -49,9 +48,10 @@ export class InsertBuilder {
 		try {
 			const resolvedData = await this.getResolvedData()
 			if (resolvedData.find(it => it.resolvedValue === AbortInsert)) {
+				this.resolver(null)
 				return { aborted: true, executed: false, primaryValue: null, values: [] }
 			}
-			resolvedDataFinal = resolvedData as ResolvedColumnValue[]
+
 			const insertData = resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
 				(result, item) => ({ ...result, [item.columnName]: expr => expr.select(['root_', item.columnName]) }),
 				{},
@@ -78,7 +78,7 @@ export class InsertBuilder {
 			return { values: resolvedData as ResolvedColumnValue[], executed: true, primaryValue: result, aborted: false }
 		} catch (e) {
 			this.resolver(null)
-			throw new EnrichedError(this.entity, resolvedDataFinal, e)
+			throw e
 		}
 	}
 }

package/src/mapper/insert/Inserter.ts

@@ -55,7 +55,7 @@ export class Inserter {
 			new MutationCreateOk([], entity, primary, data, values)
 		const insertPromise = this.executeInsert(insertBuilder, mapper.db, okResultFactory)
 
-		return await collectResults(insertPromise, Object.values(promises))
+		return await collectResults(this.schema, insertPromise, Object.values(promises))
 	}
 
 	private async executeInsert(
@@ -63,7 +63,7 @@ export class Inserter {
 		db: Client,
 		okResultFactory: (primary: Value.PrimaryValue, values: RowValues) => MutationCreateOk,
 	): Promise<MutationResultList> {
-		return tryMutation(async () => {
+		return tryMutation(this.schema, async () => {
 			const result = await insertBuilder.execute(db)
 			if (result.aborted) {
 				return [new MutationNothingToDo([], NothingToDoReason.aborted)]

package/src/mapper/update/UpdateBuilder.ts

@@ -5,7 +5,6 @@ import { Client, Operator, QueryBuilder, UpdateBuilder as DbUpdateBuilder, Value
 import { PathFactory, WhereBuilder } from '../select'
 import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
 import { AbortUpdate } from './Updater'
-import { EnrichedError } from '../ErrorUtils'
 
 export interface UpdateResult {
 	values: ResolvedColumnValue[]
@@ -61,9 +60,9 @@ export class UpdateBuilder {
 				return { values: [], affectedRows: null, executed: false, aborted: false }
 			}
 			if (resolvedData.find(it => it.resolvedValue === AbortUpdate)) {
+				this.resolver(null)
 				return { values: [], affectedRows: null, executed: false, aborted: true }
 			}
-			resolvedDataFinal = resolvedData as ResolvedColumnValue[]
 
 			const qb = DbUpdateBuilder.create()
 				.with('newData_', qb => {
@@ -120,7 +119,7 @@ export class UpdateBuilder {
 			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result, executed: true, aborted: false }
 		} catch (e) {
 			this.resolver(null)
-			throw new EnrichedError(this.entity, resolvedDataFinal, e)
+			throw e
 		}
 	}
 }

package/src/mapper/update/Updater.ts

@@ -52,7 +52,7 @@ export class Updater {
 		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, data, values)
 		const mutationResultPromise = Updater.executeUpdate(updateBuilder, mapper.db, okResultFactory)
 
-		return await collectResults(mutationResultPromise, Object.values(promises))
+		return await collectResults(this.schema, mutationResultPromise, Object.values(promises))
 	}
 
 	public async updateCb(

package/src/resolvers/ExecutionContainerFactory.ts

@@ -64,7 +64,7 @@ export class ExecutionContainerFactory {
 			.addService('inputPreValidator', ({ entityRulesResolver, columnValueResolver, dataSelector }) =>
 				new InputPreValidator(this.schema.model, entityRulesResolver, columnValueResolver, dataSelector))
 			.addService('mutationResolver', ({ db, mapperFactory, inputPreValidator, queryAstFactory }) =>
-				new MutationResolver(db, mapperFactory, this.setupSystemVariables, inputPreValidator, queryAstFactory))
+				new MutationResolver(this.schema.model, db, mapperFactory, this.setupSystemVariables, inputPreValidator, queryAstFactory))
 			.addService('validationResolver', ({ inputPreValidator, db, mapperFactory }) =>
 				new ValidationResolver(db, mapperFactory, inputPreValidator))
 			.build()

package/src/resolvers/MutationResolver.ts

@@ -8,7 +8,7 @@ import {
 	MapperFactory,
 	MutationResultHint,
 	MutationResultList,
-	MutationResultType,
+	MutationResultType, tryMutation,
 } from '../mapper'
 import { ValidationResolver } from './ValidationResolver'
 import { GraphQLResolveInfo } from 'graphql'
@@ -23,8 +23,11 @@ import { executeReadOperations } from './ReadHelpers'
 
 type WithoutNode<T extends { node: any }> = Pick<T, Exclude<keyof T, 'node'>>
 
+type TransactionOptions = { deferForeignKeyConstraints?: boolean }
+
 export class MutationResolver {
 	constructor(
+		private readonly schema: Model.Schema,
 		private readonly db: Client,
 		private readonly mapperFactory: MapperFactory,
 		private readonly systemVariablesSetup: (db: Client) => Promise<void>,
@@ -32,7 +35,7 @@ export class MutationResolver {
 		private readonly graphqlQueryAstFactory: GraphQlQueryAstFactory,
 	) {}
 
-	public async resolveTransaction(info: GraphQLResolveInfo): Promise<Result.TransactionResult> {
+	public async resolveTransaction(info: GraphQLResolveInfo, options: TransactionOptions): Promise<Result.TransactionResult> {
 		const queryAst = this.graphqlQueryAstFactory.create(info, (node, path) => {
 			return (
 				(path.length === 1 && !['ok', 'validation', 'errorMessage', 'errors'].includes(node.name.value)) ||
@@ -57,6 +60,9 @@ export class MutationResolver {
 			}))
 
 		return this.transaction(async (mapper, trx) => {
+			if (options?.deferForeignKeyConstraints) {
+				await mapper.constraintHelper.setFkConstraintsDeferred()
+			}
 			const validationResult: Record<string, Result.MutationFieldResult> = {}
 			const validationErrors: Result.ValidationError[] = []
 			for (const field of queryAst.fields) {
@@ -181,6 +187,16 @@ export class MutationResolver {
 				}
 				trxResult[field.alias] = result
 			}
+			if (options?.deferForeignKeyConstraints) {
+				const constraintsResult = await tryMutation(this.schema, async () => {
+					await mapper.constraintHelper.setFkConstraintsImmediate()
+					return []
+				})
+				const errorResponse = this.createErrorResponse(constraintsResult)
+				if (errorResponse) {
+					return { ...errorResponse, ...validationResult }
+				}
+			}
 
 			return { ok: true, errors: [], validation: { valid: true, errors: [] }, ...trxResult }
 		})

package/src/schema/GraphQlSchemaBuilder.ts

@@ -4,7 +4,7 @@ import {
 	GraphQLNonNull,
 	GraphQLObjectType,
 	GraphQLSchema,
-	GraphQLString,
+	GraphQLString, GraphQLInputObjectType,
 } from 'graphql'
 import { Model } from '@contember/schema'
 import { MutationProvider } from './MutationProvider'
@@ -59,6 +59,16 @@ export class GraphQlSchemaBuilder {
 		})
 		if (mutations.size > 0) {
 			mutations.set('transaction', {
+				args: {
+					options: {
+						type: new GraphQLInputObjectType({
+							name: 'MutationTransactionOptions',
+							fields: {
+								deferForeignKeyConstraints: { type: GraphQLBoolean },
+							},
+						}),
+					},
+				},
 				type: new GraphQLNonNull(
 					new GraphQLObjectType({
 						name: 'MutationTransaction',
@@ -76,9 +86,11 @@ export class GraphQlSchemaBuilder {
 						},
 					}),
 				),
-				resolve: async (parent, args, context: Context, info) => {
+				resolve: async (parent, args: { options?: { deferForeignKeyConstraints?: boolean } }, context: Context, info) => {
 					return context.timer(`GraphQL.mutation.${info.fieldName}`, () =>
-						context.executionContainer.mutationResolver.resolveTransaction(info),
+						context.executionContainer.mutationResolver.resolveTransaction(info, {
+							deferForeignKeyConstraints: args.options?.deferForeignKeyConstraints ?? false,
+						}),
 					)
 				},
 			})

package/tests/cases/integration/graphQlDb/update/bug-freeze-connect-missing-one.test.ts

@@ -0,0 +1,46 @@
+import { test } from 'uvu'
+import { SchemaDefinition as def } from '@contember/schema-definition'
+import { GQL } from '../../../../src/tags'
+import { executeDbTest } from '@contember/engine-api-tester'
+
+namespace Model {
+	@def.Unique('url')
+	export class Url {
+		url = def.stringColumn().notNull()
+		redirect: def.OneHasOneDefinition = def.oneHasOne(Redirect, 'url').setNullOnDelete().removeOrphan()
+	}
+
+	export class Redirect {
+		url = def.oneHasOneInverse(Url, 'redirect').notNull()
+
+		internalUrl = def.manyHasOne(Url)
+	}
+}
+test('create redirect to non-existing target', async () => {
+	await executeDbTest({
+		schema: def.createModel(Model),
+		query: GQL`
+		mutation {
+  createRedirect(
+    data: {
+      internalUrl: {connect: {url: "abcd"}},
+      url: {create: {url: "xyz"}}
+    }
+  ) {
+    ok
+    errorMessage
+  }
+}
+		`,
+		seed: [],
+		expectDatabase: {},
+		return: {
+			createRedirect: {
+				ok: false,
+				errorMessage: 'Execution has failed:\ninternalUrl: NotFoundOrDenied (for input {"url":"abcd"})',
+			},
+		},
+	})
+})
+
+test.run()