@contember/engine-content-api 1.3.4 → 1.4.0-alpha.1

package/graphql.codegen.yml

@@ -1,5 +1,5 @@
 schema:
-  - "./src/introspection/content-schema.graphql.ts"
+  - "./src/introspection/IntrospectionSchemaDefinitionFactory.ts"
 documents: []
 config:
   immutableTypes: "1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.3.4",
+  "version": "1.4.0-alpha.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -13,21 +13,19 @@
     "test": "vitest --dir ./tests/cases --no-threads"
   },
   "dependencies": {
-    "@contember/database": "1.3.4",
-    "@contember/dic": "1.3.4",
-    "@contember/graphql-utils": "1.3.4",
-    "@contember/logger": "1.3.4",
-    "@contember/schema": "1.3.4",
-    "@contember/schema-definition": "1.3.4",
-    "@contember/schema-utils": "1.3.4",
-    "@graphql-tools/schema": "^8.3.5",
-    "fast-deep-equal": "^3.1.3",
-    "graphql-tag": "^2.12.5"
+    "@contember/database": "1.4.0-alpha.1",
+    "@contember/dic": "1.4.0-alpha.1",
+    "@contember/graphql-utils": "1.4.0-alpha.1",
+    "@contember/logger": "1.4.0-alpha.1",
+    "@contember/schema": "1.4.0-alpha.1",
+    "@contember/schema-definition": "1.4.0-alpha.1",
+    "@contember/schema-utils": "1.4.0-alpha.1",
+    "fast-deep-equal": "^3.1.3"
   },
   "devDependencies": {
-    "@contember/database-tester": "1.3.4",
-    "@contember/engine-api-tester": "1.3.4",
-    "@contember/schema-definition": "1.3.4",
+    "@contember/database-tester": "1.4.0-alpha.1",
+    "@contember/engine-api-tester": "1.4.0-alpha.1",
+    "@contember/schema-definition": "1.4.0-alpha.1",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/ExecutionContainer.ts

@@ -27,8 +27,8 @@ import {
 } from './mapper'
 import { Builder } from '@contember/dic'
 import { Acl, Model, Schema } from '@contember/schema'
-import { Client, SelectBuilder as DbSelectBuilder } from '@contember/database'
-import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { Client, DatabaseMetadata, SelectBuilder as DbSelectBuilder } from '@contember/database'
+import { Providers } from '@contember/schema-utils'
 import { PaginatedHasManyExecutionHandler } from './extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
 import { PaginatedHasManyFieldProvider } from './extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
 import { WhereOptimizer } from './mapper/select/optimizer/WhereOptimizer'
@@ -44,7 +44,7 @@ import {
 
 export type ExecutionContainerArgs = {
 	schema: Schema & { id: number }
-	schemaDatabaseMetadata: SchemaDatabaseMetadata
+	schemaDatabaseMetadata: DatabaseMetadata
 	db: Client
 	identityId: string
 	identityVariables: Acl.VariablesMap
@@ -107,13 +107,20 @@ export class ExecutionContainerFactory {
 			.addService('whereOptimized', ({ schema }) =>
 				new WhereOptimizer(schema.model, new ConditionOptimizer()))
 			.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema }) =>
-				new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema.settings.useExistsInHasManyFilter === true))
+				new WhereBuilder(
+					schema.model,
+					joinBuilder,
+					conditionBuilder,
+					pathFactory,
+					whereOptimized,
+					(schema.settings.content?.useExistsInHasManyFilter ?? schema.settings.useExistsInHasManyFilter) === true,
+				))
 			.addService('orderByBuilder', ({ joinBuilder, schema }) =>
 				new OrderByBuilder(schema.model, joinBuilder))
 			.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
 				new RelationFetcher(whereBuilder, orderByBuilder, predicatesInjector, pathFactory))
-			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, whereBuilder, schema }) =>
-				new FieldsVisitorFactory(schema.model, relationFetcher, predicateFactory, whereBuilder))
+			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, schema }) =>
+				new FieldsVisitorFactory(relationFetcher, predicateFactory, schema.settings.content ?? {}))
 			.addService('metaHandler', ({ whereBuilder, predicateFactory }) =>
 				new MetaHandler(whereBuilder, predicateFactory))
 			.addService('uniqueWhereExpander', ({ schema }) =>

package/src/extensions/EntityFieldsProvider.ts

@@ -2,7 +2,7 @@ import { GraphQLFieldConfig } from 'graphql'
 import { Model } from '@contember/schema'
 
 export interface EntityFieldsProvider<ExtensionArg extends object = {}> {
-	getFields(entity: Model.Entity, accessibleFields: string[]): FieldMap<ExtensionArg>
+	getFields(entity: Model.Entity, accessibleFields: Model.AnyField[]): FieldMap<ExtensionArg>
 }
 
 export type FieldMap<ExtensionArg extends object> = {

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducer.ts

@@ -11,11 +11,18 @@ export class HasManyToHasOneReducer implements EntityFieldsProvider<HasManyToHas
 		private readonly visitor: HasManyToHasOneRelationReducerFieldVisitor,
 	) {}
 
-	getFields(entity: Model.Entity, fields: string[]): FieldMap<HasManyToHasOneReducerExtension> {
-		return fields.reduce(
-			(result, field) => ({ ...result, ...acceptFieldVisitor(this.schema, entity, field, this.visitor) }),
-			{},
-		)
+	getFields(entity: Model.Entity, accessibleFields: Model.AnyField[]): FieldMap<HasManyToHasOneReducerExtension> {
+		const fieldMap: FieldMap<HasManyToHasOneReducerExtension> = {}
+		for (const field of accessibleFields) {
+			if (field.type !== Model.RelationType.OneHasMany) {
+				continue
+			}
+
+			for (const [name, resultField] of acceptFieldVisitor(this.schema, entity, field, this.visitor)) {
+				fieldMap[name] = resultField
+			}
+		}
+		return fieldMap
 	}
 }
 

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneRelationReducerVisitor.ts

@@ -1,21 +1,22 @@
 import { GraphQLInputObjectType, GraphQLNonNull } from 'graphql'
 import { Acl, Model } from '@contember/schema'
-import {
-	aliasAwareResolver,
-	EntityTypeProvider,
-	FieldAccessVisitor,
-	GqlTypeName,
-	WhereTypeProvider,
-} from '../../schema'
+import { aliasAwareResolver, EntityTypeProvider, FieldAccessVisitor, GqlTypeName, WhereTypeProvider } from '../../schema'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 import { Authorizator } from '../../acl'
 import { getFieldsForUniqueWhere } from '../../utils'
-import { HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer'
-import { FieldMap } from '../EntityFieldsProvider'
+import { HasManyToHasOneReducer, HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer'
+import { GraphQLFieldConfig } from 'graphql'
+
+type Result = [
+	string,
+	GraphQLFieldConfig<any, any> & {
+		extensions: HasManyToHasOneReducerExtension
+	}
+]
 
 export class HasManyToHasOneRelationReducerFieldVisitor implements
-	Model.ColumnVisitor<FieldMap<HasManyToHasOneReducerExtension>>,
-	Model.RelationByTypeVisitor<FieldMap<HasManyToHasOneReducerExtension>> {
+	Model.ColumnVisitor<Result[]>,
+	Model.RelationByTypeVisitor<Result[]> {
 
 	constructor(
 		private readonly schema: Model.Schema,
@@ -25,32 +26,32 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 	) {}
 
 	public visitColumn() {
-		return {}
+		return []
 	}
 
 	public visitOneHasOneOwning() {
-		return {}
+		return []
 	}
 
 	public visitOneHasOneInverse() {
-		return {}
+		return []
 	}
 
 	public visitManyHasOne() {
-		return {}
+		return []
 	}
 
 	public visitManyHasManyInverse() {
-		return {}
+		return []
 	}
 
 	public visitManyHasManyOwning() {
-		return {}
+		return []
 	}
 
 	public visitOneHasMany({ entity, targetEntity, targetRelation, relation }: Model.OneHasManyContext) {
 		if (!targetRelation) {
-			return {}
+			return []
 		}
 		const uniqueConstraints = getFieldsForUniqueWhere(this.schema, targetEntity)
 		const composedUnique = uniqueConstraints
@@ -63,6 +64,8 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 			.map(fields => fields[0])
 			.filter(it => it !== targetRelation.name)
 
+
+		const existing = new Set<string>()
 		return [...composedUnique, ...singleUnique]
 			.filter(field =>
 				acceptFieldVisitor(
@@ -72,7 +75,11 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 					new FieldAccessVisitor(Acl.Operation.read, this.authorizator),
 				),
 			)
-			.reduce<FieldMap<HasManyToHasOneReducerExtension>>((fields, fieldName) => {
+			.map<Result | null>(fieldName => {
+				if (existing.has(fieldName)) {
+					return null
+				}
+				existing.add(fieldName)
 				const graphQlName = relation.name + GqlTypeName`By${fieldName}`
 				const uniqueWhere: GraphQLInputObjectType = new GraphQLInputObjectType({
 					//todo this can be simplified to ${targetEntity.name}By${fieldName}, but singleton must be used
@@ -84,12 +91,13 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 
 				const entityType = this.entityTypeProvider.getEntity(targetEntity.name)
 
-				return {
-					...fields,
-					[graphQlName]: {
+				return [
+					graphQlName,
+					{
 						type: entityType,
 						extensions: {
 							relationName: relation.name,
+							extensionKey: HasManyToHasOneReducer.extensionName,
 						},
 						args: {
 							by: { type: new GraphQLNonNull(uniqueWhere) },
@@ -97,7 +105,8 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 						},
 						resolve: aliasAwareResolver,
 					},
-				}
-			}, {})
+				]
+			})
+			.filter((it): it is Result => it !== null)
 	}
 }

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProvider.ts

@@ -8,11 +8,14 @@ export class PaginatedHasManyFieldProvider implements EntityFieldsProvider<Pagin
 
 	constructor(private readonly schema: Model.Schema, private readonly visitor: PaginatedHasManyFieldProviderVisitor) {}
 
-	getFields(entity: Model.Entity, fields: string[]): FieldMap<PaginatedHasManyFieldProviderExtension> {
-		return fields.reduce(
-			(result, field) => ({ ...result, ...acceptFieldVisitor(this.schema, entity, field, this.visitor) }),
-			{},
-		)
+	getFields(entity: Model.Entity, accessibleFields: Model.AnyField[]): FieldMap<PaginatedHasManyFieldProviderExtension> {
+		const fields: FieldMap<PaginatedHasManyFieldProviderExtension> = {}
+		for (const field of accessibleFields) {
+			for (const [name, fieldConfig] of acceptFieldVisitor(this.schema, entity, field, this.visitor)) {
+				fields[name] = fieldConfig
+			}
+		}
+		return fields
 	}
 }
 

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor.ts

@@ -1,13 +1,20 @@
 import { Model } from '@contember/schema'
-import { FieldMap } from '../EntityFieldsProvider'
-import { PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider'
+import { PaginatedHasManyFieldProvider, PaginatedHasManyFieldProviderExtension } from './PaginatedHasManyFieldProvider'
 import { capitalizeFirstLetter } from '../../utils'
 import { PaginatedFieldConfigFactory } from '../../schema/PaginatedFieldConfigFactory'
 import { aliasAwareResolver } from '../../schema'
+import { GraphQLFieldConfig } from 'graphql'
+
+type Result = [
+	string,
+	GraphQLFieldConfig<any, any> & {
+		extensions: PaginatedHasManyFieldProviderExtension
+	}
+]
 
 export class PaginatedHasManyFieldProviderVisitor implements
-	Model.ColumnVisitor<FieldMap<PaginatedHasManyFieldProviderExtension>>,
-	Model.RelationByTypeVisitor<FieldMap<PaginatedHasManyFieldProviderExtension>> {
+	Model.ColumnVisitor<Result[]>,
+	Model.RelationByTypeVisitor<Result[]> {
 
 	constructor(private readonly paginatedFieldFactory: PaginatedFieldConfigFactory) {}
 
@@ -23,31 +30,35 @@ export class PaginatedHasManyFieldProviderVisitor implements
 		return this.createField(targetEntity, relation)
 	}
 
-	private createField(entity: Model.Entity, relation: Model.Relation): FieldMap<PaginatedHasManyFieldProviderExtension> {
-		return {
-			[`paginate${capitalizeFirstLetter(relation.name)}`]: {
-				...this.paginatedFieldFactory.createFieldConfig(entity),
-				extensions: {
-					relationName: relation.name,
+	private createField(entity: Model.Entity, relation: Model.Relation): Result[] {
+		return [
+			[
+				`paginate${capitalizeFirstLetter(relation.name)}`,
+				{
+					...this.paginatedFieldFactory.createFieldConfig(entity),
+					extensions: {
+						relationName: relation.name,
+						extensionKey: PaginatedHasManyFieldProvider.extensionName,
+					},
+					resolve: aliasAwareResolver,
 				},
-				resolve: aliasAwareResolver,
-			},
-		}
+			],
+		]
 	}
 
 	visitColumn() {
-		return {}
+		return []
 	}
 
 	visitManyHasOne() {
-		return {}
+		return []
 	}
 
 	visitOneHasOneInverse() {
-		return {}
+		return []
 	}
 
 	visitOneHasOneOwning() {
-		return {}
+		return []
 	}
 }

package/src/introspection/IntrospectionSchemaDefinitionFactory.ts

@@ -1,21 +1,210 @@
-import { IExecutableSchemaDefinition } from '@graphql-tools/schema'
-import schema from './content-schema.graphql'
 import * as ContentSchema from './content-schema.types'
 import { IntrospectionSchemaFactory } from './IntrospectionSchemaFactory'
+import { JSONType } from '@contember/graphql-utils'
 
-export class IntrospectionSchemaDefinitionFactory {
-	constructor(private readonly introspectionSchemaFactory: IntrospectionSchemaFactory) {}
+import {
+	GraphQLBoolean,
+	GraphQLEnumType,
+	GraphQLFieldResolver,
+	GraphQLInt,
+	GraphQLInterfaceType,
+	GraphQLList,
+	GraphQLNonNull,
+	GraphQLObjectType,
+	GraphQLSchema,
+	GraphQLSchemaConfig,
+	GraphQLString,
+	GraphQLUnionType,
+} from 'graphql'
+
+const _RuleMessage = new GraphQLObjectType({
+	name: '_RuleMessage',
+	fields: {
+		text: { type: GraphQLString },
+	},
+})
+
+const _ValidatorArgument = new GraphQLObjectType({
+	name: '_ValidatorArgument',
+	fields: {
+		validator: { type: new GraphQLNonNull(GraphQLInt) },
+	},
+})
+
+const _PathArgument = new GraphQLObjectType({
+	name: '_PathArgument',
+	fields: {
+		path: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
+	},
+})
+
+const _LiteralArgument = new GraphQLObjectType({
+	name: '_LiteralArgument',
+	fields: {
+		value: { type: JSONType },
+	},
+})
+
+const _Argument = new GraphQLUnionType({
+	name: '_Argument',
+	types: [_ValidatorArgument, _PathArgument, _LiteralArgument],
+})
+
+const _Validator = new GraphQLObjectType({
+	name: '_Validator',
+	fields: {
+		operation: { type: new GraphQLNonNull(GraphQLString) },
+		arguments: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Argument))) },
+	},
+})
+
+const _Rule = new GraphQLObjectType({
+	name: '_Rule',
+	fields: {
+		message: { type: _RuleMessage },
+		validator: { type: new GraphQLNonNull(GraphQLInt) },
+	},
+})
+
+const _FieldInterface = new GraphQLInterfaceType({
+	name: '_Field',
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		type: { type: new GraphQLNonNull(GraphQLString) },
+		nullable: { type: GraphQLBoolean },
+		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
+		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
+	},
+})
+
+const _OrderByDirection = new GraphQLEnumType({
+	name: '_OrderByDirection',
+	values: {
+		asc: {},
+		desc: {},
+	},
+})
+
+const _OrderBy = new GraphQLObjectType({
+	name: '_OrderBy',
+	fields: {
+		path: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
+		direction: { type: new GraphQLNonNull(_OrderByDirection) },
+	},
+})
+
+const _OnDeleteBehaviour = new GraphQLEnumType({
+	name: '_OnDeleteBehaviour',
+	values: {
+		restrict: {},
+		cascade: {},
+		setNull: {},
+	},
+})
+
+const _RelationSide = new GraphQLEnumType({
+	name: '_RelationSide',
+	values: {
+		owning: {},
+		inverse: {},
+	},
+})
+
+const _Relation = new GraphQLObjectType({
+	name: '_Relation',
+	interfaces: [_FieldInterface],
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		type: { type: new GraphQLNonNull(GraphQLString) },
+		side: { type: new GraphQLNonNull(_RelationSide) },
+		targetEntity: { type: new GraphQLNonNull(GraphQLString) },
+		ownedBy: { type: GraphQLString },
+		inversedBy: { type: GraphQLString },
+		nullable: { type: GraphQLBoolean },
+		onDelete: { type: _OnDeleteBehaviour },
+		orphanRemoval: { type: GraphQLBoolean },
+		orderBy: { type: new GraphQLList(new GraphQLNonNull(_OrderBy)) },
+		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
+		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
+	},
+})
+
+const _Column = new GraphQLObjectType({
+	name: '_Column',
+	interfaces: [_FieldInterface],
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		type: { type: new GraphQLNonNull(GraphQLString) },
+		enumName: { type: GraphQLString },
+		defaultValue: { type: JSONType },
+		nullable: { type: new GraphQLNonNull(GraphQLBoolean) },
+		rules: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Rule))) },
+		validators: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Validator))) },
+	},
+})
 
-	public create(): IExecutableSchemaDefinition {
-		return {
-			typeDefs: schema,
-			resolvers: {
-				Query: {
-					schema: (): ContentSchema._Schema => {
-						return this.introspectionSchemaFactory.create()
-					},
+const _UniqueConstraint = new GraphQLObjectType({
+	name: '_UniqueConstraint',
+	fields: {
+		fields: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
+	},
+})
+
+const _Entity = new GraphQLObjectType({
+	name: '_Entity',
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		customPrimaryAllowed: { type: new GraphQLNonNull(GraphQLBoolean) },
+		fields: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_FieldInterface))) },
+		unique: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_UniqueConstraint))) },
+	},
+})
+
+const _Enum = new GraphQLObjectType({
+	name: '_Enum',
+	fields: {
+		name: { type: new GraphQLNonNull(GraphQLString) },
+		values: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString))) },
+	},
+})
+
+const _Schema = new GraphQLObjectType({
+	name: '_Schema',
+	fields: {
+		enums: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Enum))) },
+		entities: { type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(_Entity))) },
+	},
+})
+
+
+const createSchemaConfig = (resolver?: GraphQLFieldResolver<any, any>): GraphQLSchemaConfig => {
+	return {
+		query: new GraphQLObjectType({
+			name: 'Query',
+			fields: {
+				schema: {
+					type: _Schema,
+					resolve: resolver,
 				},
 			},
-		}
+		}),
+		types: [_Column, _Relation],
+	}
+}
+
+
+export default new GraphQLSchema(createSchemaConfig())
+
+export class IntrospectionSchemaDefinitionFactory {
+	constructor(private readonly introspectionSchemaFactory: IntrospectionSchemaFactory) {}
+
+	public create(): GraphQLSchema {
+		return new GraphQLSchema(this.createConfig())
+	}
+
+	public createConfig(): GraphQLSchemaConfig {
+		return createSchemaConfig((): ContentSchema._Schema => {
+			return this.introspectionSchemaFactory.create()
+		})
 	}
 }

package/src/introspection/index.ts

@@ -1,4 +1,3 @@
-export { default as ContentSchema } from './content-schema.graphql'
 export * as ContentSchemaTypes from './content-schema.types'
-export * from './IntrospectionSchemaDefinitionFactory'
+export { IntrospectionSchemaDefinitionFactory, default as ContentSchema } from './IntrospectionSchemaDefinitionFactory'
 export * from './IntrospectionSchemaFactory'

package/src/mapper/ErrorUtils.ts

@@ -11,8 +11,9 @@ import {
 import * as Database from '@contember/database'
 import { UniqueWhereError } from '../inputProcessing'
 import { Model } from '@contember/schema'
-import { acceptFieldVisitor, SchemaDatabaseMetadata, tryGetColumnName } from '@contember/schema-utils'
+import { acceptFieldVisitor, tryGetColumnName } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
+import { DatabaseMetadata } from '@contember/database'
 
 
 type UniqueConstraintResult = {
@@ -22,8 +23,8 @@ type UniqueConstraintResult = {
 
 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)
+const findUniqueConstraint = (model: Model.Schema, databaseMetadata: DatabaseMetadata, tableName: string, constraintName: string): UniqueConstraintResult | null => {
+	const constraint = databaseMetadata.uniqueConstraints.filter({ tableName, constraintName }).first()
 	if (!constraint) {
 		return null
 	}
@@ -50,8 +51,8 @@ type RelationInfo = {
 	targetEntity: Model.Entity
 }
 
-const findForeignConstraint = (model: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, tableName: string, constraintName: string): RelationInfo | null => {
-	const constraint = databaseMetadata.getForeignKeyConstraint(tableName, constraintName)
+const findForeignConstraint = (model: Model.Schema, databaseMetadata: DatabaseMetadata, tableName: string, constraintName: string): RelationInfo | null => {
+	const constraint = databaseMetadata.foreignKeys.filter({ fromTable: tableName, constraintName }).first()
 	if (!constraint) {
 		return null
 	}
@@ -88,7 +89,7 @@ const findForeignConstraint = (model: Model.Schema, databaseMetadata: SchemaData
 
 export const convertError = (
 	schema: Model.Schema,
-	databaseMetadata: SchemaDatabaseMetadata,
+	databaseMetadata: DatabaseMetadata,
 	e: any,
 ): MutationResult => {
 
@@ -140,7 +141,7 @@ export const convertError = (
 	throw e
 }
 
-export const tryMutation = async (schema: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
+export const tryMutation = async (schema: Model.Schema, databaseMetadata: DatabaseMetadata, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
 	try {
 		return await cb()
 	} catch (e) {

package/src/mapper/Mapper.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { acceptFieldVisitor, getColumnName, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
 import {
 	OrderByHelper,
 	PathFactory,
@@ -10,7 +10,7 @@ import {
 	SelectResultObject,
 	WhereBuilder,
 } from './select'
-import { Client, Connection, ConstraintHelper, SelectBuilder } from '@contember/database'
+import { Client, Connection, ConstraintHelper, DatabaseMetadata, SelectBuilder } from '@contember/database'
 import { PredicatesInjector } from '../acl'
 import { JunctionTableManager } from './JunctionTableManager'
 import { DeletedEntitiesStorage, DeleteExecutor } from './delete'
@@ -38,7 +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 schemaDatabaseMetadata: DatabaseMetadata,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,
@@ -49,7 +49,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		private readonly inserter: Inserter,
 		private readonly pathFactory: PathFactory,
 	) {
-		this.constraintHelper = new ConstraintHelper(db)
+		this.constraintHelper = new ConstraintHelper(db, this.schemaDatabaseMetadata)
 		this.eventManager = new EventManager(this)
 	}