@contember/schema-migrations 0.12.0-beta.0 → 1.0.0-alpha.1

package/src/modifications/columns/CreateColumnModification.ts

@@ -1,10 +1,9 @@
 import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent, EventType } from '@contember/engine-common'
 import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { wrapIdentifier } from '../../utils/dbHelpers'
-import { getColumnName, isColumn, isInverseRelation, isRelation, resolveDefaultValue } from '@contember/schema-utils'
+import { getColumnName, isColumn } from '@contember/schema-utils'
 import { ImplementationException } from '../../exceptions'
 import { createFields } from '../utils/diffUtils'
 
@@ -54,40 +53,6 @@ export const CreateColumnModification: ModificationHandlerStatic<CreateColumnMod
 		return updateModel(updateEntity(this.data.entityName, addField(this.data.field)))
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-
-		return events.map(it => {
-			if (it.tableName !== entity.tableName || it.type !== EventType.create) {
-				return it
-			}
-
-			try {
-				let value: any = null
-				if (this.data.fillValue !== undefined) {
-					value = this.data.fillValue
-				} else if (this.data.copyValue !== undefined) {
-					const columnName = getColumnName(this.schema.model, entity, this.data.copyValue)
-					value = it.values[columnName] !== undefined ? it.values[columnName] : null
-				} else {
-					value = resolveDefaultValue(this.data.field, { now: () => it.createdAt })
-				}
-				return {
-					...it,
-					values: {
-						...it.values,
-						[this.data.field.columnName]: value,
-					},
-				}
-			} catch (e) {
-				// if (e instanceof NoDataError) {
-				// 	return {...it, errors: [...it.errors || []]}
-				// }
-				throw e
-			}
-		})
-	}
-
 	describe({ createdEntities }: { createdEntities: string[] }) {
 		const notNull = !this.data.field.nullable
 		const hasValue = this.data.fillValue !== undefined || this.data.copyValue !== undefined
@@ -110,7 +75,7 @@ export const CreateColumnModification: ModificationHandlerStatic<CreateColumnMod
 			return CreateColumnModification.createModification({
 				entityName: updatedEntity.name,
 				field: newField,
-				...(newField.default ? { fillValue: newField.default } : {}),
+				...(newField.default !== undefined ? { fillValue: newField.default } : {}),
 			})
 		})
 	}

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
@@ -43,10 +42,6 @@ export const UpdateColumnDefinitionModification: ModificationHandlerStatic<Updat
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events // todo transform type
-	}
-
 	describe() {
 		const current = this.schema.model.entities[this.data.entityName].fields[this.data.fieldName] as Model.AnyColumn
 		const changingToNotNull = current.nullable && !this.data.definition.nullable

package/src/modifications/columns/UpdateColumnNameModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent, EventType } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { updateColumns } from '../utils/diffUtils'
@@ -27,25 +26,6 @@ export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColum
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-		const tableName = entity.tableName
-		const oldColumnName = (entity.fields[this.data.fieldName] as Model.AnyColumn).columnName
-		const newColumnName = this.data.columnName
-		return events.map(it => {
-			if (
-				it.tableName !== tableName ||
-				(it.type !== EventType.create && it.type !== EventType.update) ||
-				!it.values.hasOwnProperty(oldColumnName)
-			) {
-				return it
-			}
-
-			const { [oldColumnName]: value, ...values } = it.values
-			return { ...it, values: { ...values, [newColumnName]: value } }
-		})
-	}
-
 	describe() {
 		return { message: `Change column name of field ${this.data.entityName}.${this.data.fieldName}` }
 	}

package/src/modifications/constraints/CreateUniqueConstraintModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { acceptFieldVisitor } from '@contember/schema-utils'
@@ -58,10 +57,6 @@ export const CreateUniqueConstraintModification: ModificationHandlerStatic<Creat
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe({ createdEntities }: { createdEntities: string[] }) {
 		return {
 			message: `Create unique constraint (${this.data.unique.fields.join(', ')}) on entity ${this.data.entityName}`,

package/src/modifications/constraints/RemoveUniqueConstraintModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
@@ -29,10 +28,6 @@ export const RemoveUniqueConstraintModification: ModificationHandlerStatic<Remov
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		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}` }

package/src/modifications/differs/RemoveChangedFieldDiffer.ts

@@ -1,12 +1,20 @@
 import { Differ } from '../ModificationHandler'
-import { Schema } from '@contember/schema'
+import { Model, Schema } from '@contember/schema'
 import { updateFields } from '../utils/diffUtils'
 import deepEqual from 'fast-deep-equal'
 import { RemoveFieldModification } from '../fields'
 
 export class RemoveChangedFieldDiffer implements Differ {
+	constructor(
+		private readonly matcher: (originalField: Model.AnyField) => boolean,
+	) {
+	}
+
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateFields(originalSchema, updatedSchema, ({ updatedField, originalField, updatedEntity }) => {
+			if (!this.matcher(originalField)) {
+				return undefined
+			}
 			if (!deepEqual({ ...updatedField, inversedBy: undefined }, { ...originalField, inversedBy: undefined })) {
 				return [
 					RemoveFieldModification.createModification({

package/src/modifications/entities/CreateEntityModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
@@ -37,9 +36,6 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 		}))
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
 
 	describe() {
 		return { message: `Add entity ${this.data.entity.name}` }

package/src/modifications/entities/RemoveEntityModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import {
 	removeField,
 	SchemaUpdater,
@@ -15,6 +14,7 @@ import {
 import { ModificationHandlerStatic } 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'
@@ -30,7 +30,12 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 			builder.dropView(entity.tableName)
 			return
 		}
-		builder.dropTable(entity.tableName, { cascade: true })
+		if (this.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS) {
+			this.getFieldsToRemove(this.schema).forEach(([entityName, fieldName]) => {
+				(new RemoveFieldModification({ entityName, fieldName }, this.schema, this.formatVersion)).createSql(builder)
+			})
+		}
+		builder.dropTable(entity.tableName)
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -67,11 +72,7 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 				: undefined,
 			this.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS
 				? ({ schema }) => {
-					const fieldsToRemove = Object.values(schema.model.entities).flatMap(entity =>
-						Object.values(entity.fields)
-							.filter(field => isRelation(field) && field.target === this.data.entityName)
-							.map(field => [entity.name, field.name]),
-					)
+					const fieldsToRemove = this.getFieldsToRemove(schema)
 					return fieldsToRemove.reduce(
 						(schema, [entity, field]) => removeField(entity, field, this.formatVersion)({ schema }),
 						schema,
@@ -88,11 +89,12 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-		return events.filter(it => {
-			return it.tableName !== entity.tableName
-		})
+	private getFieldsToRemove(schema: Schema): [entity: string, field: string][] {
+		return Object.values(schema.model.entities).flatMap(entity =>
+			Object.values(entity.fields)
+				.filter(field => isRelation(field) && field.target === this.data.entityName)
+				.map((field): [string, string] => [entity.name, field.name]),
+		)
 	}
 
 	describe() {

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import {
 	SchemaUpdater,
 	updateAcl,
@@ -108,11 +107,6 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 		)
 	}
 
-	public async transformEvents(events: ContentEvent[]): Promise<ContentEvent[]> {
-		events = await this.subModification.transformEvents(events)
-		return events
-	}
-
 	private getNewConstraintName(constraint: Model.UniqueConstraint): string | null {
 		const generatedName = NamingHelper.createUniqueConstraintName(this.data.entityName, constraint.fields)
 		const isGenerated = constraint.name === generatedName

package/src/modifications/entities/UpdateEntityTableNameModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 
@@ -26,16 +25,6 @@ export const UpdateEntityTableNameModification: ModificationHandlerStatic<Update
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-		return events.map(it => {
-			if (it.tableName !== entity.tableName) {
-				return it
-			}
-			return { ...it, tableName: this.data.tableName }
-		})
-	}
-
 	describe() {
 		return { message: `Change table name of entity ${this.data.entityName}` }
 	}

package/src/modifications/entities/UpdateViewModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 
@@ -11,11 +10,10 @@ export const UpdateViewModification: ModificationHandlerStatic<UpdateViewModific
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.schema.model.entities[this.data.entityName]
+		builder.dropView(entity.tableName, { ifExists: true })
 		builder.createView(
 			entity.tableName,
-			{
-				replace: true,
-			},
+			{},
 			this.data.view.sql,
 		)
 	}
@@ -29,10 +27,6 @@ export const UpdateViewModification: ModificationHandlerStatic<UpdateViewModific
 		)
 	}
 
-	public async transformEvents(events: ContentEvent[]): Promise<ContentEvent[]> {
-		return events
-	}
-
 	describe() {
 		return { message: `Update SQL definition of a view` }
 	}

package/src/modifications/enums/CreateEnumModification.ts

@@ -1,19 +1,17 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
-import { escapeSqlString } from '../../utils/escapeSqlString'
+import { createCheck, getConstraintName } from './enumUtils'
 
 export const CreateEnumModification: ModificationHandlerStatic<CreateEnumModificationData> = class {
 	static id = 'createEnum'
 	constructor(private readonly data: CreateEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
-		const joinedValues = this.data.values.map(it => `'${escapeSqlString(it)}'`).join(',')
 		builder.createDomain(this.data.enumName, 'text', {
-			check: `VALUE IN(${joinedValues})`,
-			constraintName: `${this.data.enumName}_check`.toLowerCase(),
+			check: createCheck(this.data.values),
+			constraintName: getConstraintName(this.data.enumName),
 		})
 	}
 
@@ -27,10 +25,6 @@ export const CreateEnumModification: ModificationHandlerStatic<CreateEnumModific
 		}))
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: `Add enum ${this.data.enumName}` }
 	}

package/src/modifications/enums/RemoveEnumModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 
@@ -22,10 +21,6 @@ export const RemoveEnumModification: ModificationHandlerStatic<RemoveEnumModific
 		})
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: `Remove ${this.data.enumName}` }
 	}

package/src/modifications/enums/UpdateEnumModification.ts

@@ -1,21 +1,21 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
-import { escapeSqlString } from '../../utils/escapeSqlString'
 import deepEqual from 'fast-deep-equal'
+import { createCheck, getConstraintName } from './enumUtils'
 
 export const UpdateEnumModification: ModificationHandlerStatic<UpdateEnumModificationData> = class {
 	static id = 'updateEnum'
 	constructor(private readonly data: UpdateEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
-		const joinedValues = this.data.values.map(it => `'${escapeSqlString(it)}'`).join(',')
-		builder.sql(`ALTER DOMAIN "${this.data.enumName}" DROP CONSTRAINT ${this.data.enumName}_check`)
-		builder.sql(
-			`ALTER DOMAIN "${this.data.enumName}" ADD CONSTRAINT ${this.data.enumName}_check CHECK (VALUE IN(${joinedValues}))`,
-		)
+		builder.sql(`
+			ALTER DOMAIN "${this.data.enumName}"
+			DROP CONSTRAINT ${getConstraintName(this.data.enumName)}`)
+		builder.sql(`
+			ALTER DOMAIN "${this.data.enumName}"
+			ADD CONSTRAINT ${getConstraintName(this.data.enumName)} CHECK (${createCheck(this.data.values)})`)
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -28,10 +28,6 @@ export const UpdateEnumModification: ModificationHandlerStatic<UpdateEnumModific
 		}))
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		const currentValues = this.schema.model.enums[this.data.enumName]
 		const missingValues = currentValues.filter(it => !this.data.values.includes(it))

package/src/modifications/enums/enumUtils.ts

@@ -0,0 +1,8 @@
+import { escapeSqlString } from '../../utils/escapeSqlString'
+
+export const createCheck = (values: string[]) => {
+	const joinedValues = values.map(it => `'${escapeSqlString(it)}'`).join(',')
+	return `VALUE IN(${joinedValues})`
+}
+
+export const getConstraintName = (enumName: string) => `${enumName}_check`.toLowerCase()

package/src/modifications/fields/RemoveFieldModification.ts

@@ -1,30 +1,8 @@
-import {
-	acceptFieldVisitor,
-	isInverseRelation,
-	isOwningRelation,
-	isRelation,
-	NamingHelper,
-	PredicateDefinitionProcessor,
-	tryGetColumnName,
-} from '@contember/schema-utils'
+import { acceptFieldVisitor, isInverseRelation, isRelation, NamingHelper } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Model, Schema } from '@contember/schema'
-import { ContentEvent, EventType } from '@contember/engine-common'
-import {
-	removeField,
-	SchemaUpdater,
-	updateAcl,
-	updateAclEveryEntity,
-	updateAclEveryPredicate,
-	updateAclEveryRole,
-	updateAclFieldPermissions,
-	updateEntity,
-	updateField,
-	updateModel,
-	updateSchema,
-} from '../utils/schemaUpdateUtils'
+import { Schema } from '@contember/schema'
+import { removeField, SchemaUpdater } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
-import { VERSION_ACL_PATCH, VERSION_REMOVE_RELATION_INVERSE_SIDE } from '../ModificationVersions'
 import { isDefined } from '../../utils/isDefined'
 
 export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModificationData> = class {
@@ -64,27 +42,6 @@ export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModif
 		return removeField(this.data.entityName, this.data.fieldName, this.formatVersion)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-		const tableName = entity.tableName
-		const columnName = tryGetColumnName(this.schema.model, entity, this.data.fieldName)
-		if (!columnName) {
-			return events
-		}
-		return events.map(it => {
-			if (
-				it.tableName !== tableName ||
-				(it.type !== EventType.create && it.type !== EventType.update) ||
-				!it.values.hasOwnProperty(columnName)
-			) {
-				return it
-			}
-
-			const { [columnName]: value, ...values } = it.values
-			return { ...it, values }
-		})
-	}
-
 	describe() {
 		return { message: `Remove field ${this.data.entityName}.${this.data.fieldName}`, isDestructive: true }
 	}

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Input, Model, Schema, Value } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import {
 	SchemaUpdater,
 	updateAcl,
@@ -158,10 +157,6 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	private getNewConstraintName(constraint: Model.UniqueConstraint): string | null {
 		const generatedName = NamingHelper.createUniqueConstraintName(this.data.entityName, constraint.fields)
 		const isGenerated = constraint.name === generatedName

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -0,0 +1,115 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model, Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import { ModificationHandler, ModificationHandlerStatic } from '../ModificationHandler'
+import { isOwningRelation, NamingHelper } from '@contember/schema-utils'
+import { updateRelations } from '../utils/diffUtils'
+import { UpdateFieldNameModification } from '../fields'
+import { NoopModification } from '../NoopModification'
+
+export const ConvertOneToManyRelationModification: ModificationHandlerStatic<ConvertOneToManyRelationModificationData> = class {
+	static id = 'convertOneToManyRelation'
+	private subModification: ModificationHandler<any>
+
+	constructor(private readonly data: ConvertOneToManyRelationModificationData, private readonly schema: Schema, private readonly formatVersion: number) {
+		const { relation } = this.getRelation()
+		this.subModification = data.newInverseSideFieldName && relation.inversedBy ?
+			new UpdateFieldNameModification(
+				{
+					entityName: relation.target,
+					fieldName: relation.inversedBy,
+					newFieldName: data.newInverseSideFieldName,
+				},
+				schema,
+				formatVersion,
+			)
+			: new NoopModification()
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+		const { entity, relation } = this.getRelation()
+		builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
+		const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
+		builder.dropConstraint(entity.tableName, uniqueConstraintName)
+		this.subModification.createSql(builder)
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		const { relation } = this.getRelation()
+		const { entityName, fieldName } = this.data
+		return updateSchema(
+			updateModel(
+				updateEntity(
+					entityName,
+					updateField<Model.OneHasOneOwningRelation, Model.ManyHasOneRelation>(
+						fieldName,
+						({ field: { type, orphanRemoval, ...field } }) => ({
+							type: Model.RelationType.ManyHasOne,
+							...field,
+						}),
+					),
+				),
+			),
+			this.subModification.getSchemaUpdater(),
+			this.data.newInverseSideFieldName ?
+				updateModel(
+					updateEntity(
+						relation.target,
+						updateField<Model.OneHasOneInverseRelation, Model.OneHasManyRelation>(
+							this.data.newInverseSideFieldName,
+							({ field: { type,  nullable, ...field } }) => ({
+								type: Model.RelationType.OneHasMany,
+								...field,
+							}),
+						),
+					),
+				) : undefined,
+		)
+	}
+
+	describe() {
+		return {
+			message: `Converts OneHasOne relation to ManyHasOne on ${this.data.entityName}.${this.data.fieldName}`,
+		}
+	}
+
+	static createModification(data: ConvertOneToManyRelationModificationData) {
+		return { modification: this.id, ...data }
+	}
+
+	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
+			if (
+				isOwningRelation(originalRelation) &&
+				isOwningRelation(updatedRelation) &&
+				originalRelation.type === Model.RelationType.OneHasOne &&
+				updatedRelation.type === Model.RelationType.ManyHasOne
+			) {
+				const isInverseSideRenamed = originalRelation.inversedBy && updatedRelation.inversedBy && originalRelation.inversedBy !== updatedRelation.inversedBy
+				return ConvertOneToManyRelationModification.createModification({
+					entityName: updatedEntity.name,
+					fieldName: updatedRelation.name,
+					...(isInverseSideRenamed ? {
+						newInverseSideFieldName: updatedRelation.inversedBy,
+					} : {}),
+				})
+			}
+			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,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { addField, SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { createFields } from '../utils/diffUtils'
@@ -25,10 +24,6 @@ export const CreateRelationInverseSideModification: ModificationHandlerStatic<Cr
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: `Add relation ${this.data.entityName}.${this.data.relation.name}` }
 	}