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

package/src/modifications/entities/CreateViewModification.ts

@@ -1,12 +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 {
@@ -35,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)
@@ -54,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,
 			}))
 		}

package/src/modifications/entities/RemoveEntityModification.ts

@@ -11,17 +11,21 @@ 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'
+import { SchemaWithMeta } from '../utils/schemaMeta'
 
+export class RemoveEntityModificationHandler implements ModificationHandler<RemoveEntityModificationData> {
 	constructor(
 		private readonly data: RemoveEntityModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {}
 
@@ -33,7 +37,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 +108,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,26 +11,26 @@ 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'
+import { SchemaWithMeta } from '../utils/schemaMeta'
 
-export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntityNameModificationData> = class {
-	static id = 'updateEntityName'
+export class UpdateEntityNameModificationHandler implements ModificationHandler<UpdateEntityNameModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: UpdateEntityNameModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		this.subModification = data.tableName
-			? new UpdateEntityTableNameModification(
+			? updateEntityTableNameModification.createHandler(
 				{ entityName: data.entityName, tableName: data.tableName },
 				schema,
 				this.options,
@@ -124,10 +124,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 +131,8 @@ export interface UpdateEntityNameModificationData {
 	newEntityName: string
 	tableName?: string
 }
+
+export const updateEntityNameModification = createModificationType({
+	id: 'updateEntityName',
+	handler: UpdateEntityNameModificationHandler,
+})

package/src/modifications/entities/UpdateEntityTableNameModification.ts

@@ -1,10 +1,9 @@
 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'
 
-export const UpdateEntityTableNameModification: ModificationHandlerStatic<UpdateEntityTableNameModificationData> = class {
-	static id = 'updateEntityTableName'
+export class UpdateEntityTableNameModificationHandler implements ModificationHandler<UpdateEntityTableNameModificationData> {
 	constructor(private readonly data: UpdateEntityTableNameModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -28,22 +27,28 @@ export const UpdateEntityTableNameModification: ModificationHandlerStatic<Update
 	describe() {
 		return { message: `Change table name of entity ${this.data.entityName}` }
 	}
+}
 
-	static createModification(data: UpdateEntityTableNameModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface UpdateEntityTableNameModificationData {
+	entityName: string
+	tableName: string
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const updateEntityTableNameModification = createModificationType({
+	id: 'updateEntityTableName',
+	handler: UpdateEntityTableNameModificationHandler,
+})
+
+export class UpdateEntityTableNameDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(updatedSchema.model.entities)
 			.filter(
 				it =>
 					originalSchema.model.entities[it.name] && originalSchema.model.entities[it.name].tableName !== it.tableName,
 			)
-			.map(it => UpdateEntityTableNameModification.createModification({ entityName: it.name, tableName: it.tableName }))
+			.map(it => updateEntityTableNameModification.createModification({
+				entityName: it.name,
+				tableName: it.tableName,
+			}))
 	}
 }
-
-export interface UpdateEntityTableNameModificationData {
-	entityName: string
-	tableName: string
-}

package/src/modifications/entities/UpdateViewModification.ts

@@ -1,11 +1,9 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, ModificationHandler } from '../ModificationHandler'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 
-export const UpdateViewModification: ModificationHandlerStatic<UpdateViewModificationData> = class {
-	static id = 'updateView'
-
+export class UpdateViewModificationHandler implements ModificationHandler<UpdateViewModificationData> {
 	constructor(private readonly data: UpdateViewModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -32,12 +30,14 @@ export const UpdateViewModification: ModificationHandlerStatic<UpdateViewModific
 		return { message: `Update SQL definition of a view` }
 	}
 
-	static createModification(data: UpdateViewModificationData) {
-		return { modification: this.id, ...data }
-	}
 }
 
 export interface UpdateViewModificationData {
 	entityName: string
 	view: Model.View
 }
+
+export const updateViewModification = createModificationType({
+	id: 'updateView',
+	handler: UpdateViewModificationHandler,
+})

package/src/modifications/enums/CreateEnumModification.ts

@@ -1,11 +1,10 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { createCheck, getConstraintName } from './enumUtils'
 
-export const CreateEnumModification: ModificationHandlerStatic<CreateEnumModificationData> = class {
-	static id = 'createEnum'
+export class CreateEnumModificationHandler implements ModificationHandler<CreateEnumModificationData> {
 	constructor(private readonly data: CreateEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -28,19 +27,25 @@ export const CreateEnumModification: ModificationHandlerStatic<CreateEnumModific
 	describe() {
 		return { message: `Add enum ${this.data.enumName}` }
 	}
-
-	static createModification(data: CreateEnumModificationData) {
-		return { modification: this.id, ...data }
-	}
-
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
-		return Object.entries(updatedSchema.model.enums)
-			.filter(([name]) => !originalSchema.model.enums[name])
-			.map(([enumName, values]) => CreateEnumModification.createModification({ enumName, values }))
-	}
 }
 
 export interface CreateEnumModificationData {
 	enumName: string
 	values: readonly string[]
 }
+
+export const createEnumModification = createModificationType({
+	id: 'createEnum',
+	handler: CreateEnumModificationHandler,
+})
+
+export class CreateEnumDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.model.enums)
+			.filter(([name]) => !originalSchema.model.enums[name])
+			.map(([enumName, values]) => createEnumModification.createModification({
+				enumName,
+				values,
+			}))
+	}
+}

package/src/modifications/enums/RemoveEnumModification.ts

@@ -1,10 +1,9 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 
-export const RemoveEnumModification: ModificationHandlerStatic<RemoveEnumModificationData> = class {
-	static id = 'removeEnum'
+export class RemoveEnumModificationHandler implements ModificationHandler<RemoveEnumModificationData> {
 	constructor(private readonly data: RemoveEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -24,18 +23,21 @@ export const RemoveEnumModification: ModificationHandlerStatic<RemoveEnumModific
 	describe() {
 		return { message: `Remove ${this.data.enumName}` }
 	}
+}
 
-	static createModification(data: RemoveEnumModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface RemoveEnumModificationData {
+	enumName: string
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const removeEnumModification = createModificationType({
+	id: 'removeEnum',
+	handler: RemoveEnumModificationHandler,
+})
+
+export class RemoveEnumDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.entries(originalSchema.model.enums)
 			.filter(([name]) => !updatedSchema.model.enums[name])
-			.map(([enumName, values]) => RemoveEnumModification.createModification({ enumName }))
+			.map(([enumName, values]) => removeEnumModification.createModification({ enumName }))
 	}
 }
-
-export interface RemoveEnumModificationData {
-	enumName: string
-}

package/src/modifications/enums/UpdateEnumModification.ts

@@ -1,12 +1,11 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { createCheck, getConstraintName } from './enumUtils'
 
-export const UpdateEnumModification: ModificationHandlerStatic<UpdateEnumModificationData> = class {
-	static id = 'updateEnum'
+export class UpdateEnumModificationHandler implements ModificationHandler<UpdateEnumModificationData> {
 	constructor(private readonly data: UpdateEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -37,23 +36,26 @@ export const UpdateEnumModification: ModificationHandlerStatic<UpdateEnumModific
 				: undefined
 		return { message: `Update enum ${this.data.enumName}`, failureWarning }
 	}
+}
 
-	static createModification(data: UpdateEnumModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface UpdateEnumModificationData {
+	enumName: string
+	values: readonly string[]
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const updateEnumModification = createModificationType({
+	id: 'updateEnum',
+	handler: UpdateEnumModificationHandler,
+})
+
+export class UpdateEnumDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.entries(updatedSchema.model.enums)
 			.filter(
 				([name]) =>
 					originalSchema.model.enums[name] &&
 					!deepEqual(updatedSchema.model.enums[name], originalSchema.model.enums[name]),
 			)
-			.map(([enumName, values]) => UpdateEnumModification.createModification({ enumName, values }))
+			.map(([enumName, values]) => updateEnumModification.createModification({ enumName, values }))
 	}
 }
-
-export interface UpdateEnumModificationData {
-	enumName: string
-	values: readonly string[]
-}

package/src/modifications/fields/RemoveFieldModification.ts

@@ -2,11 +2,10 @@ import { acceptFieldVisitor, isInverseRelation, isRelation, NamingHelper } from
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { removeField, SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler, ModificationHandlerOptions } from '../ModificationHandler'
 import { isDefined } from '../../utils/isDefined'
 
-export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModificationData> = class {
-	static id = 'removeField'
+export class RemoveFieldModificationHandler implements ModificationHandler<RemoveFieldModificationData> {
 
 	constructor(
 		private readonly data: RemoveFieldModificationData,
@@ -20,19 +19,19 @@ export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModif
 			return
 		}
 		acceptFieldVisitor(this.schema.model, this.data.entityName, this.data.fieldName, {
-			visitColumn: (entity, column) => {
+			visitColumn: ({ entity, column }) => {
 				builder.dropColumn(entity.tableName, column.columnName)
 			},
-			visitManyHasOne: (entity, relation, {}, _) => {
+			visitManyHasOne: ({ entity, relation }) => {
 				builder.dropColumn(entity.tableName, relation.joiningColumn.columnName)
 			},
 			visitOneHasMany: () => {},
-			visitOneHasOneOwning: (entity, relation, {}, _) => {
+			visitOneHasOneOwning: ({ entity, relation }) => {
 				builder.dropConstraint(entity.tableName, NamingHelper.createUniqueConstraintName(entity.name, [relation.name]))
 				builder.dropColumn(entity.tableName, relation.joiningColumn.columnName)
 			},
 			visitOneHasOneInverse: () => {},
-			visitManyHasManyOwning: ({}, relation, {}, _) => {
+			visitManyHasManyOwning: ({ relation }) => {
 				builder.dropTable(relation.joiningTable.tableName)
 			},
 			visitManyHasManyInverse: () => {},
@@ -47,11 +46,20 @@ export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModif
 		return { message: `Remove field ${this.data.entityName}.${this.data.fieldName}`, isDestructive: true }
 	}
 
-	static createModification(data: RemoveFieldModificationData) {
-		return { modification: this.id, ...data }
-	}
+}
+
+export interface RemoveFieldModificationData {
+	entityName: string
+	fieldName: string
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const removeFieldModification = createModificationType({
+	id: 'removeField',
+	handler: RemoveFieldModificationHandler,
+})
+
+export class RemoveFieldDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(updatedSchema.model.entities)
 			.filter(({ name }) => originalSchema.model.entities[name])
 			.flatMap(entity => {
@@ -66,7 +74,7 @@ export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModif
 								return undefined
 							}
 						}
-						return RemoveFieldModification.createModification({
+						return removeFieldModification.createModification({
 							entityName: entity.name,
 							fieldName: field.name,
 						})
@@ -75,8 +83,3 @@ export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModif
 			})
 	}
 }
-
-export interface RemoveFieldModificationData {
-	entityName: string
-	fieldName: string
-}

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -13,26 +13,25 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { ModificationHandler, ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, ModificationHandler, ModificationHandlerOptions } from '../ModificationHandler'
 import { acceptFieldVisitor, NamingHelper, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { VERSION_ACL_PATCH, VERSION_UPDATE_CONSTRAINT_NAME } from '../ModificationVersions'
 import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../utils/renameConstraintsHelper'
 import { changeValue } from '../utils/valueUtils'
-import { UpdateColumnNameModification } from '../columns'
+import { updateColumnNameModification } from '../columns'
 import { NoopModification } from '../NoopModification'
+import { SchemaWithMeta } from '../utils/schemaMeta'
 
-export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldNameModificationData> = class {
-	static id = 'updateFieldName'
-
+export class UpdateFieldNameModificationHandler implements ModificationHandler<UpdateFieldNameModificationData> {
 	private renameColumnSubModification: ModificationHandler<any> = new NoopModification()
 
 	constructor(
 		private readonly data: UpdateFieldNameModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		if (this.data.columnName) {
-			this.renameColumnSubModification = new UpdateColumnNameModification({
+			this.renameColumnSubModification = updateColumnNameModification.createHandler({
 				entityName: this.data.entityName,
 				columnName: this.data.columnName,
 				fieldName: this.data.fieldName,
@@ -81,33 +80,33 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 				}
 
 				return acceptFieldVisitor<Model.AnyField>(this.schema.model, entity, field, {
-					visitColumn: (entity, field) => field,
-					visitManyHasOne: (entity, relation, targetEntity, targetRelation) => {
+					visitColumn: ({ column }) => column,
+					visitManyHasOne: ({ targetEntity, relation, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, inversedBy: this.data.newFieldName }
 							: relation
 					},
-					visitOneHasMany: (entity, relation, targetEntity, targetRelation) => {
+					visitOneHasMany: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, ownedBy: this.data.newFieldName }
 							: relation
 					},
-					visitOneHasOneOwning: (entity, relation, targetEntity, targetRelation) => {
+					visitOneHasOneOwning: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, inversedBy: this.data.newFieldName }
 							: relation
 					},
-					visitOneHasOneInverse: (entity, relation, targetEntity, targetRelation) => {
+					visitOneHasOneInverse: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, ownedBy: this.data.newFieldName }
 							: relation
 					},
-					visitManyHasManyOwning: (entity, relation, targetEntity, targetRelation) => {
+					visitManyHasManyOwning: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, inversedBy: this.data.newFieldName }
 							: relation
 					},
-					visitManyHasManyInverse: (entity, relation, targetEntity, targetRelation) => {
+					visitManyHasManyInverse: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, ownedBy: this.data.newFieldName }
 							: relation
@@ -192,10 +191,6 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 	describe() {
 		return { message: `Change field name ${this.data.entityName}.${this.data.fieldName} to ${this.data.newFieldName}` }
 	}
-
-	static createModification(data: UpdateFieldNameModificationData) {
-		return { modification: this.id, ...data }
-	}
 }
 
 export interface UpdateFieldNameModificationData {
@@ -204,3 +199,8 @@ export interface UpdateFieldNameModificationData {
 	newFieldName: string
 	columnName?: string
 }
+
+export const updateFieldNameModification = createModificationType({
+	id: 'updateFieldName',
+	handler: UpdateFieldNameModificationHandler,
+})

package/src/modifications/index.ts

@@ -0,0 +1,13 @@
+export * from './acl'
+export * from './columns'
+export * from './constraints'
+export * from './entities'
+export * from './enums'
+export * from './fields'
+export * from './relations'
+export * from './validation'
+export * from './ModificationHandlerFactory'
+export * from './ModificationVersions'
+export * from './ModificationHandler'
+export { SchemaUpdateError } from './exceptions'
+export * from './utils/sqlUpdateUtils'