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

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/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,9 +1,7 @@
 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 {
@@ -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,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'
 import deepEqual from 'fast-deep-equal'
@@ -29,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/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}` }
 	}

package/src/modifications/relations/CreateRelationModification.ts

@@ -7,7 +7,6 @@ import {
 	NamingHelper,
 } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { ContentEvent } from '@contember/engine-common'
 import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
@@ -30,58 +29,39 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 			return
 		}
 		const targetEntity = this.schema.model.entities[this.data.owningSide.target]
+		const createOwningSide = (relation: Model.OneHasOneOwningRelation | Model.ManyHasOneRelation) => {
+			builder.addColumn(entity.tableName, {
+				[relation.joiningColumn.columnName]: {
+					type: getPrimaryType(targetEntity),
+					notNull: !relation.nullable,
+				},
+			})
+			const fkName = NamingHelper.createForeignKeyName(
+				entity.tableName,
+				relation.joiningColumn.columnName,
+				targetEntity.tableName,
+				targetEntity.primaryColumn,
+			)
+			builder.addConstraint(entity.tableName, fkName, {
+				foreignKeys: {
+					columns: relation.joiningColumn.columnName,
+					references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
+					onDelete: 'NO ACTION',
+				},
+				deferrable: true,
+				deferred: false,
+			})
+		}
 		acceptRelationTypeVisitor(this.schema.model, entity, this.data.owningSide, {
 			visitManyHasOne: ({}, relation, {}, _) => {
-				builder.addColumn(entity.tableName, {
-					[relation.joiningColumn.columnName]: {
-						type: getPrimaryType(targetEntity),
-						notNull: !relation.nullable,
-					},
-				})
-				const fkName = NamingHelper.createForeignKeyName(
-					entity.tableName,
-					relation.joiningColumn.columnName,
-					targetEntity.tableName,
-					targetEntity.primaryColumn,
-				)
-				builder.addConstraint(entity.tableName, fkName, {
-					foreignKeys: {
-						columns: relation.joiningColumn.columnName,
-						references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
-						onDelete: 'NO ACTION',
-					},
-					deferrable: true,
-					deferred: false,
-				})
+				createOwningSide(relation)
 				builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
 			},
 			visitOneHasMany: () => {},
 			visitOneHasOneOwning: ({}, relation, {}, _) => {
-				builder.addColumn(entity.tableName, {
-					[relation.joiningColumn.columnName]: {
-						type: getPrimaryType(targetEntity),
-						notNull: !relation.nullable,
-					},
-				})
+				createOwningSide(relation)
 				const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
-
 				builder.addConstraint(entity.tableName, uniqueConstraintName, { unique: [relation.joiningColumn.columnName] })
-
-				const fkName = NamingHelper.createForeignKeyName(
-					entity.tableName,
-					relation.joiningColumn.columnName,
-					targetEntity.tableName,
-					targetEntity.primaryColumn,
-				)
-				builder.addConstraint(entity.tableName, fkName, {
-					foreignKeys: {
-						columns: relation.joiningColumn.columnName,
-						references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
-						onDelete: 'NO ACTION',
-					},
-					deferrable: true,
-					deferred: false,
-				})
 			},
 			visitOneHasOneInverse: () => {},
 			visitManyHasManyOwning: ({}, relation, {}, _) => {
@@ -127,10 +107,6 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events //todo fill
-	}
-
 	describe({ createdEntities }: { createdEntities: string[] }) {
 		const notNull = isIt<Model.NullableRelation>(this.data.owningSide, 'nullable') && !this.data.owningSide.nullable
 		const failureWarning =

package/src/modifications/relations/DisableOrphanRemovalModification.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 { isOwningRelation } from '@contember/schema-utils'
@@ -23,10 +22,6 @@ export const DisableOrphanRemovalModification: ModificationHandlerStatic<Disable
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return {
 			message: `Disable orphan removal on ${this.data.entityName}.${this.data.fieldName}`,

package/src/modifications/relations/EnableOrphanRemovalModification.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 { isOwningRelation } from '@contember/schema-utils'
@@ -25,10 +24,6 @@ export const EnableOrphanRemovalModification: ModificationHandlerStatic<EnableOr
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return {
 			message: `Enable orphan removal on ${this.data.entityName}.${this.data.fieldName}`,

package/src/modifications/relations/MakeRelationNotNullModification.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 { getEntity, tryGetColumnName } from '@contember/schema-utils'
@@ -38,10 +37,6 @@ export const MakeRelationNotNullModification: ModificationHandlerStatic<MakeRela
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return {
 			message: `Make relation ${this.data.entityName}.${this.data.fieldName} not-nullable`,