@contember/engine-content-api 1.3.0-alpha.6 → 1.3.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.3.0-alpha.6",
+  "version": "1.3.0-alpha.8",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -14,21 +14,21 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.3.0-alpha.6",
-    "@contember/dic": "^1.3.0-alpha.6",
-    "@contember/logger": "^1.3.0-alpha.6",
-    "@contember/graphql-utils": "^1.3.0-alpha.6",
-    "@contember/schema": "^1.3.0-alpha.6",
-    "@contember/schema-definition": "^1.3.0-alpha.6",
-    "@contember/schema-utils": "^1.3.0-alpha.6",
+    "@contember/database": "^1.3.0-alpha.8",
+    "@contember/dic": "^1.3.0-alpha.8",
+    "@contember/logger": "^1.3.0-alpha.8",
+    "@contember/graphql-utils": "^1.3.0-alpha.8",
+    "@contember/schema": "^1.3.0-alpha.8",
+    "@contember/schema-definition": "^1.3.0-alpha.8",
+    "@contember/schema-utils": "^1.3.0-alpha.8",
     "@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.6",
-    "@contember/engine-api-tester": "^1.3.0-alpha.6",
-    "@contember/schema-definition": "^1.3.0-alpha.6",
+    "@contember/database-tester": "^1.3.0-alpha.8",
+    "@contember/engine-api-tester": "^1.3.0-alpha.8",
+    "@contember/schema-definition": "^1.3.0-alpha.8",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

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/acl/PermissionFactory.ts

@@ -1,33 +1,35 @@
-import { Acl, Model, Writable } from '@contember/schema'
+import { Acl, Model, Schema, Writable } from '@contember/schema'
 import { getEntity, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { mapObject } from '../utils'
 import { prefixVariable } from './VariableUtils'
 
-export class PermissionFactory {
-	constructor(private readonly schema: Model.Schema) {}
+export interface Identity {
+	projectRoles: readonly string[]
+}
 
-	public create(acl: Acl.Schema, roles: readonly string[], prefix?: string): Acl.Permissions {
+export class PermissionFactory {
+	public create(schema: Schema, roles: readonly string[], prefix?: string): Acl.Permissions {
 		let result: Acl.Permissions = {}
 		for (let role of roles) {
-			const roleDefinition = acl.roles[role] || { entities: {} }
-			let rolePermissions: Acl.Permissions = this.prefixPredicatesWithRole(roleDefinition.entities, prefix || role)
+			const roleDefinition = schema.acl.roles[role] || { entities: {} }
+			let rolePermissions: Acl.Permissions = this.prefixPredicatesWithRole(schema.model, roleDefinition.entities, prefix || role)
 			if (roleDefinition.inherits) {
-				const inheritedPermissions = this.create(acl, roleDefinition.inherits, prefix || role)
+				const inheritedPermissions = this.create(schema, roleDefinition.inherits, prefix || role)
 				rolePermissions = this.mergePermissions(inheritedPermissions, rolePermissions)
 			}
 			result = this.mergePermissions(result, rolePermissions)
 		}
-		result = this.makePrimaryPredicatesUnionOfAllFields(result)
+		result = this.makePrimaryPredicatesUnionOfAllFields(schema.model, result)
 
 		return result
 	}
 
-	private prefixPredicatesWithRole(permissions: Acl.Permissions, role: string): Acl.Permissions {
+	private prefixPredicatesWithRole(model: Model.Schema, permissions: Acl.Permissions, role: string): Acl.Permissions {
 		return mapObject(permissions, ({ operations, predicates }, entityName) => ({
 			operations,
 			predicates: mapObject(predicates, predicate => {
-				const predicateDefinitionProcessor = new PredicateDefinitionProcessor(this.schema)
-				return predicateDefinitionProcessor.process(getEntity(this.schema, entityName), predicate, {
+				const predicateDefinitionProcessor = new PredicateDefinitionProcessor(model)
+				return predicateDefinitionProcessor.process(getEntity(model, entityName), predicate, {
 					handleColumn: ({ value }) => {
 						if (typeof value === 'string') {
 							return prefixVariable(role, value)
@@ -45,9 +47,9 @@ export class PermissionFactory {
 		}))
 	}
 
-	private makePrimaryPredicatesUnionOfAllFields(permissions: Acl.Permissions): Acl.Permissions {
+	private makePrimaryPredicatesUnionOfAllFields(model: Model.Schema, permissions: Acl.Permissions): Acl.Permissions {
 		return mapObject(permissions, (permission, entityName): Acl.EntityPermissions => {
-			const entity = getEntity(this.schema, entityName)
+			const entity = getEntity(model, entityName)
 			const entityPredicates: Writable<Acl.PredicateMap> = { ...permission.predicates }
 			const entityOperations: Writable<Acl.EntityOperations> = { ...permission.operations }
 

package/src/acl/index.ts

@@ -1,6 +1,5 @@
 export * from './Authorizator'
 export * from './PermissionFactory'
-export * from './PermissionsByIdentityFactory'
 export * from './PredicateFactory'
 export * from './PredicatesInjector'
 export * from './VariableInjector'

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/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/types.ts

@@ -6,5 +6,5 @@ export interface Context {
 	db: Client
 	identityVariables: Acl.VariablesMap
 	executionContainer: ExecutionContainer
-	timer: <T>(event: string, cb?: () => T) => Promise<T>
+	timer: <T>(event: string, cb: () => T) => T
 }

package/src/utils/index.ts

@@ -1,5 +1,4 @@
 export * from './accessor'
-export * from './arrays'
 export * from './assertNever'
 export * from './Interface'
 export * from './isIt'

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/query/acl/isNullAcl.test.ts

@@ -0,0 +1,77 @@
+import { AclDefinition as acl, createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { test } from 'vitest'
+import { execute } from '../../../../../src/test'
+import { GQL, SQL } from '../../../../../src/tags'
+import { PermissionFactory } from '../../../../../../src'
+import { testUuid } from '@contember/engine-api-tester'
+
+
+namespace RowPredicateSubset {
+	export const ownerRole = acl.createRole('owner')
+	export const personIdVariable = acl.createPredefinedVariable('personId', 'personID', ownerRole)
+
+	@acl.allow(ownerRole, {
+		read: true,
+		when: { resource: acl.canRead('item') },
+	})
+	export class Item {
+		resource = def.oneHasOne(Resource, 'item')
+	}
+
+	@acl.allow(ownerRole, {
+		read: true,
+		when: { owner: acl.canRead('resources') },
+	})
+	export class Resource {
+		item = def.oneHasOneInverse(Item, 'resource')
+		owner = def.manyHasOne(Person, 'resources')
+	}
+
+	@acl.allow(ownerRole, {
+		read: true,
+		when: { personId: personIdVariable },
+	})
+	export class Person {
+		personId = def.uuidColumn().notNull()
+		resources = def.oneHasMany(Resource, 'owner')
+	}
+}
+
+
+test('owner predicate with isNull', async () => {
+	const schema = createSchema(RowPredicateSubset)
+
+	const permissions = new PermissionFactory().create(schema, ['owner'])
+
+	await execute({
+		schema: schema.model,
+		permissions: permissions,
+		variables: {
+			owner__personId: { eq: testUuid(0) },
+		},
+		query: GQL`
+        query {
+          listItem(filter: {resource: {id: {isNull: true}}}) {
+          	id
+          }
+        }`,
+		executes: [
+			{
+				sql: SQL`select "root_"."id" as "root_id"  from "public"."item" as "root_" 
+    left join  "public"."resource" as "root_resource" on  "root_"."resource_id" = "root_resource"."id" 
+    left join  "public"."person" as "root_resource_owner" on  "root_resource"."owner_id" = "root_resource_owner"."id"  
+	where "root_resource"."id" is null and "root_resource_owner"."person_id" = ? and "root_resource_owner"."person_id" = ?`,
+				response: {
+					rows: [],
+				},
+			},
+		],
+		return: {
+			data: {
+				listItem: [],
+			},
+		},
+	})
+})
+
+

package/tests/cases/integration/graphQlRequests/query/acl/rowPredicateSubset.test.ts

@@ -37,7 +37,7 @@ namespace RowPredicateSubset {
 test('row level predicate includes main predicate', async () => {
 	const schema = createSchema(RowPredicateSubset)
 
-	const permissions = new PermissionFactory(schema.model).create(schema.acl, ['reader'])
+	const permissions = new PermissionFactory().create(schema, ['reader'])
 
 	await execute({
 		schema: schema.model,