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

package/src/modifications/indexes/CreateIndexModification.ts

@@ -1,12 +1,10 @@
 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 CreateIndexModification: ModificationHandlerStatic<CreateIndexModificationData> = class {
-	static id = 'createIndex'
-
+export class CreateIndexModificationHandler implements ModificationHandler<CreateIndexModificationData> {
 	constructor(private readonly data: CreateIndexModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -17,13 +15,13 @@ export const CreateIndexModification: ModificationHandlerStatic<CreateIndexModif
 		const fields = this.data.index.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
 				},
-				visitOneHasOneOwning: ({}, relation) => {
+				visitOneHasOneOwning: ({ relation }) => {
 					return relation.joiningColumn.columnName
 				},
 				visitOneHasMany: () => {
@@ -62,16 +60,19 @@ export const CreateIndexModification: ModificationHandlerStatic<CreateIndexModif
 			message: `Create index(${this.data.index.fields.join(', ')}) on entity ${this.data.entityName}`,
 		}
 	}
+}
 
-	static createModification(data: CreateIndexModificationData) {
-		return { modification: this.id, ...data }
-	}
+export const createIndexModification = createModificationType({
+	id: 'createIndex',
+	handler: CreateIndexModificationHandler,
+})
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+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 })),
+				.map(index => createIndexModification.createModification({ entityName: entity.name, index })),
 		)
 	}
 }

package/src/modifications/indexes/RemoveIndexModification.ts

@@ -1,11 +1,10 @@
 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 RemoveIndexModification: ModificationHandlerStatic<RemoveIndexModificationData> = class {
-	static id = 'removeIndex'
+export class RemoveIndexModificationHandler implements ModificationHandler<RemoveIndexModificationData>  {
 	constructor(private readonly data: RemoveIndexModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -34,12 +33,17 @@ export const RemoveIndexModification: ModificationHandlerStatic<RemoveIndexModif
 		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}` }
 	}
+}
 
-	static createModification(data: RemoveIndexModificationData) {
-		return { modification: this.id, ...data }
-	}
+export const removeIndexModification = createModificationType({
+	id: 'removeIndex',
+	handler: RemoveIndexModificationHandler,
+})
+
+
+export class RemoveIndexDiffer implements Differ {
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(originalSchema.model.entities).flatMap(entity =>
 			Object.values(entity.indexes)
 				.filter(
@@ -49,7 +53,7 @@ export const RemoveIndexModification: ModificationHandlerStatic<RemoveIndexModif
 							!deepEqual(it.fields, updatedSchema.model.entities[entity.name].indexes[it.name].fields)),
 				)
 				.map(index =>
-					RemoveIndexModification.createModification({
+					removeIndexModification.createModification({
 						entityName: entity.name,
 						indexName: index.name,
 					}),

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

@@ -1,24 +1,36 @@
 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 { isInverseRelation, isOwningRelation } from '@contember/schema-utils'
+import {
+	addField,
+	addTakenIndexName,
+	SchemaUpdater,
+	updateEntity,
+	updateModel,
+	updateSchema,
+} from '../utils/schemaUpdateUtils'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
+import { isInverseRelation, isOwningRelation, NamingHelper } 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'
+import { SchemaWithMeta } from '../utils/schemaMeta'
 
-export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHandlerStatic<ConvertOneHasManyToManyHasManyRelationModificationData> = class {
-	static id = 'convertOneHasManyToManyHasManyRelation'
+export class ConvertOneHasManyToManyHasManyRelationModificationHandler implements ModificationHandler<ConvertOneHasManyToManyHasManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: ConvertOneHasManyToManyHasManyRelationModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
-		this.subModification = new UpdateFieldNameModification(
+		this.subModification = updateFieldNameModification.createHandler(
 			{
 				entityName: this.data.entityName,
 				fieldName: this.data.fieldName,
@@ -34,7 +46,7 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 		const { relation: oldRelation } = this.getRelation()
 		const entity = this.schema.model.entities[this.data.entityName]
 
-		createJunctionTableSql(builder, this.options.systemSchema, entity, targetEntity, normalizeManyHasManyRelation(this.data.owningSide))
+		createJunctionTableSql(builder, this.options.systemSchema, this.schema, entity, targetEntity, normalizeManyHasManyRelation(this.data.owningSide))
 		const joiningTable = this.data.owningSide.joiningTable
 		builder.sql(`
 			INSERT INTO ${wrapIdentifier(joiningTable.tableName)} (
@@ -54,6 +66,7 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 			this.subModification.getSchemaUpdater(),
 			updateModel(updateEntity(entityName, addField(normalizeManyHasManyRelation(this.data.owningSide)))),
 			this.data.inverseSide ? updateModel(updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))) : undefined,
+			addTakenIndexName(NamingHelper.createJunctionTablePrimaryConstraintName(this.data.owningSide.joiningTable.tableName)),
 		)
 	}
 
@@ -63,11 +76,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 +116,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 +126,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,24 +1,36 @@
 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 {
+	addTakenIndexName,
+	SchemaUpdater,
+	updateEntity,
+	updateField,
+	updateModel,
+	updateSchema,
+} from '../utils/schemaUpdateUtils'
+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'
+import { resolveIndexName, SchemaWithMeta } from '../utils/schemaMeta'
 
-export const ConvertOneToManyRelationModification: ModificationHandlerStatic<ConvertOneToManyRelationModificationData> = class {
-	static id = 'convertOneToManyRelation'
+export class ConvertOneToManyRelationModificationHandler implements ModificationHandler<ConvertOneToManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: ConvertOneToManyRelationModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		const { relation } = this.getRelation()
 		this.subModification = data.newInverseSideFieldName && relation.inversedBy ?
-			new UpdateFieldNameModification(
+			updateFieldNameModification.createHandler(
 				{
 					entityName: relation.target,
 					fieldName: relation.inversedBy,
@@ -32,7 +44,12 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 
 	public createSql(builder: MigrationBuilder): void {
 		const { entity, relation } = this.getRelation()
-		builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
+		const columnName = relation.joiningColumn.columnName
+		const proposedIndexName = NamingHelper.createForeignKeyIndexName(entity.tableName, columnName)
+		const indexName = resolveIndexName(this.schema, proposedIndexName)
+		builder.addIndex(entity.tableName, columnName, {
+			name: indexName,
+		})
 		const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
 		builder.dropConstraint(entity.tableName, uniqueConstraintName)
 		this.subModification.createSql(builder)
@@ -41,6 +58,8 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 	public getSchemaUpdater(): SchemaUpdater {
 		const { relation } = this.getRelation()
 		const { entityName, fieldName } = this.data
+		const entity = this.schema.model.entities[this.data.entityName]
+		const field = entity.fields[fieldName] as Model.OneHasOneOwningRelation
 		return updateSchema(
 			updateModel(
 				updateEntity(
@@ -68,6 +87,7 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 						),
 					),
 				) : undefined,
+			addTakenIndexName(NamingHelper.createForeignKeyIndexName(entity.tableName, field.joiningColumn.columnName)),
 		)
 	}
 
@@ -77,11 +97,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
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const convertOneToManyRelationModification = createModificationType({
+	id: 'convertOneToManyRelation',
+	handler: ConvertOneToManyRelationModificationHandler,
+})
+
+export class ConvertOneToManyRelationDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				isOwningRelation(originalRelation) &&
@@ -90,7 +128,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 +139,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
-}

package/src/modifications/relations/CreateRelationModification.ts

@@ -7,21 +7,33 @@ import {
 	NamingHelper,
 } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import {
+	addField,
+	addTakenIndexName,
+	SchemaUpdater,
+	updateEntity,
+	updateModel,
+	updateSchema,
+} from '../utils/schemaUpdateUtils'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
 import { createFields } from '../utils/diffUtils'
 import { getPrimaryColumnType } from '../utils/getPrimaryColumnType'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
 import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
+import { resolveIndexName, SchemaWithMeta } from '../utils/schemaMeta'
 
 
-export const CreateRelationModification: ModificationHandlerStatic<CreateRelationModificationData> = class {
-	static id = 'createRelation'
+export class CreateRelationModificationHandler implements ModificationHandler<CreateRelationModificationData> {
 
 	constructor(
 		private readonly data: CreateRelationModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {}
 
@@ -55,29 +67,43 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 			})
 		}
 		acceptRelationTypeVisitor(this.schema.model, entity, this.getNormalizedOwningSide(), {
-			visitManyHasOne: ({}, relation, {}, _) => {
+			visitManyHasOne: ({ relation }) => {
 				createOwningSide(relation)
-				builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
+				const columnName = relation.joiningColumn.columnName
+				const proposedIndexName = NamingHelper.createForeignKeyIndexName(entity.tableName, columnName)
+				const indexName = resolveIndexName(this.schema, proposedIndexName)
+				builder.addIndex(entity.tableName, columnName, {
+					name: indexName,
+				})
 			},
 			visitOneHasMany: () => {},
-			visitOneHasOneOwning: ({}, relation, {}, _) => {
+			visitOneHasOneOwning: ({ relation }) => {
 				createOwningSide(relation)
 				const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
 				builder.addConstraint(entity.tableName, uniqueConstraintName, { unique: [relation.joiningColumn.columnName] })
 			},
 			visitOneHasOneInverse: () => {},
-			visitManyHasManyOwning: ({}, relation, {}, _) => {
-				createJunctionTableSql(builder, this.options.systemSchema,  entity, targetEntity, relation)
+			visitManyHasManyOwning: ({ relation }) => {
+				createJunctionTableSql(builder, this.options.systemSchema, this.schema, entity, targetEntity, relation)
 			},
 			visitManyHasManyInverse: () => {},
 		})
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
-		return updateModel(
-			updateEntity(this.data.entityName, addField(this.getNormalizedOwningSide())),
-			this.data.inverseSide !== undefined
-				? updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))
+		const entity = this.schema.model.entities[this.data.entityName]
+		return updateSchema(
+			updateModel(
+				updateEntity(this.data.entityName, addField(this.getNormalizedOwningSide())),
+				this.data.inverseSide !== undefined
+					? updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))
+					: undefined,
+			),
+			this.data.owningSide.type === Model.RelationType.ManyHasOne
+				? addTakenIndexName(NamingHelper.createForeignKeyIndexName(entity.tableName, this.data.owningSide.joiningColumn.columnName))
+				: undefined,
+			this.data.owningSide.type === Model.RelationType.ManyHasMany && isOwningRelation(this.data.owningSide)
+				? addTakenIndexName(NamingHelper.createJunctionTablePrimaryConstraintName(this.data.owningSide.joiningTable.tableName))
 				: undefined,
 		)
 	}
@@ -91,11 +117,32 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 		return { message: `Add relation ${this.data.entityName}.${this.data.owningSide.name}`, failureWarning }
 	}
 
-	static createModification(data: CreateRelationModificationData) {
-		return { modification: this.id, ...data }
+
+	private getNormalizedOwningSide(): Model.AnyOwningRelation {
+		if (this.data.owningSide.type === Model.RelationType.ManyHasMany) {
+			return normalizeManyHasManyRelation(this.data.owningSide)
+		}
+		return this.data.owningSide
 	}
+}
+
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export type CreateRelationModificationData = {
+	entityName: string
+	owningSide:
+		| Model.ManyHasOneRelation
+		| Model.OneHasOneOwningRelation
+		| PartialManyHasManyRelation
+	inverseSide?: Model.AnyInverseRelation
+}
+
+export const createRelationModification = createModificationType({
+	id: 'createRelation',
+	handler: CreateRelationModificationHandler,
+})
+
+export class CreateRelationDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return createFields(originalSchema, updatedSchema, ({ newField, updatedEntity }) => {
 			if (!isRelation(newField) || !isOwningRelation(newField)) {
 				return undefined
@@ -106,28 +153,11 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 			if (inverseSide && !(isRelation(inverseSide) && isInverseRelation(inverseSide))) {
 				throw new Error()
 			}
-			return CreateRelationModification.createModification({
+			return createRelationModification.createModification({
 				entityName: updatedEntity.name,
 				owningSide: newField,
 				...(inverseSide ? { inverseSide } : {}),
 			})
 		})
 	}
-
-	private getNormalizedOwningSide(): Model.AnyOwningRelation {
-		if (this.data.owningSide.type === Model.RelationType.ManyHasMany) {
-			return normalizeManyHasManyRelation(this.data.owningSide)
-		}
-		return this.data.owningSide
-	}
-}
-
-
-export type CreateRelationModificationData = {
-	entityName: string
-	owningSide:
-		| Model.ManyHasOneRelation
-		| Model.OneHasOneOwningRelation
-		| PartialManyHasManyRelation
-	inverseSide?: Model.AnyInverseRelation
 }

package/src/modifications/relations/DisableOrphanRemovalModification.ts

@@ -1,12 +1,11 @@
 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 { isOwningRelation } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 
-export const DisableOrphanRemovalModification: ModificationHandlerStatic<DisableOrphanRemovalModificationData> = class {
-	static id = 'disableOrphanRemoval'
+export class DisableOrphanRemovalModificationHandler implements ModificationHandler<DisableOrphanRemovalModificationData> {
 
 	constructor(private readonly data: DisableOrphanRemovalModificationData, private readonly schema: Schema) {}
 
@@ -27,12 +26,20 @@ export const DisableOrphanRemovalModification: ModificationHandlerStatic<Disable
 			message: `Disable orphan removal on ${this.data.entityName}.${this.data.fieldName}`,
 		}
 	}
+}
 
-	static createModification(data: DisableOrphanRemovalModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface DisableOrphanRemovalModificationData {
+	entityName: string
+	fieldName: string
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const disableOrphanRemovalModification = createModificationType({
+	id: 'disableOrphanRemoval',
+	handler: DisableOrphanRemovalModificationHandler,
+})
+
+export class DisableOrphanRemovalDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				isOwningRelation(originalRelation) &&
@@ -42,7 +49,7 @@ export const DisableOrphanRemovalModification: ModificationHandlerStatic<Disable
 				originalRelation.orphanRemoval &&
 				!updatedRelation.orphanRemoval
 			) {
-				return DisableOrphanRemovalModification.createModification({
+				return disableOrphanRemovalModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
 				})
@@ -51,7 +58,3 @@ export const DisableOrphanRemovalModification: ModificationHandlerStatic<Disable
 		})
 	}
 }
-export interface DisableOrphanRemovalModificationData {
-	entityName: string
-	fieldName: string
-}