@contember/schema-migrations 1.1.1 → 1.2.0-alpha.10

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,
@@ -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,17 +13,15 @@ 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'
 
-export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldNameModificationData> = class {
-	static id = 'updateFieldName'
-
+export class UpdateFieldNameModificationHandler implements ModificationHandler<UpdateFieldNameModificationData> {
 	private renameColumnSubModification: ModificationHandler<any> = new NoopModification()
 
 	constructor(
@@ -32,7 +30,7 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 		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,
@@ -192,10 +190,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 +198,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'

package/src/modifications/indexes/CreateIndexModification.ts

@@ -0,0 +1,83 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model, Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+
+export class CreateIndexModificationHandler implements ModificationHandler<CreateIndexModificationData> {
+	constructor(private readonly data: CreateIndexModificationData, private readonly schema: Schema) {}
+
+	public createSql(builder: MigrationBuilder): void {
+		const entity = this.schema.model.entities[this.data.entityName]
+		if (entity.view) {
+			return
+		}
+		const fields = this.data.index.fields
+		const columns = fields.map(fieldName => {
+			return acceptFieldVisitor(this.schema.model, entity, fieldName, {
+				visitColumn: ({}, column) => {
+					return column.columnName
+				},
+				visitManyHasOne: ({}, relation) => {
+					return relation.joiningColumn.columnName
+				},
+				visitOneHasOneOwning: ({}, relation) => {
+					return relation.joiningColumn.columnName
+				},
+				visitOneHasMany: () => {
+					throw new Error(`Cannot create index on 1:m relation in ${entity.name}.${fieldName}`)
+				},
+				visitOneHasOneInverse: () => {
+					throw new Error(`Cannot create index on 1:1 inverse relation in ${entity.name}.${fieldName}`)
+				},
+				visitManyHasManyOwning: () => {
+					throw new Error(`Cannot create index on m:m relation in ${entity.name}.${fieldName}`)
+				},
+				visitManyHasManyInverse: () => {
+					throw new Error(`Cannot create index on m:m inverse relation in ${entity.name}.${fieldName}`)
+				},
+			})
+		})
+		builder.addIndex(entity.tableName, [...columns], {
+			name: this.data.index.name,
+		})
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return updateModel(
+			updateEntity(this.data.entityName, ({ entity }) => ({
+				...entity,
+				indexes: {
+					...entity.indexes,
+					[this.data.index.name]: this.data.index,
+				},
+			})),
+		)
+	}
+
+	describe() {
+		return {
+			message: `Create index(${this.data.index.fields.join(', ')}) on entity ${this.data.entityName}`,
+		}
+	}
+}
+
+export const createIndexModification = createModificationType({
+	id: 'createIndex',
+	handler: CreateIndexModificationHandler,
+})
+
+export class CreateIndexDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.values(updatedSchema.model.entities).flatMap(entity =>
+			Object.values(entity.indexes)
+				.filter(it => !originalSchema.model.entities[entity.name].indexes[it.name])
+				.map(index => createIndexModification.createModification({ entityName: entity.name, index })),
+		)
+	}
+}
+
+export interface CreateIndexModificationData {
+	entityName: string
+	index: Model.Index
+}

package/src/modifications/indexes/RemoveIndexModification.ts

@@ -0,0 +1,68 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import deepEqual from 'fast-deep-equal'
+
+export class RemoveIndexModificationHandler implements ModificationHandler<RemoveIndexModificationData>  {
+	constructor(private readonly data: RemoveIndexModificationData, private readonly schema: Schema) {}
+
+	public createSql(builder: MigrationBuilder): void {
+		const entity = this.schema.model.entities[this.data.entityName]
+		if (entity.view) {
+			return
+		}
+		builder.dropIndex(entity.tableName, [], {
+			name: this.data.indexName,
+		})
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return updateModel(
+			updateEntity(this.data.entityName, ({ entity }) => {
+				const { [this.data.indexName]: removed, ...indexes } = entity.indexes
+				return {
+					...entity,
+					indexes,
+				}
+			}),
+		)
+	}
+
+	describe() {
+		const fields = this.schema.model.entities[this.data.entityName].indexes[this.data.indexName].fields
+		return { message: `Remove index (${fields.join(', ')}) on entity ${this.data.entityName}` }
+	}
+}
+
+export const removeIndexModification = createModificationType({
+	id: 'removeIndex',
+	handler: RemoveIndexModificationHandler,
+})
+
+
+export class RemoveIndexDiffer implements Differ {
+
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.values(originalSchema.model.entities).flatMap(entity =>
+			Object.values(entity.indexes)
+				.filter(
+					it =>
+						updatedSchema.model.entities[entity.name] &&
+						(!updatedSchema.model.entities[entity.name].indexes[it.name] ||
+							!deepEqual(it.fields, updatedSchema.model.entities[entity.name].indexes[it.name].fields)),
+				)
+				.map(index =>
+					removeIndexModification.createModification({
+						entityName: entity.name,
+						indexName: index.name,
+					}),
+				),
+		)
+	}
+}
+
+export interface RemoveIndexModificationData {
+	entityName: string
+	indexName: string
+}

package/src/modifications/indexes/index.ts

@@ -0,0 +1,2 @@
+export * from './CreateIndexModification'
+export * from './RemoveIndexModification'

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

@@ -1,16 +1,20 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
-import { ModificationHandler, ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
 import { isInverseRelation, isOwningRelation } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
-import { UpdateFieldNameModification } from '../fields'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
 import { wrapIdentifier } from '@contember/database'
 import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
+import { updateFieldNameModification } from '../fields'
 
-export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHandlerStatic<ConvertOneHasManyToManyHasManyRelationModificationData> = class {
-	static id = 'convertOneHasManyToManyHasManyRelation'
+export class ConvertOneHasManyToManyHasManyRelationModificationHandler implements ModificationHandler<ConvertOneHasManyToManyHasManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
@@ -18,7 +22,7 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 		private readonly schema: Schema,
 		private readonly options: ModificationHandlerOptions,
 	) {
-		this.subModification = new UpdateFieldNameModification(
+		this.subModification = updateFieldNameModification.createHandler(
 			{
 				entityName: this.data.entityName,
 				fieldName: this.data.fieldName,
@@ -63,11 +67,33 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 		}
 	}
 
-	static createModification(data: ConvertOneHasManyToManyHasManyRelationModificationData) {
-		return { modification: this.id, ...data }
+
+
+
+	private getRelation(): { entity: Model.Entity; relation: Model.ManyHasOneRelation } {
+		const entity = this.schema.model.entities[this.data.entityName]
+		const relation = entity.fields[this.data.fieldName]
+		if (relation.type !== Model.RelationType.ManyHasOne) {
+			throw new Error()
+		}
+		return { entity, relation }
 	}
+}
+
+export const convertOneHasManyToManyHasManyRelationModification = createModificationType({
+	id: 'convertOneHasManyToManyHasManyRelation',
+	handler: ConvertOneHasManyToManyHasManyRelationModificationHandler,
+})
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export interface ConvertOneHasManyToManyHasManyRelationModificationData {
+	entityName: string
+	fieldName: string
+	owningSide: PartialManyHasManyRelation
+	inverseSide?: Model.ManyHasManyInverseRelation
+}
+
+export class ConvertOneHasManyToManyHasManyRelationDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				isInverseRelation(originalRelation) &&
@@ -81,7 +107,7 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 				if (owningSide.type !== Model.RelationType.ManyHasMany || !isOwningRelation(owningSide)) {
 					throw new Error()
 				}
-				return ConvertOneHasManyToManyHasManyRelationModification.createModification({
+				return convertOneHasManyToManyHasManyRelationModification.createModification({
 					entityName: updatedRelation.target,
 					fieldName: owningOldName,
 					owningSide,
@@ -91,20 +117,4 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 			return undefined
 		})
 	}
-
-	private getRelation(): { entity: Model.Entity; relation: Model.ManyHasOneRelation } {
-		const entity = this.schema.model.entities[this.data.entityName]
-		const relation = entity.fields[this.data.fieldName]
-		if (relation.type !== Model.RelationType.ManyHasOne) {
-			throw new Error()
-		}
-		return { entity, relation }
-	}
-}
-
-export interface ConvertOneHasManyToManyHasManyRelationModificationData {
-	entityName: string
-	fieldName: string
-	owningSide: PartialManyHasManyRelation
-	inverseSide?: Model.ManyHasManyInverseRelation
 }

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -1,14 +1,18 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
-import { ModificationHandler, ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
 import { isOwningRelation, NamingHelper } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
-import { UpdateFieldNameModification } from '../fields'
 import { NoopModification } from '../NoopModification'
+import { updateFieldNameModification } from '../fields'
 
-export const ConvertOneToManyRelationModification: ModificationHandlerStatic<ConvertOneToManyRelationModificationData> = class {
-	static id = 'convertOneToManyRelation'
+export class ConvertOneToManyRelationModificationHandler implements ModificationHandler<ConvertOneToManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
@@ -18,7 +22,7 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 	) {
 		const { relation } = this.getRelation()
 		this.subModification = data.newInverseSideFieldName && relation.inversedBy ?
-			new UpdateFieldNameModification(
+			updateFieldNameModification.createHandler(
 				{
 					entityName: relation.target,
 					fieldName: relation.inversedBy,
@@ -77,11 +81,29 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 		}
 	}
 
-	static createModification(data: ConvertOneToManyRelationModificationData) {
-		return { modification: this.id, ...data }
+	private getRelation() {
+		const entity = this.schema.model.entities[this.data.entityName]
+		const relation = entity.fields[this.data.fieldName]
+		if (relation.type !== Model.RelationType.OneHasOne || !isOwningRelation(relation)) {
+			throw new Error()
+		}
+		return { entity, relation }
 	}
+}
+
+export interface ConvertOneToManyRelationModificationData {
+	entityName: string
+	fieldName: string
+	newInverseSideFieldName?: string
+}
+
+export const convertOneToManyRelationModification = createModificationType({
+	id: 'convertOneToManyRelation',
+	handler: ConvertOneToManyRelationModificationHandler,
+})
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export class ConvertOneToManyRelationDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				isOwningRelation(originalRelation) &&
@@ -90,7 +112,7 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 				updatedRelation.type === Model.RelationType.ManyHasOne
 			) {
 				const isInverseSideRenamed = originalRelation.inversedBy && updatedRelation.inversedBy && originalRelation.inversedBy !== updatedRelation.inversedBy
-				return ConvertOneToManyRelationModification.createModification({
+				return convertOneToManyRelationModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
 					...(isInverseSideRenamed ? {
@@ -101,19 +123,4 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 			return undefined
 		})
 	}
-
-	private getRelation() {
-		const entity = this.schema.model.entities[this.data.entityName]
-		const relation = entity.fields[this.data.fieldName]
-		if (relation.type !== Model.RelationType.OneHasOne || !isOwningRelation(relation)) {
-			throw new Error()
-		}
-		return { entity, relation }
-	}
-}
-
-export interface ConvertOneToManyRelationModificationData {
-	entityName: string
-	fieldName: string
-	newInverseSideFieldName?: string
 }

package/src/modifications/relations/CreateRelationInverseSideModification.ts

@@ -1,12 +1,11 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { addField, SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { createFields } from '../utils/diffUtils'
 import { isInverseRelation, isRelation } from '@contember/schema-utils'
 
-export const CreateRelationInverseSideModification: ModificationHandlerStatic<CreateRelationInverseSideModificationData> = class {
-	static id = 'createRelationInverseSide'
+export class CreateRelationInverseSideModificationHandler implements ModificationHandler<CreateRelationInverseSideModificationData> {
 	constructor(private readonly data: CreateRelationInverseSideModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {}
@@ -27,25 +26,28 @@ export const CreateRelationInverseSideModification: ModificationHandlerStatic<Cr
 	describe() {
 		return { message: `Add relation ${this.data.entityName}.${this.data.relation.name}` }
 	}
+}
 
-	static createModification(data: CreateRelationInverseSideModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface CreateRelationInverseSideModificationData {
+	entityName: string
+	relation: Model.AnyRelation & Model.InverseRelation
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const createRelationInverseSideModification = createModificationType({
+	id: 'createRelationInverseSide',
+	handler: CreateRelationInverseSideModificationHandler,
+})
+
+export class CreateRelationInverseSideDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return createFields(originalSchema, updatedSchema, ({ newField, updatedEntity }) => {
 			if (!isRelation(newField) || !isInverseRelation(newField)) {
 				return undefined
 			}
-			return CreateRelationInverseSideModification.createModification({
+			return createRelationInverseSideModification.createModification({
 				entityName: updatedEntity.name,
 				relation: newField,
 			})
 		})
 	}
 }
-
-export interface CreateRelationInverseSideModificationData {
-	entityName: string
-	relation: Model.AnyRelation & Model.InverseRelation
-}