@contember/schema-migrations 0.12.0-beta.1 → 1.0.0-alpha.2

package/src/modifications/acl/PatchAclSchemaModification.ts

@@ -1,5 +1,4 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { applyPatch, Operation } from 'rfc6902'
@@ -27,10 +26,6 @@ export const PatchAclSchemaModification: ModificationHandlerStatic<PatchAclSchem
 		}
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: 'Update ACL schema' }
 	}

package/src/modifications/acl/UpdateAclSchemaModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Acl, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
@@ -21,10 +20,6 @@ export const UpdateAclSchemaModification: ModificationHandlerStatic<UpdateAclSch
 		})
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: 'Update ACL schema' }
 	}

package/src/modifications/columns/CreateColumnModification.ts

@@ -1,10 +1,9 @@
 import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent, EventType } from '@contember/engine-common'
 import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { wrapIdentifier } from '../../utils/dbHelpers'
-import { getColumnName, isColumn, isInverseRelation, isRelation, resolveDefaultValue } from '@contember/schema-utils'
+import { getColumnName, isColumn } from '@contember/schema-utils'
 import { ImplementationException } from '../../exceptions'
 import { createFields } from '../utils/diffUtils'
 
@@ -54,40 +53,6 @@ export const CreateColumnModification: ModificationHandlerStatic<CreateColumnMod
 		return updateModel(updateEntity(this.data.entityName, addField(this.data.field)))
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-
-		return events.map(it => {
-			if (it.tableName !== entity.tableName || it.type !== EventType.create) {
-				return it
-			}
-
-			try {
-				let value: any = null
-				if (this.data.fillValue !== undefined) {
-					value = this.data.fillValue
-				} else if (this.data.copyValue !== undefined) {
-					const columnName = getColumnName(this.schema.model, entity, this.data.copyValue)
-					value = it.values[columnName] !== undefined ? it.values[columnName] : null
-				} else {
-					value = resolveDefaultValue(this.data.field, { now: () => it.createdAt })
-				}
-				return {
-					...it,
-					values: {
-						...it.values,
-						[this.data.field.columnName]: value,
-					},
-				}
-			} catch (e) {
-				// if (e instanceof NoDataError) {
-				// 	return {...it, errors: [...it.errors || []]}
-				// }
-				throw e
-			}
-		})
-	}
-
 	describe({ createdEntities }: { createdEntities: string[] }) {
 		const notNull = !this.data.field.nullable
 		const hasValue = this.data.fillValue !== undefined || this.data.copyValue !== undefined
@@ -110,7 +75,7 @@ export const CreateColumnModification: ModificationHandlerStatic<CreateColumnMod
 			return CreateColumnModification.createModification({
 				entityName: updatedEntity.name,
 				field: newField,
-				...(newField.default ? { fillValue: newField.default } : {}),
+				...(newField.default !== undefined ? { fillValue: newField.default } : {}),
 			})
 		})
 	}

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
@@ -43,10 +42,6 @@ export const UpdateColumnDefinitionModification: ModificationHandlerStatic<Updat
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events // todo transform type
-	}
-
 	describe() {
 		const current = this.schema.model.entities[this.data.entityName].fields[this.data.fieldName] as Model.AnyColumn
 		const changingToNotNull = current.nullable && !this.data.definition.nullable

package/src/modifications/columns/UpdateColumnNameModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent, EventType } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { updateColumns } from '../utils/diffUtils'
@@ -27,25 +26,6 @@ export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColum
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-		const tableName = entity.tableName
-		const oldColumnName = (entity.fields[this.data.fieldName] as Model.AnyColumn).columnName
-		const newColumnName = this.data.columnName
-		return events.map(it => {
-			if (
-				it.tableName !== tableName ||
-				(it.type !== EventType.create && it.type !== EventType.update) ||
-				!it.values.hasOwnProperty(oldColumnName)
-			) {
-				return it
-			}
-
-			const { [oldColumnName]: value, ...values } = it.values
-			return { ...it, values: { ...values, [newColumnName]: value } }
-		})
-	}
-
 	describe() {
 		return { message: `Change column name of field ${this.data.entityName}.${this.data.fieldName}` }
 	}

package/src/modifications/constraints/CreateUniqueConstraintModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { acceptFieldVisitor } from '@contember/schema-utils'
@@ -58,10 +57,6 @@ export const CreateUniqueConstraintModification: ModificationHandlerStatic<Creat
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe({ createdEntities }: { createdEntities: string[] }) {
 		return {
 			message: `Create unique constraint (${this.data.unique.fields.join(', ')}) on entity ${this.data.entityName}`,

package/src/modifications/constraints/RemoveUniqueConstraintModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
@@ -29,10 +28,6 @@ export const RemoveUniqueConstraintModification: ModificationHandlerStatic<Remov
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		const fields = this.schema.model.entities[this.data.entityName].unique[this.data.constraintName].fields
 		return { message: `Remove unique constraint (${fields.join(', ')}) on entity ${this.data.entityName}` }

package/src/modifications/differs/RemoveChangedFieldDiffer.ts

@@ -1,12 +1,20 @@
 import { Differ } from '../ModificationHandler'
-import { Schema } from '@contember/schema'
+import { Model, Schema } from '@contember/schema'
 import { updateFields } from '../utils/diffUtils'
 import deepEqual from 'fast-deep-equal'
 import { RemoveFieldModification } from '../fields'
 
 export class RemoveChangedFieldDiffer implements Differ {
+	constructor(
+		private readonly matcher: (originalField: Model.AnyField) => boolean,
+	) {
+	}
+
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateFields(originalSchema, updatedSchema, ({ updatedField, originalField, updatedEntity }) => {
+			if (!this.matcher(originalField)) {
+				return undefined
+			}
 			if (!deepEqual({ ...updatedField, inversedBy: undefined }, { ...originalField, inversedBy: undefined })) {
 				return [
 					RemoveFieldModification.createModification({

package/src/modifications/differs/RemoveChangedViewDiffer.ts

@@ -0,0 +1,42 @@
+import { Differ } from '../ModificationHandler'
+import { Model, Schema } from '@contember/schema'
+import deepEqual from 'fast-deep-equal'
+import { RemoveEntityModification } from '../entities'
+import { getViewDirectDependants } from '../utils/viewDependencies'
+import { Migration } from '../../Migration'
+
+export class RemoveChangedViewDiffer implements Differ {
+	constructor() {
+	}
+
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		const changedViews = Object.values(originalSchema.model.entities)
+			.filter(it => {
+				const updatedEntity = updatedSchema.model.entities[it.name]
+				if (!updatedEntity || !it.view || !updatedEntity.view) {
+					return false
+				}
+				return !deepEqual(updatedEntity.view, it.view)
+			})
+		if (changedViews.length === 0) {
+			return []
+		}
+		const removed = new Set<string>()
+		const dependants = getViewDirectDependants(originalSchema.model)
+		const modifications: Migration.Modification[] = []
+		const removeCascade = (entity: Model.Entity) => {
+			if (removed.has(entity.name)) {
+				return
+			}
+			removed.add(entity.name)
+			for (const dependant of dependants.get(entity.name) ?? []) {
+				removeCascade(dependant)
+			}
+			modifications.push(RemoveEntityModification.createModification({ entityName: entity.name }))
+		}
+		for (const changed of changedViews) {
+			removeCascade(changed)
+		}
+		return modifications
+	}
+}

package/src/modifications/differs/index.ts

@@ -1,2 +1,3 @@
 export * from './ChangeViewNonViewDiffer'
 export * from './RemoveChangedFieldDiffer'
+export * from './RemoveChangedViewDiffer'

package/src/modifications/entities/CreateEntityModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
@@ -12,6 +11,7 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.data.entity
 		if (entity.view) {
+			// BC
 			builder.createView(entity.tableName, {}, entity.view.sql)
 			return
 		}
@@ -37,9 +37,6 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 		}))
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
 
 	describe() {
 		return { message: `Add entity ${this.data.entity.name}` }
@@ -52,6 +49,7 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(updatedSchema.model.entities)
 			.filter(it => !originalSchema.model.entities[it.name])
+			.filter(it => !it.view)
 			.map(entity =>
 				CreateEntityModification.createModification({
 					entity: {

package/src/modifications/entities/CreateViewModification.ts

@@ -0,0 +1,65 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model, Schema } from '@contember/schema'
+import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
+import { ModificationHandlerStatic } from '../ModificationHandler'
+import { Migration } from '../../Migration'
+
+export const CreateViewModification: ModificationHandlerStatic<CreateViewModificationData> = class {
+	static id = 'createView'
+	constructor(private readonly data: CreateViewModificationData, private readonly schema: Schema) {}
+
+	public createSql(builder: MigrationBuilder): void {
+		const entity = this.data.entity
+		if (!entity.view) {
+			throw new Error()
+		}
+		builder.createView(entity.tableName, {}, entity.view.sql)
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return updateModel(({ model }) => ({
+			...model,
+			entities: {
+				...model.entities,
+				[this.data.entity.name]: this.data.entity,
+			},
+		}))
+	}
+
+
+	describe() {
+		return { message: `Add view ${this.data.entity.name}` }
+	}
+
+	static createModification(data: CreateViewModificationData) {
+		return { modification: this.id, ...data }
+	}
+
+	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		const newViews = Object.values(updatedSchema.model.entities)
+			.filter(it => !originalSchema.model.entities[it.name])
+			.filter(it => !!it.view)
+		const created = new Set<string>()
+		const modifications: Migration.Modification[] = []
+		const cascadeCreate = (entity: Model.Entity) => {
+			if (originalSchema.model.entities[entity.name] || created.has(entity.name)) {
+				return
+			}
+			created.add(entity.name)
+			for (const dependency of entity.view?.dependencies ?? []) {
+				cascadeCreate(updatedSchema.model.entities[dependency])
+			}
+			modifications.push(CreateViewModification.createModification({
+				entity: entity,
+			}))
+		}
+		for (const view of newViews) {
+			cascadeCreate(view)
+		}
+		return modifications
+	}
+}
+
+export interface CreateViewModificationData {
+	entity: Model.Entity
+}

package/src/modifications/entities/RemoveEntityModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
+import { Acl, Schema } from '@contember/schema'
 import {
 	removeField,
 	SchemaUpdater,
@@ -15,6 +14,7 @@ import {
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { VERSION_ACL_PATCH, VERSION_REMOVE_REFERENCING_RELATIONS } from '../ModificationVersions'
 import { isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
+import { RemoveFieldModification } from '../fields'
 
 export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityModificationData> = class {
 	static id = 'removeEntity'
@@ -30,7 +30,12 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 			builder.dropView(entity.tableName)
 			return
 		}
-		builder.dropTable(entity.tableName, { cascade: true })
+		if (this.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS) {
+			this.getFieldsToRemove(this.schema).forEach(([entityName, fieldName]) => {
+				(new RemoveFieldModification({ entityName, fieldName }, this.schema, this.formatVersion)).createSql(builder)
+			})
+		}
+		builder.dropTable(entity.tableName)
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -41,7 +46,9 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 						({ role }) => ({
 							...role,
 							variables: Object.fromEntries(
-								Object.entries(role.variables).filter(([, variable]) => variable.entityName !== this.data.entityName),
+								Object.entries(role.variables).filter(([, variable]) =>
+									variable.type !== Acl.VariableType.entity || variable.entityName !== this.data.entityName,
+								),
 							),
 						}),
 						updateAclEntities(({ entities }) => {
@@ -67,11 +74,7 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 				: undefined,
 			this.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS
 				? ({ schema }) => {
-					const fieldsToRemove = Object.values(schema.model.entities).flatMap(entity =>
-						Object.values(entity.fields)
-							.filter(field => isRelation(field) && field.target === this.data.entityName)
-							.map(field => [entity.name, field.name]),
-					)
+					const fieldsToRemove = this.getFieldsToRemove(schema)
 					return fieldsToRemove.reduce(
 						(schema, [entity, field]) => removeField(entity, field, this.formatVersion)({ schema }),
 						schema,
@@ -88,11 +91,12 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-		return events.filter(it => {
-			return it.tableName !== entity.tableName
-		})
+	private getFieldsToRemove(schema: Schema): [entity: string, field: string][] {
+		return Object.values(schema.model.entities).flatMap(entity =>
+			Object.values(entity.fields)
+				.filter(field => isRelation(field) && field.target === this.data.entityName)
+				.map((field): [string, string] => [entity.name, field.name]),
+		)
 	}
 
 	describe() {

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
+import { Acl, Model, Schema } from '@contember/schema'
 import {
 	SchemaUpdater,
 	updateAcl,
@@ -83,13 +82,18 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 						({ role }) => ({
 							...role,
 							variables: Object.fromEntries(
-								Object.entries(role.variables).map(([key, variable]) => [
-									key,
-									{
-										...variable,
-										entityName: changeValue(this.data.entityName, this.data.newEntityName)(variable.entityName),
-									},
-								]),
+								Object.entries(role.variables).map(([key, variable]) => {
+									if (variable.type === Acl.VariableType.entity) {
+										return [
+											key,
+											{
+												...variable,
+												entityName: changeValue(this.data.entityName, this.data.newEntityName)(variable.entityName),
+											},
+										]
+									}
+									return [key, variable]
+								}),
 							),
 						}),
 						updateAclEntities(({ entities }) => {
@@ -108,11 +112,6 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 		)
 	}
 
-	public async transformEvents(events: ContentEvent[]): Promise<ContentEvent[]> {
-		events = await this.subModification.transformEvents(events)
-		return events
-	}
-
 	private getNewConstraintName(constraint: Model.UniqueConstraint): string | null {
 		const generatedName = NamingHelper.createUniqueConstraintName(this.data.entityName, constraint.fields)
 		const isGenerated = constraint.name === generatedName

package/src/modifications/entities/UpdateEntityTableNameModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 
@@ -26,16 +25,6 @@ export const UpdateEntityTableNameModification: ModificationHandlerStatic<Update
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-		return events.map(it => {
-			if (it.tableName !== entity.tableName) {
-				return it
-			}
-			return { ...it, tableName: this.data.tableName }
-		})
-	}
-
 	describe() {
 		return { message: `Change table name of entity ${this.data.entityName}` }
 	}

package/src/modifications/entities/UpdateViewModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 
@@ -29,10 +28,6 @@ export const UpdateViewModification: ModificationHandlerStatic<UpdateViewModific
 		)
 	}
 
-	public async transformEvents(events: ContentEvent[]): Promise<ContentEvent[]> {
-		return events
-	}
-
 	describe() {
 		return { message: `Update SQL definition of a view` }
 	}
@@ -40,20 +35,6 @@ export const UpdateViewModification: ModificationHandlerStatic<UpdateViewModific
 	static createModification(data: UpdateViewModificationData) {
 		return { modification: this.id, ...data }
 	}
-
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
-		return Object.values(updatedSchema.model.entities)
-			.filter((it): it is Model.Entity & Required<Pick<Model.Entity, 'view'>> => {
-				const origView = originalSchema.model.entities[it.name]?.view
-				return !!it.view?.sql && !!origView && origView?.sql !== it.view.sql
-			})
-			.map(it =>
-				UpdateViewModification.createModification({
-					entityName: it.name,
-					view: it.view,
-				}),
-			)
-	}
 }
 
 export interface UpdateViewModificationData {

package/src/modifications/entities/index.ts

@@ -1,5 +1,5 @@
 export * from './CreateEntityModification'
+export * from './CreateViewModification'
 export * from './RemoveEntityModification'
 export * from './UpdateEntityNameModification'
 export * from './UpdateEntityTableNameModification'
-export * from './UpdateViewModification'

package/src/modifications/enums/CreateEnumModification.ts

@@ -1,19 +1,17 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
-import { escapeSqlString } from '../../utils/escapeSqlString'
+import { createCheck, getConstraintName } from './enumUtils'
 
 export const CreateEnumModification: ModificationHandlerStatic<CreateEnumModificationData> = class {
 	static id = 'createEnum'
 	constructor(private readonly data: CreateEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
-		const joinedValues = this.data.values.map(it => `'${escapeSqlString(it)}'`).join(',')
 		builder.createDomain(this.data.enumName, 'text', {
-			check: `VALUE IN(${joinedValues})`,
-			constraintName: `${this.data.enumName}_check`.toLowerCase(),
+			check: createCheck(this.data.values),
+			constraintName: getConstraintName(this.data.enumName),
 		})
 	}
 
@@ -27,10 +25,6 @@ export const CreateEnumModification: ModificationHandlerStatic<CreateEnumModific
 		}))
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: `Add enum ${this.data.enumName}` }
 	}

package/src/modifications/enums/RemoveEnumModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 
@@ -22,10 +21,6 @@ export const RemoveEnumModification: ModificationHandlerStatic<RemoveEnumModific
 		})
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: `Remove ${this.data.enumName}` }
 	}

package/src/modifications/enums/UpdateEnumModification.ts

@@ -1,21 +1,21 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
-import { escapeSqlString } from '../../utils/escapeSqlString'
 import deepEqual from 'fast-deep-equal'
+import { createCheck, getConstraintName } from './enumUtils'
 
 export const UpdateEnumModification: ModificationHandlerStatic<UpdateEnumModificationData> = class {
 	static id = 'updateEnum'
 	constructor(private readonly data: UpdateEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
-		const joinedValues = this.data.values.map(it => `'${escapeSqlString(it)}'`).join(',')
-		builder.sql(`ALTER DOMAIN "${this.data.enumName}" DROP CONSTRAINT ${this.data.enumName}_check`)
-		builder.sql(
-			`ALTER DOMAIN "${this.data.enumName}" ADD CONSTRAINT ${this.data.enumName}_check CHECK (VALUE IN(${joinedValues}))`,
-		)
+		builder.sql(`
+			ALTER DOMAIN "${this.data.enumName}"
+			DROP CONSTRAINT ${getConstraintName(this.data.enumName)}`)
+		builder.sql(`
+			ALTER DOMAIN "${this.data.enumName}"
+			ADD CONSTRAINT ${getConstraintName(this.data.enumName)} CHECK (${createCheck(this.data.values)})`)
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -28,10 +28,6 @@ export const UpdateEnumModification: ModificationHandlerStatic<UpdateEnumModific
 		}))
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		const currentValues = this.schema.model.enums[this.data.enumName]
 		const missingValues = currentValues.filter(it => !this.data.values.includes(it))

package/src/modifications/enums/enumUtils.ts

@@ -0,0 +1,8 @@
+import { escapeSqlString } from '../../utils/escapeSqlString'
+
+export const createCheck = (values: string[]) => {
+	const joinedValues = values.map(it => `'${escapeSqlString(it)}'`).join(',')
+	return `VALUE IN(${joinedValues})`
+}
+
+export const getConstraintName = (enumName: string) => `${enumName}_check`.toLowerCase()