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

package/package.json

@@ -1,30 +1,33 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.3.0-alpha.1",
+  "version": "1.3.0-alpha.13",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
+  "exports": {
+    "typescript": "./src/index.ts",
+    "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"
   },
   "dependencies": {
-    "@contember/database": "^1.3.0-alpha.1",
-    "@contember/dic": "^1.3.0-alpha.1",
-    "@contember/logger": "^1.3.0-alpha.1",
-    "@contember/graphql-utils": "^1.3.0-alpha.1",
-    "@contember/schema": "^1.3.0-alpha.1",
-    "@contember/schema-definition": "^1.3.0-alpha.1",
-    "@contember/schema-utils": "^1.3.0-alpha.1",
+    "@contember/database": "1.3.0-alpha.13",
+    "@contember/dic": "1.3.0-alpha.13",
+    "@contember/graphql-utils": "1.3.0-alpha.13",
+    "@contember/logger": "1.3.0-alpha.13",
+    "@contember/schema": "1.3.0-alpha.13",
+    "@contember/schema-definition": "1.3.0-alpha.13",
+    "@contember/schema-utils": "1.3.0-alpha.13",
     "@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.1",
-    "@contember/engine-api-tester": "^1.3.0-alpha.1",
-    "@contember/schema-definition": "^1.3.0-alpha.1",
+    "@contember/database-tester": "1.3.0-alpha.13",
+    "@contember/engine-api-tester": "1.3.0-alpha.13",
+    "@contember/schema-definition": "1.3.0-alpha.13",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",
@@ -37,4 +40,4 @@
     "graphql": ">= 14.6.0",
     "pg": "^8.9.0"
   }
-}
+}

package/src/ExecutionContainer.ts

@@ -0,0 +1,208 @@
+import { PredicateFactory, PredicatesInjector, VariableInjector } from './acl'
+import {
+	ConditionBuilder,
+	FieldsVisitorFactory,
+	JoinBuilder,
+	MetaHandler,
+	OrderByBuilder,
+	RelationFetcher,
+	WhereBuilder,
+} from './mapper/select'
+import { UniqueWhereExpander } from './inputProcessing'
+import { HasManyToHasOneReducer, HasManyToHasOneReducerExecutionHandler } from './extensions'
+import {
+	DeleteExecutor,
+	InsertBuilderFactory,
+	Inserter,
+	JunctionConnectHandler,
+	JunctionDisconnectHandler,
+	JunctionTableManager,
+	MapperFactory,
+	PathFactory,
+	SelectBuilder,
+	SelectBuilderFactory,
+	SelectHydrator,
+	UpdateBuilderFactory,
+	Updater,
+} 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 { PaginatedHasManyExecutionHandler } from './extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
+import { PaginatedHasManyFieldProvider } from './extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
+import { WhereOptimizer } from './mapper/select/optimizer/WhereOptimizer'
+import { ConditionOptimizer } from './mapper/select/optimizer/ConditionOptimizer'
+import { GraphQlQueryAstFactory, MutationResolver, ReadResolver, ValidationResolver } from './resolvers'
+import {
+	ColumnValueResolver,
+	DependencyCollector,
+	EntityRulesResolver, InputPreValidator,
+	QueryAstFactory,
+	ValidationDataSelector,
+} from './input-validation'
+
+export type ExecutionContainerArgs = {
+	schema: Schema & { id: number }
+	schemaDatabaseMetadata: SchemaDatabaseMetadata
+	db: Client
+	identityId: string
+	identityVariables: Acl.VariablesMap
+	permissions: Acl.Permissions
+	systemSchema: string
+	project: { slug: string }
+	stage: { id: string; slug: string }
+}
+
+export interface ExecutionContainer {
+	readResolver: ReadResolver
+	mutationResolver: MutationResolver
+	validationResolver: ValidationResolver
+}
+
+export type ExecutionContainerBuilder = ReturnType<ExecutionContainerFactory['createBuilderInternal']>
+export type ExecutionContainerHook = (builder: ExecutionContainerBuilder) => ExecutionContainerBuilder
+
+export class ExecutionContainerFactory {
+	public readonly hooks: ExecutionContainerHook[] = []
+
+	constructor(
+		private readonly providers: Providers,
+	) {
+	}
+
+	createBuilder(args: ExecutionContainerArgs): ExecutionContainerBuilder {
+		const builder = this.createBuilderInternal(args)
+		return this.hooks.reduce((acc, cb) => cb(acc), builder)
+	}
+
+	createBuilderInternal({ permissions, identityVariables, identityId, db, schema, systemSchema, stage, project, schemaDatabaseMetadata }: ExecutionContainerArgs) {
+		return new Builder({})
+			.addService('systemSchema', () =>
+				systemSchema)
+			.addService('db', () =>
+				db)
+			.addService('project', () =>
+				project)
+			.addService('stage', () =>
+				stage)
+			.addService('schema', () =>
+				schema)
+			.addService('schemaDatabaseMetadata', () =>
+				schemaDatabaseMetadata)
+			.addService('providers', () =>
+				this.providers)
+			.addService('variableInjector', ({ schema }) =>
+				new VariableInjector(schema.model, identityVariables))
+			.addService('predicateFactory', ({ variableInjector, schema }) =>
+				new PredicateFactory(permissions, schema.model, variableInjector))
+			.addService('predicatesInjector', ({ predicateFactory, schema }) =>
+				new PredicatesInjector(schema.model, predicateFactory))
+			.addService('joinBuilder', ({ schema }) =>
+				new JoinBuilder(schema.model))
+			.addService('conditionBuilder', () =>
+				new ConditionBuilder())
+			.addService('pathFactory', () =>
+				new PathFactory())
+			.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))
+			.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('metaHandler', ({ whereBuilder, predicateFactory }) =>
+				new MetaHandler(whereBuilder, predicateFactory))
+			.addService('uniqueWhereExpander', ({ schema }) =>
+				new UniqueWhereExpander(schema.model))
+			.addService('hasManyToHasOneReducer', ({ uniqueWhereExpander, schema }) =>
+				new HasManyToHasOneReducerExecutionHandler(schema.model, uniqueWhereExpander))
+			.addService('paginatedHasManyExecutionHandler', ({ relationFetcher, schema }) =>
+				new PaginatedHasManyExecutionHandler(schema.model, relationFetcher))
+			.addService('selectHandlers', ({ hasManyToHasOneReducer, paginatedHasManyExecutionHandler }) => ({
+				[HasManyToHasOneReducer.extensionName]: hasManyToHasOneReducer,
+				[PaginatedHasManyFieldProvider.extensionName]: paginatedHasManyExecutionHandler,
+			}))
+			.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory, predicateFactory, schema }) =>
+				new (class implements SelectBuilderFactory {
+					create(qb: DbSelectBuilder, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder {
+						return new SelectBuilder(
+							schema.model,
+							whereBuilder,
+							orderByBuilder,
+							metaHandler,
+							qb,
+							hydrator,
+							fieldsVisitorFactory,
+							selectHandlers,
+							pathFactory,
+							relationPath,
+							predicateFactory,
+						)
+					}
+				})())
+			.addService('insertBuilderFactory', ({ whereBuilder, pathFactory, schema, predicateFactory }) =>
+				new InsertBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
+			.addService('updateBuilderFactory', ({ whereBuilder, pathFactory, schema, predicateFactory }) =>
+				new UpdateBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
+			.addService('connectJunctionHandler', () =>
+				new JunctionConnectHandler())
+			.addService('disconnectJunctionHandler', ({}) =>
+				new JunctionDisconnectHandler())
+			.addService('junctionTableManager', ({ predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory, schema }) =>
+				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, 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,
+					whereBuilder,
+					junctionTableManager,
+					deleteExecutor,
+					updater,
+					inserter,
+					pathFactory,
+					providers,
+				)
+			})
+
+			.addService('queryAstFactory', () =>
+				new GraphQlQueryAstFactory())
+			.addService('readResolver', ({ mapperFactory, queryAstFactory }) =>
+				new ReadResolver(mapperFactory, queryAstFactory))
+			.addService('validationDependencyCollector', () =>
+				new DependencyCollector())
+			.addService('validationQueryAstFactory', ({ schema }) =>
+				new QueryAstFactory(schema.model))
+			.addService('dataSelector', ({ validationQueryAstFactory, schema }) =>
+				new ValidationDataSelector(schema.model, validationQueryAstFactory))
+			.addService('columnValueResolver', ({ providers }) =>
+				new ColumnValueResolver(providers))
+			.addService('entityRulesResolver', ({ schema }) =>
+				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, schemaDatabaseMetadata }) =>
+				new MutationResolver(schema.model, mapperFactory, inputPreValidator, queryAstFactory, schemaDatabaseMetadata))
+			.addService('validationResolver', ({ inputPreValidator, mapperFactory }) =>
+				new ValidationResolver(mapperFactory, inputPreValidator))
+	}
+
+	public create(args: ExecutionContainerArgs): ExecutionContainer {
+		return this.createBuilder(args).build().pick('validationResolver', 'readResolver', 'mutationResolver')
+	}
+}
+

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

@@ -5,6 +5,29 @@ export * from './schema'
 export * from './inputProcessing'
 export { EntityRulesResolver } from './input-validation'
 export * from './types'
+export * from './ExecutionContainer'
 export { graphql } from 'graphql'
 export { UserError } from './exception'
-export { createMapperContainer } from './mapper'
+export {
+	DataModificationEvent,
+	AfterCommitEvent,
+	AfterInsertEvent,
+	AfterJunctionUpdateEvent,
+	AfterUpdateEvent,
+	BeforeCommitEvent,
+	BeforeDeleteEvent,
+	BeforeInsertEvent,
+	BeforeJunctionUpdateEvent,
+	BeforeUpdateEvent,
+	EventManager,
+	Mapper,
+	MapperFactory,
+	ExecutionContainer,
+	ExecutionContainerBuilder,
+	Path,
+	WhereBuilder,
+	PathFactory,
+	ExecutionContainerFactory,
+	ExecutionContainerHook,
+	ExecutionContainerArgs,
+} from './mapper'

package/src/mapper/ColumnValue.ts

@@ -2,14 +2,14 @@ import { Value } from '@contember/schema'
 import { getFulfilledValues, getRejections } from '../utils'
 
 export type ColumnValue<E = never> = {
-	value: PromiseLike<Value.AtomicValue<E> | undefined>
+	value: PromiseLike<Value.FieldValue<E> | undefined>
 	fieldName: string
 	columnName: string
 	columnType: string
 }
 
 export type ResolvedColumnValue<E = never> = ColumnValue<E> & {
-	resolvedValue: Value.AtomicValue<E>
+	resolvedValue: Value.FieldValue<E>
 }
 
 export const resolveGenericValue = <T>(value: Value.GenericValueLike<T>): Promise<T> => {

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)]
 	}
 }