@contember/engine-content-api 1.3.0-alpha.7 → 1.3.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.3.0-alpha.7",
+  "version": "1.3.0-beta.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -9,26 +9,25 @@
     "default": "./dist/src/index.js"
   },
   "scripts": {
-    "build-copy": "mkdir -p dist && find ./tests/ -name '*.gql' -type f -exec cp --parents {} ./dist \\;",
     "generate": "gql-gen --config graphql.codegen.yml",
-    "test": "vitest --no-threads"
+    "test": "vitest --dir ./tests/cases --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.3.0-alpha.7",
-    "@contember/dic": "^1.3.0-alpha.7",
-    "@contember/logger": "^1.3.0-alpha.7",
-    "@contember/graphql-utils": "^1.3.0-alpha.7",
-    "@contember/schema": "^1.3.0-alpha.7",
-    "@contember/schema-definition": "^1.3.0-alpha.7",
-    "@contember/schema-utils": "^1.3.0-alpha.7",
+    "@contember/database": "1.3.0-beta.1",
+    "@contember/dic": "1.3.0-beta.1",
+    "@contember/graphql-utils": "1.3.0-beta.1",
+    "@contember/logger": "1.3.0-beta.1",
+    "@contember/schema": "1.3.0-beta.1",
+    "@contember/schema-definition": "1.3.0-beta.1",
+    "@contember/schema-utils": "1.3.0-beta.1",
     "@graphql-tools/schema": "^8.3.5",
     "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.3.0-alpha.7",
-    "@contember/engine-api-tester": "^1.3.0-alpha.7",
-    "@contember/schema-definition": "^1.3.0-alpha.7",
+    "@contember/database-tester": "1.3.0-beta.1",
+    "@contember/engine-api-tester": "1.3.0-beta.1",
+    "@contember/schema-definition": "1.3.0-beta.1",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",
@@ -41,4 +40,4 @@
     "graphql": ">= 14.6.0",
     "pg": "^8.9.0"
   }
-}
+}

package/src/ExecutionContainer.ts

@@ -28,7 +28,7 @@ import {
 import { Builder } from '@contember/dic'
 import { Acl, Model, Schema } from '@contember/schema'
 import { Client, SelectBuilder as DbSelectBuilder } from '@contember/database'
-import { Providers } from '@contember/schema-utils'
+import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import { PaginatedHasManyExecutionHandler } from './extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
 import { PaginatedHasManyFieldProvider } from './extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
 import { WhereOptimizer } from './mapper/select/optimizer/WhereOptimizer'
@@ -44,6 +44,7 @@ import {
 
 export type ExecutionContainerArgs = {
 	schema: Schema & { id: number }
+	schemaDatabaseMetadata: SchemaDatabaseMetadata
 	db: Client
 	identityId: string
 	identityVariables: Acl.VariablesMap
@@ -75,7 +76,7 @@ export class ExecutionContainerFactory {
 		return this.hooks.reduce((acc, cb) => cb(acc), builder)
 	}
 
-	createBuilderInternal({ permissions, identityVariables, identityId, db, schema, systemSchema, stage, project }: ExecutionContainerArgs) {
+	createBuilderInternal({ permissions, identityVariables, identityId, db, schema, systemSchema, stage, project, schemaDatabaseMetadata }: ExecutionContainerArgs) {
 		return new Builder({})
 			.addService('systemSchema', () =>
 				systemSchema)
@@ -87,6 +88,8 @@ export class ExecutionContainerFactory {
 				stage)
 			.addService('schema', () =>
 				schema)
+			.addService('schemaDatabaseMetadata', () =>
+				schemaDatabaseMetadata)
 			.addService('providers', () =>
 				this.providers)
 			.addService('variableInjector', ({ schema }) =>
@@ -153,15 +156,16 @@ export class ExecutionContainerFactory {
 				new JunctionTableManager(schema.model, predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory))
 			.addService('deleteExecutor', ({ predicateFactory, updateBuilderFactory, whereBuilder, pathFactory, schema }) =>
 				new DeleteExecutor(schema.model, predicateFactory, whereBuilder, updateBuilderFactory, pathFactory))
-			.addService('updater', ({ predicateFactory, updateBuilderFactory, schema }) =>
-				new Updater(schema.model, predicateFactory, updateBuilderFactory))
-			.addService('inserter', ({  insertBuilderFactory, providers, schema }) =>
-				new Inserter(schema.model,  insertBuilderFactory, providers))
-			.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory, providers, schema }) => {
+			.addService('updater', ({ predicateFactory, updateBuilderFactory, schema, schemaDatabaseMetadata }) =>
+				new Updater(schema.model, schemaDatabaseMetadata, predicateFactory, updateBuilderFactory))
+			.addService('inserter', ({  insertBuilderFactory, providers, schema, schemaDatabaseMetadata }) =>
+				new Inserter(schema.model, schemaDatabaseMetadata, insertBuilderFactory, providers))
+			.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory, providers, schema, schemaDatabaseMetadata }) => {
 				return new MapperFactory(
 					db,
 					identityId,
 					schema.model,
+					schemaDatabaseMetadata,
 					predicatesInjector,
 					selectBuilderFactory,
 					uniqueWhereExpander,
@@ -191,8 +195,8 @@ export class ExecutionContainerFactory {
 				new EntityRulesResolver(schema.validation, schema.model))
 			.addService('inputPreValidator', ({ entityRulesResolver, columnValueResolver, dataSelector, schema }) =>
 				new InputPreValidator(schema.model, entityRulesResolver, columnValueResolver, dataSelector))
-			.addService('mutationResolver', ({ mapperFactory, inputPreValidator, queryAstFactory, schema }) =>
-				new MutationResolver(schema.model, mapperFactory, inputPreValidator, queryAstFactory))
+			.addService('mutationResolver', ({ mapperFactory, inputPreValidator, queryAstFactory, schema, schemaDatabaseMetadata }) =>
+				new MutationResolver(schema.model, mapperFactory, inputPreValidator, queryAstFactory, schemaDatabaseMetadata))
 			.addService('validationResolver', ({ inputPreValidator, mapperFactory }) =>
 				new ValidationResolver(mapperFactory, inputPreValidator))
 	}

package/src/mapper/ErrorUtils.ts

@@ -11,31 +11,37 @@ import {
 import * as Database from '@contember/database'
 import { UniqueWhereError } from '../inputProcessing'
 import { Model } from '@contember/schema'
-import { isOwningRelation, isRelation, NamingHelper } from '@contember/schema-utils'
+import { acceptFieldVisitor, SchemaDatabaseMetadata, tryGetColumnName } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
-import RelationType = Model.RelationType
 
 
-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]
-			}
-		}
+type UniqueConstraintResult = {
+	entity: Model.Entity
+	fields: string[]
+}
+
+const getEntityByTableName = (model: Model.Schema, tableName: string) => Object.values(model.entities).find(it => it.tableName === tableName)
+
+const findUniqueConstraint = (model: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, tableName: string, constraintName: string): UniqueConstraintResult | null => {
+	const constraint = databaseMetadata.getUniqueConstraint(tableName, constraintName)
+	if (!constraint) {
+		return null
 	}
-	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] }]
-			}
+	const entity = getEntityByTableName(model, constraint.tableName)
+	if (!entity) {
+		return null
+	}
+	const fieldsInConstraint: string[] = []
+	for (const field of Object.values(entity.fields)) {
+		const columnName = tryGetColumnName(model, entity, field.name)
+		if (columnName && constraint.columnNames.includes(columnName)) {
+			fieldsInConstraint.push(field.name)
 		}
 	}
-	return [null, null]
+	if (fieldsInConstraint.length === constraint.columnNames.length) {
+		return { entity, fields: fieldsInConstraint }
+	}
+	return null
 }
 
 type RelationInfo = {
@@ -44,28 +50,47 @@ type RelationInfo = {
 	targetEntity: Model.Entity
 }
 
-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 }
+const findForeignConstraint = (model: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, tableName: string, constraintName: string): RelationInfo | null => {
+	const constraint = databaseMetadata.getForeignKeyConstraint(tableName, constraintName)
+	if (!constraint) {
+		return null
+	}
+	const owningEntity = getEntityByTableName(model, constraint.fromTable)
+	if (!owningEntity) {
+		// todo m:n
+		return null
+	}
+
+	const targetEntity = getEntityByTableName(model, constraint.toTable)
+	if (!targetEntity) {
+		return null
+	}
+	for (const field of Object.values(owningEntity.fields)) {
+		const relation = acceptFieldVisitor<(Model.Relation & Model.JoiningColumnRelation) | null>(model, owningEntity, field, {
+			visitColumn: () => null,
+			visitOneHasOneInverse: () => null,
+			visitManyHasManyInverse: () => null,
+			visitManyHasManyOwning: () => null,
+			visitOneHasMany: () => null,
+			visitOneHasOneOwning: ({ relation }) => relation,
+			visitManyHasOne: ({ relation }) => relation,
+		})
+		if (relation && relation.joiningColumn.columnName === constraint.fromColumn) {
+			return {
+				owningEntity,
+				owningRelation: relation,
+				targetEntity,
 			}
 		}
 	}
 	return null
 }
 
-export const convertError = (schema: Model.Schema, e: any): MutationResult => {
+export const convertError = (
+	schema: Model.Schema,
+	databaseMetadata: SchemaDatabaseMetadata,
+	e: any,
+): MutationResult => {
 
 	if (e instanceof Database.NotNullViolationError) {
 		return new MutationConstraintViolationError([], ConstraintType.notNull, e.originalMessage, [
@@ -73,7 +98,7 @@ export const convertError = (schema: Model.Schema, e: any): MutationResult => {
 		])
 	}
 	if (e instanceof Database.ForeignKeyViolationError) {
-		const relationInfo = e.constraint ? findForeignConstraint(schema, e.constraint) : null
+		const relationInfo = e.constraint && e.table ? findForeignConstraint(schema, databaseMetadata, e.table, 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
@@ -85,13 +110,13 @@ export const convertError = (schema: Model.Schema, e: any): MutationResult => {
 		return new MutationConstraintViolationError([], ConstraintType.foreignKey, message, [MutationResultHint.sqlError])
 	}
 	if (e instanceof Database.UniqueViolationError) {
-		const [entity, constraint] = e.constraint ? findUniqueConstraint(schema, e.constraint) : [null, null]
+		const constraint = e.constraint && e.table ? findUniqueConstraint(schema, databaseMetadata, e.table, e.constraint) : 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
+		const message = constraint
 			? `${values ? `Value (${values})` : 'Unknown value'}` +
-			  ` already exists in unique columns (${constraint.fields.join(', ')}) on entity ${entity.name}`
+			  ` 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])
@@ -115,10 +140,10 @@ export const convertError = (schema: Model.Schema, e: any): MutationResult => {
 	throw e
 }
 
-export const tryMutation = async (schema: Model.Schema, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
+export const tryMutation = async (schema: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
 	try {
 		return await cb()
 	} catch (e) {
-		return [convertError(schema, e)]
+		return [convertError(schema, databaseMetadata, e)]
 	}
 }

package/src/mapper/Mapper.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
+import { acceptFieldVisitor, getColumnName, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import {
 	OrderByHelper,
 	PathFactory,
@@ -38,6 +38,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		public readonly identityId: string,
 		public readonly transactionId: string,
 		private readonly schema: Model.Schema,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,
@@ -181,7 +182,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			throw new ImplementationException()
 		}
 		await this.setupSystemVariables()
-		return tryMutation(this.schema, () =>
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, () =>
 			this.insertInternal(entity, data, builderCb),
 		)
 	}
@@ -196,7 +197,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			throw new ImplementationException()
 		}
 		await this.setupSystemVariables()
-		return tryMutation(this.schema, async () => {
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return [new MutationEntryNotFoundError([], by)]
@@ -214,7 +215,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			throw new ImplementationException()
 		}
 		await this.setupSystemVariables()
-		return tryMutation(this.schema, async () => {
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
@@ -233,7 +234,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			throw new ImplementationException()
 		}
 		await this.setupSystemVariables()
-		return tryMutation(this.schema, async () => {
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return await this.insertInternal(entity, create)
@@ -258,7 +259,9 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 			throw new ImplementationException()
 		}
 		await this.setupSystemVariables()
-		return tryMutation(this.schema, () => this.deleteExecutor.execute(this, entity, by, filter))
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, () => {
+			return this.deleteExecutor.execute(this, entity, by, filter)
+		})
 	}
 
 	public async connectJunction(

package/src/mapper/MapperFactory.ts

@@ -8,7 +8,7 @@ import { Inserter } from './insert'
 import { Model } from '@contember/schema'
 import { Client, Connection } from '@contember/database'
 import { Mapper } from './Mapper'
-import { Providers } from '@contember/schema-utils'
+import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 export type MapperFactoryHook = (mapper: Mapper) => void
 
@@ -20,6 +20,7 @@ export class MapperFactory {
 		private readonly db: Client,
 		private readonly identityId: string,
 		private readonly schema: Model.Schema,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,
@@ -51,6 +52,7 @@ export class MapperFactory {
 			this.identityId,
 			this.providers.uuid(),
 			this.schema,
+			this.schemaDatabaseMetadata,
 			this.predicatesInjector,
 			this.selectBuilderFactory,
 			this.uniqueWhereExpander,

package/src/mapper/Result.ts

@@ -3,6 +3,7 @@ import { convertError } from './ErrorUtils'
 import { getFulfilledValues, getRejections } from '../utils'
 import { SerializationFailureError } from '@contember/database'
 import { logger } from '@contember/logger'
+import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -212,6 +213,7 @@ export type ResultListNotFlatten = MutationResultList | MutationResultList[]
 
 export const collectResults = async (
 	schema: Model.Schema,
+	schemaDatabaseMetadata: SchemaDatabaseMetadata,
 	mainPromise: Promise<ResultListNotFlatten | undefined> | undefined,
 	otherPromises: (Promise<ResultListNotFlatten | undefined> | undefined)[],
 ): Promise<MutationResultList> => {
@@ -220,7 +222,7 @@ export const collectResults = async (
 		.filter((it): it is Promise<ResultListNotFlatten> => !!it)
 		.map(it =>
 			it //
-				.catch(e => [convertError(schema, e)])
+				.catch(e => [convertError(schema, schemaDatabaseMetadata, e)])
 				.then(value => ({ value, index: index++ })),
 		)
 	const results = await Promise.allSettled(allPromises)

package/src/mapper/delete/DeleteExecutor.ts

@@ -169,6 +169,10 @@ export class DeleteExecutor {
 		}
 		const owningRelations = findOwningRelations(this.schema, entity)
 		for (const [owningEntity, relation] of owningRelations) {
+			if (owningEntity.view) {
+				continue
+			}
+
 			if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
 				await this.collectRestrictResult(state, mapper, owningEntity, relation, values)
 			} else if (relation.joiningColumn.onDelete === Model.OnDelete.cascade) {

package/src/mapper/insert/Inserter.ts

@@ -11,9 +11,8 @@ import { CreateInputVisitor } from '../../inputProcessing'
 import { SqlCreateInputProcessor } from './SqlCreateInputProcessor'
 import { Mapper } from '../Mapper'
 import { Input, Model, Value } from '@contember/schema'
-import { acceptEveryFieldVisitor, Providers } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor, Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import { InsertBuilderFactory } from './InsertBuilderFactory'
-import { Client } from '@contember/database'
 import { InsertBuilder } from './InsertBuilder'
 import { tryMutation } from '../ErrorUtils'
 import { rowDataToFieldValues } from '../ColumnValue'
@@ -21,6 +20,7 @@ import { rowDataToFieldValues } from '../ColumnValue'
 export class Inserter {
 	constructor(
 		private readonly schema: Model.Schema,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly insertBuilderFactory: InsertBuilderFactory,
 		private readonly providers: Providers,
 	) {}
@@ -53,7 +53,7 @@ export class Inserter {
 			new MutationCreateOk([], entity, primary, data, values)
 		const insertPromise = this.executeInsert(insertBuilder, mapper, okResultFactory)
 
-		return await collectResults(this.schema, insertPromise, Object.values(promises))
+		return await collectResults(this.schema, this.schemaDatabaseMetadata, insertPromise, Object.values(promises))
 	}
 
 	private async executeInsert(
@@ -61,7 +61,7 @@ export class Inserter {
 		mapper: Mapper,
 		okResultFactory: (primary: Value.PrimaryValue, values: RowValues) => MutationCreateOk,
 	): Promise<MutationResultList> {
-		return tryMutation(this.schema, async () => {
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const result = await insertBuilder.execute(mapper)
 			if (result.aborted) {
 				return [new MutationNothingToDo([], NothingToDoReason.aborted)]

package/src/mapper/update/Updater.ts

@@ -4,7 +4,7 @@ import { Input, Model } from '@contember/schema'
 import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
-import { acceptEveryFieldVisitor } from '@contember/schema-utils'
+import { acceptEveryFieldVisitor, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import {
 	collectResults,
 	MutationNoResultError,
@@ -21,6 +21,7 @@ import { rowDataToFieldValues } from '../ColumnValue'
 export class Updater {
 	constructor(
 		private readonly schema: Model.Schema,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly predicateFactory: PredicateFactory,
 		private readonly updateBuilderFactory: UpdateBuilderFactory,
 	) {}
@@ -50,7 +51,7 @@ export class Updater {
 		if (otherPromises.length === 0) {
 			return await mutationResultPromise
 		} else {
-			return await collectResults(this.schema, mutationResultPromise, otherPromises)
+			return await collectResults(this.schema, this.schemaDatabaseMetadata, mutationResultPromise, otherPromises)
 		}
 	}
 

package/src/resolvers/MutationResolver.ts

@@ -23,6 +23,7 @@ import { InputPreValidator } from '../input-validation'
 import { ObjectNode } from '../inputProcessing'
 import { executeReadOperations } from './ReadHelpers'
 import { logger } from '@contember/logger'
+import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 type WithoutNode<T extends { node: any }> = Pick<T, Exclude<keyof T, 'node'>>
 
@@ -34,6 +35,7 @@ export class MutationResolver {
 		private readonly mapperFactory: MapperFactory,
 		private readonly inputValidator: InputPreValidator,
 		private readonly graphqlQueryAstFactory: GraphQlQueryAstFactory,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 	) {}
 
 	public async resolveTransaction(info: GraphQLResolveInfo, options: TransactionOptions): Promise<Result.TransactionResult> {
@@ -196,7 +198,7 @@ export class MutationResolver {
 			}
 			if (options?.deferForeignKeyConstraints) {
 				logger.debug('MutationResolver: validating fk constraints')
-				const constraintsResult = await tryMutation(this.schema, async () => {
+				const constraintsResult = await tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 					await mapper.constraintHelper.setFkConstraintsImmediate()
 					return []
 				})

package/src/utils/uniqueWhereFields.ts

@@ -15,5 +15,5 @@ export const getFieldsForUniqueWhere = (schema: Model.Schema, entity: Model.Enti
 		}),
 	).filter((it): it is [string] => !!it)
 
-	return [[entity.primary], ...Object.values(entity.unique).map(it => it.fields), ...relations]
+	return [[entity.primary], ...entity.unique.map(it => it.fields), ...relations]
 }

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

@@ -1,6 +1,6 @@
 import { test } from 'vitest'
 import { execute, failedTransaction, sqlTransaction } from '../../../../src/test'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { createSchema, SchemaBuilder, SchemaDefinition as def } from '@contember/schema-definition'
 import { Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../src/tags'
 import { testUuid } from '../../../../src/testUuid'
@@ -100,3 +100,56 @@ test('delete author with restrict on posts - declined', async () => {
 	})
 })
 
+
+namespace DeleteModelView {
+	export class Author {
+		name = def.stringColumn()
+		stats = def.oneHasOneInverse(AuthorStats, 'author')
+	}
+
+	@def.View('SELECT 1') // not important here
+	export class AuthorStats {
+		author = def.oneHasOne(Author, 'stats')
+		postCount = def.intColumn().notNull()
+	}
+}
+
+test('delete author with restrict on a view - should be ignored', async () => {
+	const schema = createSchema(DeleteModelView)
+	await execute({
+		schema: schema.model,
+		query: GQL`
+        mutation {
+          deleteAuthor(by: {id: "${testUuid(1)}"}) {
+            ok
+          }
+        }`,
+		executes: [
+			...sqlTransaction([
+				{
+					sql: SQL`select "root_"."id" from "public"."author" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
+				{
+					sql: SQL`select "root_"."id" as "id", true as "allowed" from "public"."author" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1), allowed: true }] },
+				},
+				{
+					sql: SQL`delete from "public"."author" where "id" in (?)`,
+					parameters: [testUuid(1)],
+					response: { },
+				},
+			]),
+		],
+		return: {
+			data: {
+				deleteAuthor: {
+					ok: true,
+				},
+			},
+		},
+	})
+})
+

package/tests/cases/unit/orderbyHelper.test.ts

@@ -9,9 +9,9 @@ const entity: Model.Entity = {
 	primaryColumn: 'id',
 	tableName: 'foo',
 	fields: {},
-	unique: {},
+	unique: [],
 	eventLog: { enabled: true },
-	indexes: {},
+	indexes: [],
 }
 
 describe('order by helper', () => {

package/tests/src/test.ts

@@ -1,6 +1,6 @@
 import { Acl, Model, Schema, Validation } from '@contember/schema'
 import { Authorizator, GraphQlSchemaBuilderFactory, ExecutionContainerFactory } from '../../src'
-import { AllowAllPermissionFactory, emptySchema } from '@contember/schema-utils'
+import { AllowAllPermissionFactory, dummySchemaDatabaseMetadata, emptySchema } from '@contember/schema-utils'
 import { executeGraphQlTest } from './testGraphql'
 import { Client } from '@contember/database'
 import { createConnectionMock } from '@contember/database-tester'
@@ -111,6 +111,7 @@ export const execute = async (test: Test) => {
 					systemSchema: 'system',
 					stage: { id: '00000000-0000-0000-0000-000000000000', slug: 'live' },
 					project: { slug: 'test' },
+					schemaDatabaseMetadata: dummySchemaDatabaseMetadata,
 				}),
 			timer: (label: any, cb: any) => cb(),
 		},