@contember/schema-migrations 1.3.0-alpha.6 → 1.3.0-alpha.8

package/src/modifications/entities/ToggleEventLogModification.ts

@@ -5,6 +5,7 @@ import {
 	createModificationType,
 	Differ,
 	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
 import {
@@ -23,14 +24,14 @@ export class ToggleEventLogModificationHandler implements ModificationHandler<To
 	) {
 	}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, { systemSchema }: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.schema.model.entities[this.data.entityName]
 		if (entity.view) {
 			return
 		}
 		if (this.data.enabled) {
-			createEventTrigger(builder, this.options.systemSchema, entity.tableName, [entity.primaryColumn])
-			createEventTrxTrigger(builder, this.options.systemSchema, entity.tableName)
+			createEventTrigger(builder, systemSchema, entity.tableName, [entity.primaryColumn])
+			createEventTrxTrigger(builder, systemSchema, entity.tableName)
 		} else {
 			dropEventTrigger(builder, entity.tableName)
 			dropEventTrxTrigger(builder, entity.tableName)

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -5,32 +5,29 @@ import {
 	updateAcl,
 	updateAclEntities,
 	updateAclEveryRole,
-	updateEntity,
 	updateEveryEntity,
 	updateEveryField,
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { createModificationType, ModificationHandler, ModificationHandlerOptions } from '../ModificationHandler'
-import { isIt } from '../../utils/isIt'
 import {
-	VERSION_ACL_PATCH,
-	VERSION_UPDATE_CONSTRAINT_NAME,
-	VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE,
-} from '../ModificationVersions'
-import { acceptEveryFieldVisitor, NamingHelper } from '@contember/schema-utils'
+	createModificationType,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
+import { isIt } from '../../utils/isIt'
+import { VERSION_ACL_PATCH } from '../ModificationVersions'
 import { NoopModification } from '../NoopModification'
-import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../utils/renameConstraintsHelper'
 import { changeValue } from '../utils/valueUtils'
 import { updateEntityTableNameModification } from './UpdateEntityTableNameModification'
-import { SchemaWithMeta } from '../utils/schemaMeta'
 
 export class UpdateEntityNameModificationHandler implements ModificationHandler<UpdateEntityNameModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: UpdateEntityNameModificationData,
-		private readonly schema: SchemaWithMeta,
+		private readonly schema: Schema,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		this.subModification = data.tableName
@@ -42,29 +39,8 @@ export class UpdateEntityNameModificationHandler implements ModificationHandler<
 			: new NoopModification()
 	}
 
-	public createSql(builder: MigrationBuilder): void {
-		const entity = this.schema.model.entities[this.data.entityName]
-		if (!entity.view && this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
-			renameConstraintsSqlBuilder(builder, entity, this.getNewConstraintName.bind(this))
-		}
-
-		if (this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE) {
-			acceptEveryFieldVisitor(this.schema.model, this.data.entityName, {
-				visitColumn: () => {},
-				visitManyHasManyOwning: () => {},
-				visitManyHasManyInverse: () => {},
-				visitOneHasOneInverse: () => {},
-				visitManyHasOne: () => {},
-				visitOneHasMany: () => {},
-				visitOneHasOneOwning: ({ relation }) => {
-					const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
-					const newUniqueConstraintName = NamingHelper.createUniqueConstraintName(this.data.newEntityName, [relation.name])
-					builder.renameConstraint(entity.tableName, uniqueConstraintName, newUniqueConstraintName)
-				},
-			})
-		}
-
-		this.subModification.createSql(builder)
+	public createSql(builder: MigrationBuilder, options: ModificationHandlerCreateSqlOptions): void {
+		this.subModification.createSql(builder, options)
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -79,9 +55,6 @@ export class UpdateEntityNameModificationHandler implements ModificationHandler<
 						return field
 					}),
 				),
-				this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
-					? updateEntity(this.data.entityName, renameConstraintSchemaUpdater(this.getNewConstraintName.bind(this)))
-					: undefined,
 				({ model }) => {
 					const { [this.data.entityName]: renamed, ...entities } = model.entities
 					const newEntities = {
@@ -133,15 +106,6 @@ export class UpdateEntityNameModificationHandler implements ModificationHandler<
 		)
 	}
 
-	private getNewConstraintName(constraint: Model.UniqueConstraint): string | null {
-		const generatedName = NamingHelper.createUniqueConstraintName(this.data.entityName, constraint.fields)
-		const isGenerated = constraint.name === generatedName
-		if (!isGenerated) {
-			null
-		}
-		return NamingHelper.createUniqueConstraintName(this.data.newEntityName, constraint.fields)
-	}
-
 	describe() {
 		return { message: `Change entity name from ${this.data.entityName} to ${this.data.newEntityName}` }
 	}

package/src/modifications/fields/RemoveFieldModification.ts

@@ -1,4 +1,4 @@
-import { acceptFieldVisitor, isInverseRelation, isRelation, NamingHelper } from '@contember/schema-utils'
+import { acceptFieldVisitor, isInverseRelation, isRelation } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { removeField, SchemaUpdater } from '../utils/schemaUpdateUtils'

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -13,25 +13,28 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { createModificationType, ModificationHandler, ModificationHandlerOptions } from '../ModificationHandler'
-import { acceptFieldVisitor, NamingHelper, PredicateDefinitionProcessor } from '@contember/schema-utils'
+import {
+	createModificationType,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
+import { acceptFieldVisitor, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import {
 	VERSION_ACL_PATCH,
-	VERSION_UPDATE_CONSTRAINT_NAME,
-	VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE,
+	VERSION_UPDATE_CONSTRAINT_FIELDS,
+	VERSION_UPDATE_INDEX_FIELDS,
 } from '../ModificationVersions'
-import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../utils/renameConstraintsHelper'
 import { changeValue } from '../utils/valueUtils'
 import { updateColumnNameModification } from '../columns'
 import { NoopModification } from '../NoopModification'
-import { SchemaWithMeta } from '../utils/schemaMeta'
 
 export class UpdateFieldNameModificationHandler implements ModificationHandler<UpdateFieldNameModificationData> {
 	private renameColumnSubModification: ModificationHandler<any> = new NoopModification()
 
 	constructor(
 		private readonly data: UpdateFieldNameModificationData,
-		private readonly schema: SchemaWithMeta,
+		private readonly schema: Schema,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		if (this.data.columnName) {
@@ -43,57 +46,39 @@ export class UpdateFieldNameModificationHandler implements ModificationHandler<U
 		}
 	}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, options: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.schema.model.entities[this.data.entityName]
 		if (entity.view) {
 			return
 		}
-		if (this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
-			renameConstraintsSqlBuilder(builder, entity, this.getNewConstraintName.bind(this))
-		}
-
-		if (this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE) {
-			acceptFieldVisitor(this.schema.model, this.data.entityName,  this.data.fieldName, {
-				visitColumn: () => {},
-				visitManyHasManyOwning: () => {},
-				visitManyHasManyInverse: () => {},
-				visitOneHasOneInverse: () => {},
-				visitManyHasOne: () => {},
-				visitOneHasMany: () => {},
-				visitOneHasOneOwning: ({ relation }) => {
-					const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
-					const newUniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [this.data.newFieldName])
-					builder.renameConstraint(entity.tableName, uniqueConstraintName, newUniqueConstraintName)
-				},
-			})
-		}
-
-		this.renameColumnSubModification.createSql(builder)
+		this.renameColumnSubModification.createSql(builder, options)
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
-		const updateConstraintName =
-			this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
-				? updateEntity(this.data.entityName, renameConstraintSchemaUpdater(this.getNewConstraintName.bind(this)))
-				: undefined
 		const updateConstraintFields =
-			this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME
+			this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_FIELDS
 				? updateEntity(this.data.entityName, ({ entity }) => {
 					return {
 						...entity,
-						unique: Object.fromEntries(
-							Object.entries(entity.unique).map(([name, unique]) => [
-								name,
-								{
-									...unique,
-									fields: unique.fields.map(changeValue(this.data.fieldName, this.data.newFieldName)),
-								},
-							]),
-						),
+						unique: entity.unique.map(unique => ({
+							...unique,
+							fields: unique.fields.map(changeValue(this.data.fieldName, this.data.newFieldName)),
+						})),
 					}
 				  })
 				: undefined
-
+		const updateIndexFields =
+			this.options.formatVersion >= VERSION_UPDATE_INDEX_FIELDS
+				? updateEntity(this.data.entityName, ({ entity }) => {
+					return {
+						...entity,
+						indexes: entity.indexes.map(unique => ({
+							...unique,
+							fields: unique.fields.map(changeValue(this.data.fieldName, this.data.newFieldName)),
+						})),
+					}
+				})
+				: undefined
 		const updateRelationReferences = updateEveryEntity(
 			updateEveryField(({ field, entity }) => {
 				const isUpdatedRelation = (entity: Model.Entity, relation: Model.AnyRelation | null) => {
@@ -189,26 +174,14 @@ export class UpdateFieldNameModificationHandler implements ModificationHandler<U
 			updateAclOp,
 			this.renameColumnSubModification.getSchemaUpdater(),
 			updateModel(
-				updateConstraintName,
 				updateConstraintFields,
+				updateIndexFields,
 				updateRelationReferences,
 				updateFieldName,
 			),
 		)
 	}
 
-
-	private getNewConstraintName(constraint: Model.UniqueConstraint): string | null {
-		const generatedName = NamingHelper.createUniqueConstraintName(this.data.entityName, constraint.fields)
-		const isGenerated = constraint.name === generatedName
-		if (!isGenerated) {
-			null
-		}
-		const newFieldNames = constraint.fields.map(changeValue(this.data.fieldName, this.data.newFieldName))
-		const newName = NamingHelper.createUniqueConstraintName(this.data.entityName, newFieldNames)
-		return newName === constraint.name ? null : newName
-	}
-
 	describe() {
 		return { message: `Change field name ${this.data.entityName}.${this.data.fieldName} to ${this.data.newFieldName}` }
 	}

package/src/modifications/indexes/CreateIndexModification.ts

@@ -1,56 +1,47 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
-import { acceptFieldVisitor } from '@contember/schema-utils'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
+} from '../ModificationHandler'
+import { wrapIdentifier } from '../../utils/dbHelpers'
+import { getIndexColumns } from './utils'
+import deepEqual from 'fast-deep-equal'
 
 export class CreateIndexModificationHandler implements ModificationHandler<CreateIndexModificationData> {
 	constructor(private readonly data: CreateIndexModificationData, private readonly schema: Schema) {}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, { databaseMetadata, invalidateDatabaseMetadata }: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.schema.model.entities[this.data.entityName]
 		if (entity.view) {
 			return
 		}
 		const fields = this.data.index.fields
-		const columns = fields.map(fieldName => {
-			return acceptFieldVisitor(this.schema.model, entity, fieldName, {
-				visitColumn: ({ column }) => {
-					return column.columnName
-				},
-				visitManyHasOne: ({ relation }) => {
-					return relation.joiningColumn.columnName
-				},
-				visitOneHasOneOwning: ({ relation }) => {
-					return relation.joiningColumn.columnName
-				},
-				visitOneHasMany: () => {
-					throw new Error(`Cannot create index on 1:m relation in ${entity.name}.${fieldName}`)
-				},
-				visitOneHasOneInverse: () => {
-					throw new Error(`Cannot create index on 1:1 inverse relation in ${entity.name}.${fieldName}`)
-				},
-				visitManyHasManyOwning: () => {
-					throw new Error(`Cannot create index on m:m relation in ${entity.name}.${fieldName}`)
-				},
-				visitManyHasManyInverse: () => {
-					throw new Error(`Cannot create index on m:m inverse relation in ${entity.name}.${fieldName}`)
-				},
-			})
-		})
-		builder.addIndex(entity.tableName, [...columns], {
-			name: this.data.index.name,
+		const columns = getIndexColumns({
+			fields,
+			entity,
+			model: this.schema.model,
 		})
+
+		const tableNameId = wrapIdentifier(entity.tableName)
+		const columnNameIds = columns.map(wrapIdentifier)
+
+		builder.sql(`CREATE INDEX ON ${tableNameId} (${columnNameIds.join(', ')})`)
+
+		invalidateDatabaseMetadata()
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
 		return updateModel(
 			updateEntity(this.data.entityName, ({ entity }) => ({
 				...entity,
-				indexes: {
+				indexes: [
 					...entity.indexes,
-					[this.data.index.name]: this.data.index,
-				},
+					this.data.index,
+				],
 			})),
 		)
 	}
@@ -67,17 +58,20 @@ export const createIndexModification = createModificationType({
 	handler: CreateIndexModificationHandler,
 })
 
+export interface CreateIndexModificationData {
+	entityName: string
+	index: Model.Index
+}
+
 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 })),
+			entity.indexes
+				.filter(it => !originalSchema.model.entities[entity.name].indexes.find(idx => deepEqual(idx.fields, it.fields)))
+				.map(index => createIndexModification.createModification({
+					entityName: entity.name,
+					index,
+				})),
 		)
 	}
 }
-
-export interface CreateIndexModificationData {
-	entityName: string
-	index: Model.Index
-}

package/src/modifications/indexes/RemoveIndexModification.ts

@@ -1,26 +1,45 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
+} from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
+import { getIndexColumns } from './utils'
+import { wrapIdentifier } from '../../utils/dbHelpers'
 
 export class RemoveIndexModificationHandler implements ModificationHandler<RemoveIndexModificationData>  {
 	constructor(private readonly data: RemoveIndexModificationData, private readonly schema: Schema) {}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, { databaseMetadata, invalidateDatabaseMetadata }: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.schema.model.entities[this.data.entityName]
 		if (entity.view) {
 			return
 		}
-		builder.dropIndex(entity.tableName, [], {
-			name: this.data.indexName,
+		const fields = this.getFields()
+
+		const columns = getIndexColumns({
+			entity,
+			fields,
+			model: this.schema.model,
 		})
+
+		const indexNames = databaseMetadata.getIndexNames({ tableName: entity.tableName, columnNames: columns })
+
+		for (const name of indexNames) {
+			builder.sql(`DROP INDEX ${wrapIdentifier(name)}`)
+		}
+		invalidateDatabaseMetadata()
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
+		const fields = this.getFields()
 		return updateModel(
 			updateEntity(this.data.entityName, ({ entity }) => {
-				const { [this.data.indexName]: removed, ...indexes } = entity.indexes
+				const indexes = entity.indexes.filter(it => !deepEqual(it.fields, fields))
 				return {
 					...entity,
 					indexes,
@@ -30,9 +49,20 @@ export class RemoveIndexModificationHandler implements ModificationHandler<Remov
 	}
 
 	describe() {
-		const fields = this.schema.model.entities[this.data.entityName].indexes[this.data.indexName].fields
+		const fields = this.getFields()
 		return { message: `Remove index (${fields.join(', ')}) on entity ${this.data.entityName}` }
 	}
+
+	getFields() {
+		const entity = this.schema.model.entities[this.data.entityName]
+		const fields = 'indexName' in this.data
+			? entity.indexes.find(it => it.name === this.data.indexName)?.fields
+			: this.data.fields
+		if (!fields) {
+			throw new Error()
+		}
+		return fields
+	}
 }
 
 export const removeIndexModification = createModificationType({
@@ -41,28 +71,38 @@ export const removeIndexModification = createModificationType({
 })
 
 
+export type RemoveIndexModificationData =
+	| {
+		entityName: string
+		indexName: string
+		fields?: never
+	}
+	| {
+		entityName: string
+		fields: readonly string[]
+		indexName?: never
+	}
+
 export class RemoveIndexDiffer implements Differ {
 
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(originalSchema.model.entities).flatMap(entity =>
-			Object.values(entity.indexes)
+			entity.indexes
 				.filter(
-					it =>
-						updatedSchema.model.entities[entity.name] &&
-						(!updatedSchema.model.entities[entity.name].indexes[it.name] ||
-							!deepEqual(it.fields, updatedSchema.model.entities[entity.name].indexes[it.name].fields)),
+					it => {
+						const updatedEntity = updatedSchema.model.entities[entity.name]
+						if (!updatedEntity) {
+							return false
+						}
+						return !updatedEntity.indexes.find(index => deepEqual(index.fields, it.fields))
+					},
 				)
 				.map(index =>
 					removeIndexModification.createModification({
 						entityName: entity.name,
-						indexName: index.name,
+						fields: index.fields,
 					}),
 				),
 		)
 	}
 }
-
-export interface RemoveIndexModificationData {
-	entityName: string
-	indexName: string
-}

package/src/modifications/indexes/utils.ts

@@ -0,0 +1,30 @@
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+
+export const getIndexColumns = ({ entity, fields, model }: { fields: readonly string[]; model: Model.Schema; entity: Model.Entity }) => {
+	return fields.map(fieldName => {
+		return acceptFieldVisitor(model, entity, fieldName, {
+			visitColumn: ({ column }) => {
+				return column.columnName
+			},
+			visitManyHasOne: ({ relation }) => {
+				return relation.joiningColumn.columnName
+			},
+			visitOneHasOneOwning: ({ relation }) => {
+				return relation.joiningColumn.columnName
+			},
+			visitOneHasMany: () => {
+				throw new Error(`Cannot create index on 1:m relation in ${entity.name}.${fieldName}`)
+			},
+			visitOneHasOneInverse: () => {
+				throw new Error(`Cannot create index on 1:1 inverse relation in ${entity.name}.${fieldName}`)
+			},
+			visitManyHasManyOwning: () => {
+				throw new Error(`Cannot create index on m:m relation in ${entity.name}.${fieldName}`)
+			},
+			visitManyHasManyInverse: () => {
+				throw new Error(`Cannot create index on m:m inverse relation in ${entity.name}.${fieldName}`)
+			},
+		})
+	})
+}

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

@@ -1,33 +1,25 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import {
-	addField,
-	addTakenIndexName,
-	SchemaUpdater,
-	updateEntity,
-	updateModel,
-	updateSchema,
-} from '../utils/schemaUpdateUtils'
+import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
-	ModificationHandler,
+	ModificationHandler, ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
-import { isInverseRelation, isOwningRelation, NamingHelper } from '@contember/schema-utils'
+import { isInverseRelation, isOwningRelation } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
-import { wrapIdentifier } from '@contember/database'
+import { wrapIdentifier } from '../../utils/dbHelpers'
 import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
 import { updateFieldNameModification } from '../fields'
-import { SchemaWithMeta } from '../utils/schemaMeta'
 
 export class ConvertOneHasManyToManyHasManyRelationModificationHandler implements ModificationHandler<ConvertOneHasManyToManyHasManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: ConvertOneHasManyToManyHasManyRelationModificationData,
-		private readonly schema: SchemaWithMeta,
+		private readonly schema: Schema,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		this.subModification = updateFieldNameModification.createHandler(
@@ -41,12 +33,12 @@ export class ConvertOneHasManyToManyHasManyRelationModificationHandler implement
 		)
 	}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, { systemSchema }: ModificationHandlerCreateSqlOptions): 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, this.schema, entity, targetEntity, normalizeManyHasManyRelation(this.data.owningSide))
+		createJunctionTableSql(builder, systemSchema, this.schema, entity, targetEntity, normalizeManyHasManyRelation(this.data.owningSide))
 		const joiningTable = this.data.owningSide.joiningTable
 		builder.sql(`
 			INSERT INTO ${wrapIdentifier(joiningTable.tableName)} (
@@ -66,7 +58,6 @@ export class ConvertOneHasManyToManyHasManyRelationModificationHandler implement
 			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)),
 		)
 	}
 
@@ -76,9 +67,6 @@ export class ConvertOneHasManyToManyHasManyRelationModificationHandler implement
 		}
 	}
 
-
-
-
 	private getRelation(): { entity: Model.Entity; relation: Model.ManyHasOneRelation } {
 		const entity = this.schema.model.entities[this.data.entityName]
 		const relation = entity.fields[this.data.fieldName]