@contember/schema-migrations 1.1.2 → 1.2.0-alpha.11

package/src/modifications/columns/UpdateColumnNameModification.ts

@@ -1,13 +1,13 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { updateColumns } from '../utils/diffUtils'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 
-export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColumnNameModificationData> = class {
-	static id = 'updateColumnName'
-	constructor(private readonly data: UpdateColumnNameModificationData, private readonly schema: Schema) {}
+export class UpdateColumnNameModificationHandler implements ModificationHandler<UpdateColumnNameModificationData> {
+	constructor(private readonly data: UpdateColumnNameModificationData, private readonly schema: Schema) {
+	}
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.schema.model.entities[this.data.entityName]
@@ -15,13 +15,13 @@ export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColum
 			return
 		}
 		acceptFieldVisitor(this.schema.model, entity, this.data.fieldName, {
-			visitColumn: (entity, column) => {
+			visitColumn: ({ entity, column }) => {
 				builder.renameColumn(entity.tableName, column.columnName, this.data.columnName)
 			},
-			visitManyHasOne: (entity, relation) => {
+			visitManyHasOne: ({ entity, relation }) => {
 				builder.renameColumn(entity.tableName, relation.joiningColumn.columnName, this.data.columnName)
 			},
-			visitOneHasOneOwning: (entity, relation) =>  {
+			visitOneHasOneOwning: ({ entity, relation }) => {
 				builder.renameColumn(entity.tableName, relation.joiningColumn.columnName, this.data.columnName)
 			},
 			visitManyHasManyInverse: () => {
@@ -43,44 +43,47 @@ export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColum
 		return updateModel(
 			updateEntity(
 				this.data.entityName,
-				updateField(this.data.fieldName, ({ field, entity }) => acceptFieldVisitor<Model.AnyField>(this.schema.model, entity, field, {
-					visitColumn: (entity, column) => {
-						return {
-							...column,
-							columnName: this.data.columnName,
-						}
-					},
-					visitManyHasOne: (entity, relation) => {
-						return {
-							...relation,
-							joiningColumn: {
-								...relation.joiningColumn,
-								columnName: this.data.columnName,
-							},
-						}
-					},
-					visitOneHasOneOwning: (entity, relation) => {
-						return {
-							...relation,
-							joiningColumn: {
-								...relation.joiningColumn,
+				updateField(this.data.fieldName, ({ field, entity }) =>
+					acceptFieldVisitor<Model.AnyField>(this.schema.model, entity, field, {
+						visitColumn: ({ column }) => {
+							return {
+								...column,
 								columnName: this.data.columnName,
-							},
-						}
-					},
-					visitManyHasManyInverse: () => {
-						throw new Error('Cannot rename column of many-to-many relation')
-					},
-					visitManyHasManyOwning: () => {
-						throw new Error('Cannot rename column of many-to-many relation')
+							}
+						},
+						visitManyHasOne: ({ entity, relation }) => {
+							return {
+								...relation,
+								joiningColumn: {
+									...relation.joiningColumn,
+									columnName: this.data.columnName,
+								},
+							}
+						},
+						visitOneHasOneOwning: ({ entity, relation }) => {
+							return {
+								...relation,
+								joiningColumn: {
+									...relation.joiningColumn,
+									columnName: this.data.columnName,
+								},
+							}
+						},
+						visitManyHasManyInverse: () => {
+							throw new Error('Cannot rename column of many-to-many relation')
+						},
+						visitManyHasManyOwning: () => {
+							throw new Error('Cannot rename column of many-to-many relation')
+						},
+						visitOneHasMany: () => {
+							throw new Error('Cannot rename column of one-to-many relation')
+						},
+						visitOneHasOneInverse: () => {
+							throw new Error('Cannot rename column of one-to-one inverse relation')
+						},
 					},
-					visitOneHasMany: () => {
-						throw new Error('Cannot rename column of one-to-many relation')
-					},
-					visitOneHasOneInverse: () => {
-						throw new Error('Cannot rename column of one-to-one inverse relation')
-					},
-				})),
+					),
+				),
 			),
 		)
 	}
@@ -88,17 +91,26 @@ export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColum
 	describe() {
 		return { message: `Change column name of field ${this.data.entityName}.${this.data.fieldName}` }
 	}
+}
 
-	static createModification(data: UpdateColumnNameModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface UpdateColumnNameModificationData {
+	entityName: string
+	fieldName: string
+	columnName: string
+}
+
+export const updateColumnNameModification = createModificationType({
+	id: 'updateColumnName',
+	handler: UpdateColumnNameModificationHandler,
+})
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export class UpdateColumnNameDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateColumns(originalSchema, updatedSchema, ({ originalColumn, updatedColumn, updatedEntity }) => {
 			if (originalColumn.columnName === updatedColumn.columnName) {
 				return undefined
 			}
-			return UpdateColumnNameModification.createModification({
+			return updateColumnNameModification.createModification({
 				entityName: updatedEntity.name,
 				fieldName: updatedColumn.name,
 				columnName: updatedColumn.columnName,
@@ -106,8 +118,3 @@ export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColum
 		})
 	}
 }
-export interface UpdateColumnNameModificationData {
-	entityName: string
-	fieldName: string
-	columnName: string
-}

package/src/modifications/constraints/CreateUniqueConstraintModification.ts

@@ -1,13 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { acceptFieldVisitor } from '@contember/schema-utils'
 
-export const CreateUniqueConstraintModification: ModificationHandlerStatic<CreateUniqueConstraintModificationData> = class {
-	static id = 'createUniqueConstraint'
-
-	constructor(private readonly data: CreateUniqueConstraintModificationData, private readonly schema: Schema) {}
+export class CreateUniqueConstraintModificationHandler implements ModificationHandler<CreateUniqueConstraintModificationData> {
+	constructor(private readonly data: CreateUniqueConstraintModificationData, private readonly schema: Schema) {
+	}
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.schema.model.entities[this.data.entityName]
@@ -17,10 +16,10 @@ export const CreateUniqueConstraintModification: ModificationHandlerStatic<Creat
 		const fields = this.data.unique.fields
 		const columns = fields.map(fieldName => {
 			return acceptFieldVisitor(this.schema.model, entity, fieldName, {
-				visitColumn: ({}, column) => {
+				visitColumn: ({ column }) => {
 					return column.columnName
 				},
-				visitManyHasOne: ({}, relation) => {
+				visitManyHasOne: ({ relation }) => {
 					return relation.joiningColumn.columnName
 				},
 				visitOneHasMany: () => {
@@ -66,20 +65,27 @@ export const CreateUniqueConstraintModification: ModificationHandlerStatic<Creat
 		}
 	}
 
-	static createModification(data: CreateUniqueConstraintModificationData) {
-		return { modification: this.id, ...data }
-	}
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export interface CreateUniqueConstraintModificationData {
+	entityName: string
+	unique: Model.UniqueConstraint
+}
+
+export const createUniqueConstraintModification = createModificationType({
+	id: 'createUniqueConstraint',
+	handler: CreateUniqueConstraintModificationHandler,
+})
+
+export class CreateUniqueConstraintDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(updatedSchema.model.entities).flatMap(entity =>
 			Object.values(entity.unique)
 				.filter(it => !originalSchema.model.entities[entity.name].unique[it.name])
-				.map(unique => CreateUniqueConstraintModification.createModification({ entityName: entity.name, unique })),
+				.map(unique => createUniqueConstraintModification.createModification({
+					entityName: entity.name,
+					unique,
+				})),
 		)
 	}
 }
-
-export interface CreateUniqueConstraintModificationData {
-	entityName: string
-	unique: Model.UniqueConstraint
-}

package/src/modifications/constraints/RemoveUniqueConstraintModification.ts

@@ -1,12 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 
-export const RemoveUniqueConstraintModification: ModificationHandlerStatic<RemoveUniqueConstraintModificationData> = class {
-	static id = 'removeUniqueConstraint'
-	constructor(private readonly data: RemoveUniqueConstraintModificationData, private readonly schema: Schema) {}
+export class RemoveUniqueConstraintModificationHandler implements ModificationHandler<RemoveUniqueConstraintModificationData> {
+	constructor(private readonly data: RemoveUniqueConstraintModificationData, private readonly schema: Schema) {
+	}
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.schema.model.entities[this.data.entityName]
@@ -32,12 +32,21 @@ export const RemoveUniqueConstraintModification: ModificationHandlerStatic<Remov
 		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}` }
 	}
+}
 
-	static createModification(data: RemoveUniqueConstraintModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface RemoveUniqueConstraintModificationData {
+	entityName: string
+	constraintName: string
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const removeUniqueConstraintModification = createModificationType({
+	id: 'removeUniqueConstraint',
+	handler: RemoveUniqueConstraintModificationHandler,
+})
+
+
+export class RemoveUniqueConstraintDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(originalSchema.model.entities).flatMap(entity =>
 			Object.values(entity.unique)
 				.filter(
@@ -47,7 +56,7 @@ export const RemoveUniqueConstraintModification: ModificationHandlerStatic<Remov
 							!deepEqual(it.fields, updatedSchema.model.entities[entity.name].unique[it.name].fields)),
 				)
 				.map(unique =>
-					RemoveUniqueConstraintModification.createModification({
+					removeUniqueConstraintModification.createModification({
 						entityName: entity.name,
 						constraintName: unique.name,
 					}),
@@ -55,8 +64,3 @@ export const RemoveUniqueConstraintModification: ModificationHandlerStatic<Remov
 		)
 	}
 }
-
-export interface RemoveUniqueConstraintModificationData {
-	entityName: string
-	constraintName: string
-}

package/src/modifications/differs/ChangeViewNonViewDiffer.ts

@@ -1,6 +1,6 @@
 import { Differ } from '../ModificationHandler'
 import { Schema } from '@contember/schema'
-import { RemoveEntityModification } from '../entities'
+import { removeEntityModification } from '../entities'
 
 export class ChangeViewNonViewDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
@@ -12,6 +12,6 @@ export class ChangeViewNonViewDiffer implements Differ {
 				}
 				return !!origEntity.view !== !!it.view
 			})
-			.map(it => RemoveEntityModification.createModification({ entityName: it.name }))
+			.map(it => removeEntityModification.createModification({ entityName: it.name }))
 	}
 }

package/src/modifications/differs/RemoveChangedFieldDiffer.ts

@@ -2,7 +2,7 @@ import { Differ } from '../ModificationHandler'
 import { Model, Schema } from '@contember/schema'
 import { updateFields } from '../utils/diffUtils'
 import deepEqual from 'fast-deep-equal'
-import { RemoveFieldModification } from '../fields'
+import { removeFieldModification } from '../fields'
 
 export class RemoveChangedFieldDiffer implements Differ {
 	constructor(
@@ -17,7 +17,7 @@ export class RemoveChangedFieldDiffer implements Differ {
 			}
 			if (!deepEqual({ ...updatedField, inversedBy: undefined }, { ...originalField, inversedBy: undefined })) {
 				return [
-					RemoveFieldModification.createModification({
+					removeFieldModification.createModification({
 						entityName: updatedEntity.name,
 						fieldName: updatedField.name,
 					}),

package/src/modifications/differs/RemoveChangedViewDiffer.ts

@@ -1,7 +1,7 @@
 import { Differ } from '../ModificationHandler'
 import { Model, Schema } from '@contember/schema'
 import deepEqual from 'fast-deep-equal'
-import { RemoveEntityModification } from '../entities'
+import { removeEntityModification } from '../entities'
 import { getViewDirectDependants } from '../utils/viewDependencies'
 import { Migration } from '../../Migration'
 
@@ -32,7 +32,7 @@ export class RemoveChangedViewDiffer implements Differ {
 			for (const dependant of dependants.get(entity.name) ?? []) {
 				removeCascade(dependant)
 			}
-			modifications.push(RemoveEntityModification.createModification({ entityName: entity.name }))
+			modifications.push(removeEntityModification.createModification({ entityName: entity.name }))
 		}
 		for (const changed of changedViews) {
 			removeCascade(changed)

package/src/modifications/entities/CreateEntityModification.ts

@@ -1,11 +1,16 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
 import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
+import { PartialEntity } from '../../utils/PartialEntity.js'
 
-export const CreateEntityModification: ModificationHandlerStatic<CreateEntityModificationData> = class {
-	static id = 'createEntity'
+export class CreateEntityModificationHandler implements ModificationHandler<CreateEntityModificationData> {
 	constructor(
 		private readonly data: CreateEntityModificationData,
 		private readonly schema: Schema,
@@ -43,6 +48,7 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 				...model.entities,
 				[this.data.entity.name]: {
 					eventLog: { enabled: true },
+					indexes: {},
 					...this.data.entity,
 				},
 			},
@@ -54,16 +60,20 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 		return { message: `Add entity ${this.data.entity.name}` }
 	}
 
-	static createModification(data: CreateEntityModificationData) {
-		return { modification: this.id, ...data }
-	}
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const createEntityModification = createModificationType({
+	id: 'createEntity',
+	handler: CreateEntityModificationHandler,
+})
+
+export class CreateEntityDiffer implements Differ {
+	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({
+				createEntityModification.createModification({
 					entity: {
 						...entity,
 						fields: {
@@ -76,8 +86,6 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 	}
 }
 
-type SomePartial<E, K extends keyof E> = Omit<E, K> & Partial<Pick<E, K>>
-
 export interface CreateEntityModificationData {
-	entity: SomePartial<Model.Entity, 'eventLog'>
+	entity: PartialEntity
 }

package/src/modifications/entities/CreateViewModification.ts

@@ -1,11 +1,11 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { Migration } from '../../Migration'
+import { PartialEntity } from '../../utils/PartialEntity.js'
 
-export const CreateViewModification: ModificationHandlerStatic<CreateViewModificationData> = class {
-	static id = 'createView'
+export class CreateViewModificationHandler implements ModificationHandler<CreateViewModificationData> {
 	constructor(private readonly data: CreateViewModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -22,6 +22,7 @@ export const CreateViewModification: ModificationHandlerStatic<CreateViewModific
 			entities: {
 				...model.entities,
 				[this.data.entity.name]: {
+					indexes: {},
 					eventLog: { enabled: true }, // not relevant here...
 					...this.data.entity,
 				},
@@ -33,12 +34,15 @@ export const CreateViewModification: ModificationHandlerStatic<CreateViewModific
 	describe() {
 		return { message: `Add view ${this.data.entity.name}` }
 	}
+}
 
-	static createModification(data: CreateViewModificationData) {
-		return { modification: this.id, ...data }
-	}
+export const createViewModification = createModificationType({
+	id: 'createView',
+	handler: CreateViewModificationHandler,
+})
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export class CreateViewDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		const newViews = Object.values(updatedSchema.model.entities)
 			.filter(it => !originalSchema.model.entities[it.name])
 			.filter(it => !!it.view)
@@ -52,7 +56,7 @@ export const CreateViewModification: ModificationHandlerStatic<CreateViewModific
 			for (const dependency of entity.view?.dependencies ?? []) {
 				cascadeCreate(updatedSchema.model.entities[dependency])
 			}
-			modifications.push(CreateViewModification.createModification({
+			modifications.push(createViewModification.createModification({
 				entity: entity,
 			}))
 		}
@@ -63,8 +67,6 @@ export const CreateViewModification: ModificationHandlerStatic<CreateViewModific
 	}
 }
 
-type SomePartial<E, K extends keyof E> = Omit<E, K> & Partial<Pick<E, K>>
-
 export interface CreateViewModificationData {
-	entity: SomePartial<Model.Entity, 'eventLog'>
+	entity: PartialEntity
 }

package/src/modifications/entities/RemoveEntityModification.ts

@@ -11,14 +11,17 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerOptions,
+} 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'
+import { removeFieldModification } from '../fields'
 
+export class RemoveEntityModificationHandler implements ModificationHandler<RemoveEntityModificationData> {
 	constructor(
 		private readonly data: RemoveEntityModificationData,
 		private readonly schema: Schema,
@@ -33,7 +36,7 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 		}
 		if (this.options.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS) {
 			this.getFieldsToRemove(this.schema).forEach(([entityName, fieldName]) => {
-				(new RemoveFieldModification({ entityName, fieldName }, this.schema, this.options)).createSql(builder)
+				removeFieldModification.createHandler({ entityName, fieldName }, this.schema, this.options).createSql(builder)
 			})
 		}
 		builder.dropTable(entity.tableName)
@@ -104,17 +107,21 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 		return { message: `Remove entity ${this.data.entityName}`, isDestructive: true }
 	}
 
-	static createModification(data: RemoveEntityModificationData) {
-		return { modification: this.id, ...data }
-	}
-
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
-		return Object.keys(originalSchema.model.entities)
-			.filter(name => !updatedSchema.model.entities[name])
-			.map(entityName => RemoveEntityModification.createModification({ entityName }))
-	}
 }
 
 export interface RemoveEntityModificationData {
 	entityName: string
 }
+
+export const removeEntityModification = createModificationType({
+	id: 'removeEntity',
+	handler: RemoveEntityModificationHandler,
+})
+
+export class RemoveEntityDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.keys(originalSchema.model.entities)
+			.filter(name => !updatedSchema.model.entities[name])
+			.map(entityName => removeEntityModification.createModification({ entityName }))
+	}
+}

package/src/modifications/entities/ToggleEventLogModification.ts

@@ -1,7 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
 import {
 	createEventTrigger,
 	createEventTrxTrigger,
@@ -9,8 +14,7 @@ import {
 	dropEventTrxTrigger,
 } from '../utils/sqlUpdateUtils'
 
-export const ToggleEventLogModification: ModificationHandlerStatic<ToggleEventLogModificationData> = class {
-	static id = 'toggleEventLog'
+export class ToggleEventLogModificationHandler implements ModificationHandler<ToggleEventLogModificationData> {
 
 	constructor(
 		private readonly data: ToggleEventLogModificationData,
@@ -51,12 +55,20 @@ export const ToggleEventLogModification: ModificationHandlerStatic<ToggleEventLo
 			message: `${this.data.enabled ? 'Enable' : 'Disable'} event log for ${this.data.entityName}`,
 		}
 	}
+}
 
-	static createModification(data: ToggleEventLogModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface ToggleEventLogModificationData {
+	entityName: string
+	enabled: boolean
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const toggleEventLogModification = createModificationType({
+	id: 'toggleEventLog',
+	handler: ToggleEventLogModificationHandler,
+})
+
+export class ToggleEventLogDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(updatedSchema.model.entities)
 			.flatMap(updatedEntity => {
 				const origEntity = originalSchema.model.entities[updatedEntity.name]
@@ -66,7 +78,7 @@ export const ToggleEventLogModification: ModificationHandlerStatic<ToggleEventLo
 				const newValue = updatedEntity.eventLog.enabled
 				const oldValue = origEntity.eventLog.enabled
 				if (newValue !== oldValue) {
-					return [ToggleEventLogModification.createModification({
+					return [toggleEventLogModification.createModification({
 						entityName: updatedEntity.name,
 						enabled: newValue,
 					})]
@@ -76,8 +88,3 @@ export const ToggleEventLogModification: ModificationHandlerStatic<ToggleEventLo
 
 	}
 }
-
-export interface ToggleEventLogModificationData {
-	entityName: string
-	enabled: boolean
-}

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -11,17 +11,16 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { ModificationHandler, ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, ModificationHandler, ModificationHandlerOptions } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
 import { VERSION_ACL_PATCH, VERSION_UPDATE_CONSTRAINT_NAME } from '../ModificationVersions'
 import { NamingHelper } from '@contember/schema-utils'
-import { UpdateEntityTableNameModification } from './UpdateEntityTableNameModification'
 import { NoopModification } from '../NoopModification'
 import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../utils/renameConstraintsHelper'
 import { changeValue } from '../utils/valueUtils'
+import { updateEntityTableNameModification } from './UpdateEntityTableNameModification'
 
-export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntityNameModificationData> = class {
-	static id = 'updateEntityName'
+export class UpdateEntityNameModificationHandler implements ModificationHandler<UpdateEntityNameModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
@@ -30,7 +29,7 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 		private readonly options: ModificationHandlerOptions,
 	) {
 		this.subModification = data.tableName
-			? new UpdateEntityTableNameModification(
+			? updateEntityTableNameModification.createHandler(
 				{ entityName: data.entityName, tableName: data.tableName },
 				schema,
 				this.options,
@@ -124,10 +123,6 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 	describe() {
 		return { message: `Change entity name from ${this.data.entityName} to ${this.data.newEntityName}` }
 	}
-
-	static createModification(data: UpdateEntityNameModificationData) {
-		return { modification: this.id, ...data }
-	}
 }
 
 export interface UpdateEntityNameModificationData {
@@ -135,3 +130,8 @@ export interface UpdateEntityNameModificationData {
 	newEntityName: string
 	tableName?: string
 }
+
+export const updateEntityNameModification = createModificationType({
+	id: 'updateEntityName',
+	handler: UpdateEntityNameModificationHandler,
+})