@contember/schema-migrations 1.1.0-alpha.2 → 1.1.0-alpha.3

package/src/modifications/entities/CreateEntityModification.ts

@@ -1,12 +1,16 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
 import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
 
 export const CreateEntityModification: ModificationHandlerStatic<CreateEntityModificationData> = class {
 	static id = 'createEntity'
-	constructor(private readonly data: CreateEntityModificationData, private readonly schema: Schema) {}
+	constructor(
+		private readonly data: CreateEntityModificationData,
+		private readonly schema: Schema,
+		private readonly options: ModificationHandlerOptions,
+	) {}
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.data.entity
@@ -23,8 +27,8 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 				notNull: true,
 			},
 		})
-		createEventTrigger(builder, entity.tableName, [entity.primaryColumn])
-		createEventTrxTrigger(builder, entity.tableName)
+		createEventTrigger(builder, this.options.systemSchema, entity.tableName, [entity.primaryColumn])
+		createEventTrxTrigger(builder, this.options.systemSchema, entity.tableName)
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {

package/src/modifications/entities/RemoveEntityModification.ts

@@ -11,17 +11,18 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { ModificationHandlerOptions, 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'
+
 	constructor(
 		private readonly data: RemoveEntityModificationData,
 		private readonly schema: Schema,
-		private readonly formatVersion: number,
+		private readonly options: ModificationHandlerOptions,
 	) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -30,9 +31,9 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 			builder.dropView(entity.tableName)
 			return
 		}
-		if (this.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS) {
+		if (this.options.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS) {
 			this.getFieldsToRemove(this.schema).forEach(([entityName, fieldName]) => {
-				(new RemoveFieldModification({ entityName, fieldName }, this.schema, this.formatVersion)).createSql(builder)
+				(new RemoveFieldModification({ entityName, fieldName }, this.schema, this.options)).createSql(builder)
 			})
 		}
 		builder.dropTable(entity.tableName)
@@ -40,7 +41,7 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 
 	public getSchemaUpdater(): SchemaUpdater {
 		return updateSchema(
-			this.formatVersion >= VERSION_ACL_PATCH
+			this.options.formatVersion >= VERSION_ACL_PATCH
 				? updateAcl(
 					updateAclEveryRole(
 						({ role }) => ({
@@ -72,11 +73,11 @@ export const RemoveEntityModification: ModificationHandlerStatic<RemoveEntityMod
 					),
 				  )
 				: undefined,
-			this.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS
+			this.options.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS
 				? ({ schema }) => {
 					const fieldsToRemove = this.getFieldsToRemove(schema)
 					return fieldsToRemove.reduce(
-						(schema, [entity, field]) => removeField(entity, field, this.formatVersion)({ schema }),
+						(schema, [entity, field]) => removeField(entity, field, this.options.formatVersion)({ schema }),
 						schema,
 					)
 				  }

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -11,7 +11,7 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { ModificationHandler, ModificationHandlerStatic } from '../ModificationHandler'
+import { ModificationHandler, ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
 import { VERSION_ACL_PATCH, VERSION_UPDATE_CONSTRAINT_NAME } from '../ModificationVersions'
 import { NamingHelper } from '@contember/schema-utils'
@@ -27,20 +27,20 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 	constructor(
 		private readonly data: UpdateEntityNameModificationData,
 		private readonly schema: Schema,
-		private readonly formatVersion: number,
+		private readonly options: ModificationHandlerOptions,
 	) {
 		this.subModification = data.tableName
 			? new UpdateEntityTableNameModification(
 				{ entityName: data.entityName, tableName: data.tableName },
 				schema,
-				this.formatVersion,
+				this.options,
 			  )
 			: new NoopModification()
 	}
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.schema.model.entities[this.data.entityName]
-		if (!entity.view && this.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
+		if (!entity.view && this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
 			renameConstraintsSqlBuilder(builder, entity, this.getNewConstraintName.bind(this))
 		}
 		this.subModification.createSql(builder)
@@ -58,7 +58,7 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 						return field
 					}),
 				),
-				this.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
+				this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
 					? updateEntity(this.data.entityName, renameConstraintSchemaUpdater(this.getNewConstraintName.bind(this)))
 					: undefined,
 				({ model }) => {
@@ -76,7 +76,7 @@ export const UpdateEntityNameModification: ModificationHandlerStatic<UpdateEntit
 					}
 				},
 			),
-			this.formatVersion >= VERSION_ACL_PATCH
+			this.options.formatVersion >= VERSION_ACL_PATCH
 				? updateAcl(
 					updateAclEveryRole(
 						({ role }) => ({

package/src/modifications/fields/RemoveFieldModification.ts

@@ -2,15 +2,16 @@ import { acceptFieldVisitor, isInverseRelation, isRelation, NamingHelper } from
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { removeField, SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
 import { isDefined } from '../../utils/isDefined'
 
 export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModificationData> = class {
 	static id = 'removeField'
+
 	constructor(
 		private readonly data: RemoveFieldModificationData,
 		private readonly schema: Schema,
-		private readonly formatVersion: number,
+		private readonly options: ModificationHandlerOptions,
 	) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -39,7 +40,7 @@ export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModif
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
-		return removeField(this.data.entityName, this.data.fieldName, this.formatVersion)
+		return removeField(this.data.entityName, this.data.fieldName, this.options.formatVersion)
 	}
 
 	describe() {

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -13,7 +13,7 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { ModificationHandlerOptions, ModificationHandlerStatic } 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'
@@ -24,7 +24,7 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 	constructor(
 		private readonly data: UpdateFieldNameModificationData,
 		private readonly schema: Schema,
-		private readonly formatVersion: number,
+		private readonly options: ModificationHandlerOptions,
 	) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -32,18 +32,18 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 		if (entity.view) {
 			return
 		}
-		if (this.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
+		if (this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
 			renameConstraintsSqlBuilder(builder, entity, this.getNewConstraintName.bind(this))
 		}
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
 		const updateConstraintName =
-			this.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
+			this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
 				? updateEntity(this.data.entityName, renameConstraintSchemaUpdater(this.getNewConstraintName.bind(this)))
 				: undefined
 		const updateConstraintFields =
-			this.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
+			this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
 				? updateEntity(this.data.entityName, ({ entity }) => {
 					return {
 						...entity,
@@ -112,7 +112,7 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 			}
 		})
 		const updateAclOp =
-			this.formatVersion >= VERSION_ACL_PATCH
+			this.options.formatVersion >= VERSION_ACL_PATCH
 				? updateAcl(
 					updateAclEveryRole(
 						updateAclEveryEntity(

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

@@ -0,0 +1,109 @@
+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 { updateRelations } from '../utils/diffUtils'
+import { UpdateFieldNameModification } from '../fields'
+import { createJunctionTableSql } from '../utils/createJunctionTable'
+import { wrapIdentifier } from '@contember/database'
+
+export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHandlerStatic<ConvertOneHasManyToManyHasManyRelationModificationData> = class {
+	static id = 'convertOneHasManyToManyHasManyRelation'
+	private subModification: ModificationHandler<any>
+
+	constructor(
+		private readonly data: ConvertOneHasManyToManyHasManyRelationModificationData,
+		private readonly schema: Schema,
+		private readonly options: ModificationHandlerOptions,
+	) {
+		this.subModification = new UpdateFieldNameModification(
+			{
+				entityName: this.data.entityName,
+				fieldName: this.data.fieldName,
+				newFieldName: this.data.owningSide.name,
+			},
+			schema,
+			this.options,
+		)
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+		const targetEntity = this.schema.model.entities[this.data.owningSide.target]
+		const { relation: oldRelation } = this.getRelation()
+		const entity = this.schema.model.entities[this.data.entityName]
+
+		createJunctionTableSql(builder, this.options.systemSchema, entity, targetEntity, this.data.owningSide)
+		const joiningTable = this.data.owningSide.joiningTable
+		builder.sql(`
+			INSERT INTO ${wrapIdentifier(joiningTable.tableName)} (
+				${wrapIdentifier(joiningTable.joiningColumn.columnName)},
+				${wrapIdentifier(joiningTable.inverseJoiningColumn.columnName)}
+				)
+			SELECT ${wrapIdentifier(entity.primaryColumn)}, ${wrapIdentifier(oldRelation.joiningColumn.columnName)}
+			FROM ${wrapIdentifier(entity.tableName)}
+			WHERE ${wrapIdentifier(oldRelation.joiningColumn.columnName)} IS NOT NULL`)
+
+		builder.dropColumn(entity.tableName, oldRelation.joiningColumn.columnName)
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		const { entityName } = this.data
+		return updateSchema(
+			this.subModification.getSchemaUpdater(),
+			updateModel(updateEntity(entityName, addField(this.data.owningSide))),
+			this.data.inverseSide ? updateModel(updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))) : undefined,
+		)
+	}
+
+	describe() {
+		return {
+			message: `Converts OneHasMany relation to ManyHasMany on ${this.data.entityName}.${this.data.fieldName}`,
+		}
+	}
+
+	static createModification(data: ConvertOneHasManyToManyHasManyRelationModificationData) {
+		return { modification: this.id, ...data }
+	}
+
+	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
+			if (
+				isInverseRelation(originalRelation) &&
+				isInverseRelation(updatedRelation) &&
+				originalRelation.type === Model.RelationType.OneHasMany &&
+				updatedRelation.type === Model.RelationType.ManyHasMany
+			) {
+				const owningOldName = originalRelation.ownedBy
+				const owningNewName = updatedRelation.ownedBy
+				const owningSide = updatedSchema.model.entities[updatedRelation.target].fields[owningNewName]
+				if (owningSide.type !== Model.RelationType.ManyHasMany || !isOwningRelation(owningSide)) {
+					throw new Error()
+				}
+				return ConvertOneHasManyToManyHasManyRelationModification.createModification({
+					entityName: updatedRelation.target,
+					fieldName: owningOldName,
+					owningSide,
+					inverseSide: updatedRelation,
+				})
+			}
+			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: Model.ManyHasManyOwningRelation
+	inverseSide?: Model.ManyHasManyInverseRelation
+}

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -1,7 +1,7 @@
 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 { ModificationHandler, ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
 import { isOwningRelation, NamingHelper } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 import { UpdateFieldNameModification } from '../fields'
@@ -11,7 +11,11 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 	static id = 'convertOneToManyRelation'
 	private subModification: ModificationHandler<any>
 
-	constructor(private readonly data: ConvertOneToManyRelationModificationData, private readonly schema: Schema, private readonly formatVersion: number) {
+	constructor(
+		private readonly data: ConvertOneToManyRelationModificationData,
+		private readonly schema: Schema,
+		private readonly options: ModificationHandlerOptions,
+	) {
 		const { relation } = this.getRelation()
 		this.subModification = data.newInverseSideFieldName && relation.inversedBy ?
 			new UpdateFieldNameModification(
@@ -21,7 +25,7 @@ export const ConvertOneToManyRelationModification: ModificationHandlerStatic<Con
 					newFieldName: data.newInverseSideFieldName,
 				},
 				schema,
-				formatVersion,
+				this.options,
 			)
 			: new NoopModification()
 	}

package/src/modifications/relations/CreateRelationModification.ts

@@ -8,20 +8,21 @@ import {
 } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
 import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
-import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
+import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
 import { createFields } from '../utils/diffUtils'
+import { getPrimaryColumnType } from '../utils/getPrimaryColumnType'
+import { createJunctionTableSql } from '../utils/createJunctionTable'
 
-const getPrimaryType = (entity: Model.Entity): string => {
-	const column = entity.fields[entity.primary] as Model.AnyColumn
-	return column.columnType
-}
 
 export const CreateRelationModification: ModificationHandlerStatic<CreateRelationModificationData> = class {
 	static id = 'createRelation'
 
-	constructor(private readonly data: CreateRelationModificationData, private readonly schema: Schema) {}
+	constructor(
+		private readonly data: CreateRelationModificationData,
+		private readonly schema: Schema,
+		private readonly options: ModificationHandlerOptions,
+	) {}
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.schema.model.entities[this.data.entityName]
@@ -32,7 +33,7 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 		const createOwningSide = (relation: Model.OneHasOneOwningRelation | Model.ManyHasOneRelation) => {
 			builder.addColumn(entity.tableName, {
 				[relation.joiningColumn.columnName]: {
-					type: getPrimaryType(targetEntity),
+					type: getPrimaryColumnType(targetEntity),
 					notNull: !relation.nullable,
 				},
 			})
@@ -65,34 +66,7 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 			},
 			visitOneHasOneInverse: () => {},
 			visitManyHasManyOwning: ({}, relation, {}, _) => {
-				const primaryColumns = [
-					relation.joiningTable.joiningColumn.columnName,
-					relation.joiningTable.inverseJoiningColumn.columnName,
-				]
-				builder.createTable(
-					relation.joiningTable.tableName,
-					{
-						[relation.joiningTable.joiningColumn.columnName]: {
-							type: getPrimaryType(entity),
-							notNull: true,
-							references: `"${entity.tableName}"("${entity.primaryColumn}")`,
-							onDelete: 'CASCADE',
-						},
-						[relation.joiningTable.inverseJoiningColumn.columnName]: {
-							type: getPrimaryType(targetEntity),
-							notNull: true,
-							references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
-							onDelete: 'CASCADE',
-						},
-					},
-					{
-						constraints: {
-							primaryKey: primaryColumns,
-						},
-					},
-				)
-				createEventTrigger(builder, relation.joiningTable.tableName, primaryColumns)
-				createEventTrxTrigger(builder, relation.joiningTable.tableName)
+				createJunctionTableSql(builder, this.options.systemSchema,  entity, targetEntity, relation)
 			},
 			visitManyHasManyInverse: () => {},
 		})

package/src/modifications/relations/index.ts

@@ -1,3 +1,4 @@
+export * from './ConvertOneHasManyToManyHasManyRelationModification'
 export * from './ConvertOneToManyRelationModification'
 export * from './CreateRelationInverseSideModification'
 export * from './CreateRelationModification'

package/src/modifications/utils/createJunctionTable.ts

@@ -0,0 +1,41 @@
+import { createEventTrigger, createEventTrxTrigger } from './sqlUpdateUtils'
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model } from '@contember/schema'
+import { getPrimaryColumnType } from './getPrimaryColumnType'
+
+export const createJunctionTableSql = (
+	builder: MigrationBuilder,
+	systemSchema: string,
+	entity: Model.Entity,
+	targetEntity: Model.Entity,
+	relation: Model.ManyHasManyOwningRelation,
+) => {
+	const primaryColumns = [
+		relation.joiningTable.joiningColumn.columnName,
+		relation.joiningTable.inverseJoiningColumn.columnName,
+	]
+	builder.createTable(
+		relation.joiningTable.tableName,
+		{
+			[relation.joiningTable.joiningColumn.columnName]: {
+				type: getPrimaryColumnType(entity),
+				notNull: true,
+				references: `"${entity.tableName}"("${entity.primaryColumn}")`,
+				onDelete: 'CASCADE',
+			},
+			[relation.joiningTable.inverseJoiningColumn.columnName]: {
+				type: getPrimaryColumnType(targetEntity),
+				notNull: true,
+				references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
+				onDelete: 'CASCADE',
+			},
+		},
+		{
+			constraints: {
+				primaryKey: primaryColumns,
+			},
+		},
+	)
+	createEventTrigger(builder, systemSchema, relation.joiningTable.tableName, primaryColumns)
+	createEventTrxTrigger(builder, systemSchema, relation.joiningTable.tableName)
+}

package/src/modifications/utils/getPrimaryColumnType.ts

@@ -0,0 +1,6 @@
+import { Model } from '@contember/schema'
+
+export const getPrimaryColumnType = (entity: Model.Entity): string => {
+	const column = entity.fields[entity.primary] as Model.AnyColumn
+	return column.columnType
+}

package/src/modifications/utils/sqlUpdateUtils.ts

@@ -1,19 +1,19 @@
 import { MigrationBuilder, Name } from '@contember/database-migrations'
 
-export const createEventTrigger = (builder: MigrationBuilder, tableName: Name, primaryColumns: string[]) => {
+export const createEventTrigger = (builder: MigrationBuilder, systemSchema: string, tableName: Name, primaryColumns: string[]) => {
 	builder.createTrigger(tableName, 'log_event', {
 		when: 'AFTER',
 		operation: ['INSERT', 'UPDATE', 'DELETE'],
 		level: 'ROW',
 		function: {
-			schema: 'system',
+			schema: systemSchema,
 			name: 'trigger_event',
 		},
 		functionParams: primaryColumns,
 	})
 }
 
-export const createEventTrxTrigger = (builder: MigrationBuilder, tableName: Name) => {
+export const createEventTrxTrigger = (builder: MigrationBuilder, systemSchema: string, tableName: Name) => {
 	builder.createTrigger(tableName, 'log_event_trx', {
 		when: 'AFTER',
 		operation: ['INSERT', 'UPDATE', 'DELETE'],
@@ -22,7 +22,7 @@ export const createEventTrxTrigger = (builder: MigrationBuilder, tableName: Name
 		deferrable: true,
 		deferred: true,
 		function: {
-			schema: 'system',
+			schema: systemSchema,
 			name: 'trigger_event_commit',
 		},
 	})

package/tests/cases/integration/convertOneHasManyToManyHasManyRelation.test.ts

@@ -0,0 +1,81 @@
+import { testMigrations } from '../../src/tests'
+import { SQL } from '../../src/tags'
+import { SchemaDefinition as def } from '@contember/schema-definition'
+
+namespace ConvertOHMToMHMSchemaOrig {
+	export class Article {
+		title = def.stringColumn()
+		category = def.manyHasOne(Category, 'articles')
+	}
+
+	export class Category {
+		articles = def.oneHasMany(Article, 'category')
+	}
+}
+
+namespace ConvertOHMToMHMSchemaOrigUpdated {
+	export class Article {
+		title = def.stringColumn()
+		categories = def.manyHasMany(Category, 'articles')
+	}
+
+	export class Category {
+		articles = def.manyHasManyInverse(Article, 'categories')
+	}
+}
+
+
+testMigrations('convert one has many to many has many', {
+	originalSchema: def.createModel(ConvertOHMToMHMSchemaOrig),
+	updatedSchema: def.createModel(ConvertOHMToMHMSchemaOrigUpdated),
+	diff: [
+		{
+			modification: 'convertOneHasManyToManyHasManyRelation',
+			entityName: 'Article',
+			fieldName: 'category',
+			owningSide: {
+				type: 'ManyHasMany',
+				name: 'categories',
+				inversedBy: 'articles',
+				target: 'Category',
+				joiningTable: {
+					tableName: 'article_categories',
+					joiningColumn: {
+						columnName: 'article_id',
+						onDelete: 'cascade',
+					},
+					inverseJoiningColumn: {
+						columnName: 'category_id',
+						onDelete: 'cascade',
+					},
+				},
+			},
+			inverseSide: {
+				name: 'articles',
+				ownedBy: 'categories',
+				target: 'Article',
+				type: 'ManyHasMany',
+			},
+		},
+	],
+	sql: SQL`
+	CREATE TABLE "article_categories" (
+		"article_id" uuid NOT NULL REFERENCES "article"("id") ON DELETE CASCADE,
+		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE, CONSTRAINT
+		"article_categories_pkey" PRIMARY KEY ("article_id", "category_id")
+	);
+
+	CREATE TRIGGER "log_event" AFTER INSERT OR UPDATE OR DELETE
+	    ON "article_categories" FOR EACH ROW
+	    EXECUTE PROCEDURE "system"."trigger_event"($pga$article_id$pga$, $pga$category_id$pga$);
+
+	CREATE CONSTRAINT TRIGGER "log_event_trx" AFTER INSERT OR UPDATE OR DELETE
+	    ON "article_categories" DEFERRABLE INITIALLY DEFERRED FOR EACH ROW
+	    EXECUTE PROCEDURE "system"."trigger_event_commit"();
+
+	INSERT INTO "article_categories" ( "article_id", "category_id" )
+	SELECT "id", "category_id" FROM "article" WHERE "category_id" IS NOT NULL;
+
+	ALTER TABLE "article" DROP "category_id";
+	`,
+})

package/tests/cases/integration/updateColumnDefinition.test.ts

@@ -29,5 +29,5 @@ testMigrations('update column definition', {
 		},
 	],
 	sql: SQL`ALTER TABLE "author"
-		ALTER "registered_at" SET DATA TYPE timestamptz;`,
+		ALTER "registered_at" SET DATA TYPE timestamptz USING "registered_at"::timestamptz;`,
 })

package/tests/src/tests.ts

@@ -69,7 +69,7 @@ export function testGenerateSql(originalSchema: Model.Schema, diff: Migration.Mo
 	let schema = { model: originalSchema, acl: emptyAcl, validation: {} }
 	const builder = createMigrationBuilder()
 	for (let { modification, ...data } of diff) {
-		const modificationHandler = modificationFactory.create(modification, data, schema, VERSION_LATEST)
+		const modificationHandler = modificationFactory.create(modification, data, schema, { formatVersion: VERSION_LATEST, systemSchema: 'system' })
 		modificationHandler.createSql(builder)
 		schema = modificationHandler.getSchemaUpdater()({ schema })
 	}