@contember/schema-migrations 1.2.0-alpha.8 → 1.2.0-beta.1

package/src/modifications/columns/CreateColumnModification.ts

@@ -1,15 +1,14 @@
 import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { wrapIdentifier } from '../../utils/dbHelpers'
 import { getColumnName, isColumn } from '@contember/schema-utils'
 import { ImplementationException } from '../../exceptions'
 import { createFields } from '../utils/diffUtils'
+import { getColumnSqlType } from '../utils/columnUtils'
 
-export const CreateColumnModification: ModificationHandlerStatic<CreateColumnModificationData> = class {
-	static id = 'createColumn'
-
+export class CreateColumnModificationHandler implements ModificationHandler<CreateColumnModificationData> {
 	constructor(private readonly data: CreateColumnModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -21,7 +20,7 @@ export const CreateColumnModification: ModificationHandlerStatic<CreateColumnMod
 		const hasSeed = this.data.fillValue !== undefined || this.data.copyValue !== undefined
 		builder.addColumn(entity.tableName, {
 			[column.columnName]: {
-				type: column.type === Model.ColumnType.Enum ? `"${column.columnType}"` : column.columnType,
+				type: getColumnSqlType(column),
 				notNull: !column.nullable && !hasSeed,
 				sequenceGenerated: column.sequence,
 			},
@@ -33,7 +32,7 @@ export const CreateColumnModification: ModificationHandlerStatic<CreateColumnMod
 			} else if (this.data.copyValue !== undefined) {
 				const copyFrom = getColumnName(this.schema.model, entity, this.data.copyValue)
 				builder.sql(`UPDATE ${wrapIdentifier(entity.tableName)}
-	  SET ${wrapIdentifier(column.columnName)} = ${wrapIdentifier(copyFrom)}`)
+	  SET ${wrapIdentifier(column.columnName)} = ${wrapIdentifier(copyFrom)}::${getColumnSqlType(column)}`)
 			} else {
 				throw new ImplementationException()
 			}
@@ -63,17 +62,28 @@ export const CreateColumnModification: ModificationHandlerStatic<CreateColumnMod
 				: undefined
 		return { message: `Add field ${this.data.entityName}.${this.data.field.name}`, failureWarning }
 	}
+}
 
-	static createModification(data: CreateColumnModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface CreateColumnModificationData {
+	entityName: string
+	field: Model.AnyColumn
+	fillValue?: any
+	copyValue?: string
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+
+export const createColumnModification = createModificationType({
+	id: 'createColumn',
+	handler: CreateColumnModificationHandler,
+})
+
+export class CreateColumnDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return createFields(originalSchema, updatedSchema, ({ newField, updatedEntity }) => {
 			if (!isColumn(newField)) {
 				return undefined
 			}
-			return CreateColumnModification.createModification({
+			return createColumnModification.createModification({
 				entityName: updatedEntity.name,
 				field: newField,
 				...(newField.default !== undefined ? { fillValue: newField.default } : {}),
@@ -81,10 +91,3 @@ export const CreateColumnModification: ModificationHandlerStatic<CreateColumnMod
 		})
 	}
 }
-
-export interface CreateColumnModificationData {
-	entityName: string
-	field: Model.AnyColumn
-	fillValue?: any
-	copyValue?: string
-}

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -1,13 +1,14 @@
-import { MigrationBuilder } from '@contember/database-migrations'
+import { escapeValue, 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 deepEqual from 'fast-deep-equal'
 import { updateColumns } from '../utils/diffUtils'
 import { wrapIdentifier } from '@contember/database'
+import { getColumnSqlType } from '../utils/columnUtils'
+import { getEntityDependantViews } from '../utils/viewDependencies'
 
-export const UpdateColumnDefinitionModification: ModificationHandlerStatic<UpdateColumnDefinitionModificationData> = class {
-	static id = 'updateColumnDefinition'
+export class UpdateColumnDefinitionModificationHandler implements ModificationHandler<UpdateColumnDefinitionModificationData>  {
 	constructor(private readonly data: UpdateColumnDefinitionModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -15,34 +16,40 @@ export const UpdateColumnDefinitionModification: ModificationHandlerStatic<Updat
 		if (entity.view) {
 			return
 		}
-		const field = entity.fields[this.data.fieldName] as Model.AnyColumn
-		const definition = this.data.definition
-		const newType = definition.columnType !== field.columnType
-			? definition.type === Model.ColumnType.Enum
-				? `"${definition.columnType}"`
-				: definition.columnType
-			: undefined
-		builder.alterColumn(entity.tableName, field.columnName, {
-			type: newType,
-			notNull: field.nullable !== definition.nullable ? !definition.nullable : undefined,
-			using: newType !== undefined ? `${wrapIdentifier(field.columnName)}::${newType}` : undefined,
-			sequenceGenerated: field.sequence && !definition.sequence ? false : (!field.sequence ? definition.sequence : undefined),
+		const oldColumn = entity.fields[this.data.fieldName] as Model.AnyColumn
+		const newColumn = this.data.definition
+
+		const hasNewSequence = !oldColumn.sequence && newColumn.sequence
+		const hasNewType = newColumn.columnType !== oldColumn.columnType
+		const columnType = getColumnSqlType(newColumn)
+
+		const usingCast = `${wrapIdentifier(oldColumn.columnName)}::${columnType}`
+
+		builder.alterColumn(entity.tableName, oldColumn.columnName, {
+			type: hasNewSequence || hasNewType ? columnType : undefined,
+			notNull: oldColumn.nullable !== newColumn.nullable ? !newColumn.nullable : undefined,
+			using: hasNewSequence
+				? `COALESCE(${usingCast}, nextval(PG_GET_SERIAL_SEQUENCE(${escapeValue(entity.tableName)}, ${escapeValue(oldColumn.columnName)})))`
+				: hasNewType
+					? usingCast
+					: undefined,
+			sequenceGenerated: oldColumn.sequence && !newColumn.sequence ? false : (!oldColumn.sequence ? newColumn.sequence : undefined),
 		})
 
 		const seqAlter = []
-		if (field.sequence && definition.sequence) {
-			if (field.sequence.precedence !== definition.sequence.precedence) {
-				seqAlter.push(`SET GENERATED ${definition.sequence.precedence}`)
+		if (oldColumn.sequence && newColumn.sequence) {
+			if (oldColumn.sequence.precedence !== newColumn.sequence.precedence) {
+				seqAlter.push(`SET GENERATED ${newColumn.sequence.precedence}`)
 			}
-			if (field.sequence.start !== definition.sequence.start && typeof definition.sequence.start == 'number') {
-				seqAlter.push(`SET START WITH ${definition.sequence.start}`)
+			if (oldColumn.sequence.start !== newColumn.sequence.start && typeof newColumn.sequence.start == 'number') {
+				seqAlter.push(`SET START WITH ${newColumn.sequence.start}`)
 			}
-			if (definition.sequence.restart) {
+			if (newColumn.sequence.restart) {
 				seqAlter.push('RESTART')
 			}
 		}
 		if (seqAlter.length > 0) {
-			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} ALTER ${wrapIdentifier(field.columnName)} ${seqAlter.join(' ')}`)
+			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} ALTER ${wrapIdentifier(oldColumn.columnName)} ${seqAlter.join(' ')}`)
 		}
 	}
 
@@ -71,27 +78,49 @@ export const UpdateColumnDefinitionModification: ModificationHandlerStatic<Updat
 			failureWarning,
 		}
 	}
+}
 
-	static createModification(data: UpdateColumnDefinitionModificationData) {
-		return { modification: this.id, ...data }
+type SequenceDefinitionAlter =
+	& Model.AnyColumn['sequence']
+	& {
+		restart?: boolean
 	}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+type ColumnDefinitionAlter =
+	& Omit<Model.AnyColumn, 'sequence' | 'columnName' | 'name'>
+	& {
+		sequence?: SequenceDefinitionAlter
+	}
+
+export interface UpdateColumnDefinitionModificationData {
+	entityName: string
+	fieldName: string
+	definition: ColumnDefinitionAlter
+}
+
+export const updateColumnDefinitionModification = createModificationType({
+	id: 'updateColumnDefinition',
+	handler: UpdateColumnDefinitionModificationHandler,
+})
+
+export class UpdateColumnDefinitionDiffer implements Differ<UpdateColumnDefinitionModificationData> {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateColumns(originalSchema, updatedSchema, ({ originalColumn, updatedColumn, updatedEntity }) => {
 			const {
 				name: {},
 				columnName: {},
 				...updatedDefinition
-			} = updatedColumn as any
+			} = updatedColumn
 			const {
 				name: {},
 				columnName: {},
 				...originalDefinition
-			} = originalColumn as any
+			} = originalColumn
 			if (deepEqual(updatedDefinition, originalDefinition)) {
 				return undefined
 			}
-			return UpdateColumnDefinitionModification.createModification({
+
+			return updateColumnDefinitionModification.createModification({
 				entityName: updatedEntity.name,
 				fieldName: updatedColumn.name,
 				definition: updatedDefinition,
@@ -99,21 +128,3 @@ export const UpdateColumnDefinitionModification: ModificationHandlerStatic<Updat
 		})
 	}
 }
-
-type SequenceDefinitionAlter =
-	& Model.AnyColumn['sequence']
-	& {
-		restart?: boolean
-	}
-
-type ColumnDefinitionAlter =
-	& Model.AnyColumn
-	& {
-		sequence?: SequenceDefinitionAlter
-	}
-
-export interface UpdateColumnDefinitionModificationData {
-	entityName: string
-	fieldName: string
-	definition: ColumnDefinitionAlter
-}

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,9 +1,8 @@
 import { Differ } from '../ModificationHandler'
-import { Model, Schema } from '@contember/schema'
+import { Schema } from '@contember/schema'
 import deepEqual from 'fast-deep-equal'
-import { RemoveEntityModification } from '../entities'
-import { getViewDirectDependants } from '../utils/viewDependencies'
-import { Migration } from '../../Migration'
+import { cascadeRemoveDependantViews } from '../utils/viewDependencies'
+import { UpdateColumnDefinitionDiffer } from '../columns'
 
 export class RemoveChangedViewDiffer implements Differ {
 	constructor() {
@@ -18,25 +17,13 @@ export class RemoveChangedViewDiffer implements Differ {
 				}
 				return !deepEqual(updatedEntity.view, it.view)
 			})
-		if (changedViews.length === 0) {
+		const columnDiffer = new UpdateColumnDefinitionDiffer()
+		const columnChanges = columnDiffer.createDiff(originalSchema, updatedSchema)
+		if (changedViews.length === 0 && columnChanges.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
+		const changedColumnsEntities = Array.from(new Set(columnChanges.map(it => it.entityName)))
+			.map(it => originalSchema.model.entities[it])
+		return cascadeRemoveDependantViews(originalSchema.model, [...changedViews, ...changedColumnsEntities])
 	}
 }

package/src/modifications/entities/CreateEntityModification.ts

@@ -1,12 +1,17 @@
 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'
+import { getColumnSqlType } from '../utils/columnUtils'
 
-export const CreateEntityModification: ModificationHandlerStatic<CreateEntityModificationData> = class {
-	static id = 'createEntity'
+export class CreateEntityModificationHandler implements ModificationHandler<CreateEntityModificationData> {
 	constructor(
 		private readonly data: CreateEntityModificationData,
 		private readonly schema: Schema,
@@ -25,7 +30,7 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 		builder.createTable(entity.tableName, {
 			[primaryColumn.name]: {
 				primaryKey: true,
-				type: primaryColumn.type === Model.ColumnType.Enum ? `"${primaryColumn.columnType}"` : primaryColumn.columnType,
+				type: getColumnSqlType(primaryColumn),
 				notNull: true,
 				sequenceGenerated: primaryColumn.sequence,
 			},
@@ -56,16 +61,20 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 		return { message: `Add entity ${this.data.entity.name}` }
 	}
 
-	static createModification(data: CreateEntityModificationData) {
-		return { modification: this.id, ...data }
-	}
+}
+
+export const createEntityModification = createModificationType({
+	id: 'createEntity',
+	handler: CreateEntityModificationHandler,
+})
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+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: {