@contember/schema-migrations 1.2.0-alpha.14 → 1.2.0-alpha.16

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -1,4 +1,4 @@
-import { MigrationBuilder } from '@contember/database-migrations'
+import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
@@ -6,6 +6,7 @@ import deepEqual from 'fast-deep-equal'
 import { updateColumns } from '../utils/diffUtils'
 import { wrapIdentifier } from '@contember/database'
 import { getColumnSqlType } from '../utils/columnUtils'
+import { getEntityDependantViews } from '../utils/viewDependencies'
 
 export class UpdateColumnDefinitionModificationHandler implements ModificationHandler<UpdateColumnDefinitionModificationData>  {
 	constructor(private readonly data: UpdateColumnDefinitionModificationData, private readonly schema: Schema) {}
@@ -17,14 +18,21 @@ export class UpdateColumnDefinitionModificationHandler implements ModificationHa
 		}
 		const oldColumn = entity.fields[this.data.fieldName] as Model.AnyColumn
 		const newColumn = this.data.definition
-		const newType = newColumn.columnType !== oldColumn.columnType
-			? getColumnSqlType(newColumn)
-			: undefined
+
+		const hasNewSequence = !oldColumn.sequence && newColumn.sequence
+		const hasNewType = newColumn.columnType !== oldColumn.columnType
+		const columnType = getColumnSqlType(newColumn)
+
+		const usingCast = `${wrapIdentifier(oldColumn.columnName)}::${columnType}`
 
 		builder.alterColumn(entity.tableName, oldColumn.columnName, {
-			type: newType,
+			type: hasNewSequence || hasNewType ? columnType : undefined,
 			notNull: oldColumn.nullable !== newColumn.nullable ? !newColumn.nullable : undefined,
-			using: newType !== undefined ? `${wrapIdentifier(oldColumn.columnName)}::${newType}` : undefined,
+			using: hasNewSequence
+				? `COALESCE(${usingCast}, nextval(PG_GET_SERIAL_SEQUENCE(${escapeValue(entity.tableName)}, ${escapeValue(oldColumn.columnName)})))`
+				: hasNewType
+					? usingCast
+					: undefined,
 			sequenceGenerated: oldColumn.sequence && !newColumn.sequence ? false : (!oldColumn.sequence ? newColumn.sequence : undefined),
 		})
 
@@ -79,7 +87,7 @@ type SequenceDefinitionAlter =
 	}
 
 type ColumnDefinitionAlter =
-	& Model.AnyColumn
+	& Omit<Model.AnyColumn, 'sequence' | 'columnName' | 'name'>
 	& {
 		sequence?: SequenceDefinitionAlter
 	}
@@ -95,22 +103,23 @@ export const updateColumnDefinitionModification = createModificationType({
 	handler: UpdateColumnDefinitionModificationHandler,
 })
 
-export class UpdateColumnDefinitionDiffer implements Differ {
+export class UpdateColumnDefinitionDiffer implements Differ<UpdateColumnDefinitionModificationData> {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateColumns(originalSchema, updatedSchema, ({ originalColumn, updatedColumn, updatedEntity }) => {
 			const {
 				name: {},
 				columnName: {},
 				...updatedDefinition
-			} = updatedColumn as any
+			} = updatedColumn
 			const {
 				name: {},
 				columnName: {},
 				...originalDefinition
-			} = originalColumn as any
+			} = originalColumn
 			if (deepEqual(updatedDefinition, originalDefinition)) {
 				return undefined
 			}
+
 			return updateColumnDefinitionModification.createModification({
 				entityName: updatedEntity.name,
 				fieldName: updatedColumn.name,

package/src/modifications/differs/RemoveChangedViewDiffer.ts

@@ -1,9 +1,8 @@
 import { Differ } from '../ModificationHandler'
-import { Model, Schema } from '@contember/schema'
+import { Schema } from '@contember/schema'
 import deepEqual from 'fast-deep-equal'
-import { removeEntityModification } from '../entities'
-import { getViewDirectDependants } from '../utils/viewDependencies'
-import { Migration } from '../../Migration'
+import { cascadeRemoveDependantViews } from '../utils/viewDependencies'
+import { UpdateColumnDefinitionDiffer } from '../columns'
 
 export class RemoveChangedViewDiffer implements Differ {
 	constructor() {
@@ -18,25 +17,13 @@ export class RemoveChangedViewDiffer implements Differ {
 				}
 				return !deepEqual(updatedEntity.view, it.view)
 			})
-		if (changedViews.length === 0) {
+		const columnDiffer = new UpdateColumnDefinitionDiffer()
+		const columnChanges = columnDiffer.createDiff(originalSchema, updatedSchema)
+		if (changedViews.length === 0 && columnChanges.length === 0) {
 			return []
 		}
-		const removed = new Set<string>()
-		const dependants = getViewDirectDependants(originalSchema.model)
-		const modifications: Migration.Modification[] = []
-		const removeCascade = (entity: Model.Entity) => {
-			if (removed.has(entity.name)) {
-				return
-			}
-			removed.add(entity.name)
-			for (const dependant of dependants.get(entity.name) ?? []) {
-				removeCascade(dependant)
-			}
-			modifications.push(removeEntityModification.createModification({ entityName: entity.name }))
-		}
-		for (const changed of changedViews) {
-			removeCascade(changed)
-		}
-		return modifications
+		const changedColumnsEntities = Array.from(new Set(columnChanges.map(it => it.entityName)))
+			.map(it => originalSchema.model.entities[it])
+		return cascadeRemoveDependantViews(originalSchema.model, [...changedViews, ...changedColumnsEntities])
 	}
 }

package/src/modifications/entities/RemoveEntityModification.ts

@@ -20,11 +20,12 @@ import {
 import { VERSION_ACL_PATCH, VERSION_REMOVE_REFERENCING_RELATIONS } from '../ModificationVersions'
 import { isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { removeFieldModification } from '../fields'
+import { SchemaWithMeta } from '../utils/schemaMeta'
 
 export class RemoveEntityModificationHandler implements ModificationHandler<RemoveEntityModificationData> {
 	constructor(
 		private readonly data: RemoveEntityModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {}
 

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -19,13 +19,14 @@ 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: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		this.subModification = data.tableName

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -20,13 +20,14 @@ import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../u
 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: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		if (this.data.columnName) {

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

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

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -1,6 +1,13 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import {
+	addTakenIndexName,
+	SchemaUpdater,
+	updateEntity,
+	updateField,
+	updateModel,
+	updateSchema,
+} from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
@@ -11,13 +18,14 @@ import { isOwningRelation, NamingHelper } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 import { NoopModification } from '../NoopModification'
 import { updateFieldNameModification } from '../fields'
+import { resolveIndexName, SchemaWithMeta } from '../utils/schemaMeta'
 
 export class ConvertOneToManyRelationModificationHandler implements ModificationHandler<ConvertOneToManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: ConvertOneToManyRelationModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		const { relation } = this.getRelation()
@@ -36,7 +44,12 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 
 	public createSql(builder: MigrationBuilder): void {
 		const { entity, relation } = this.getRelation()
-		builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
+		const columnName = relation.joiningColumn.columnName
+		const proposedIndexName = NamingHelper.createForeignKeyIndexName(entity.tableName, columnName)
+		const indexName = resolveIndexName(this.schema, proposedIndexName)
+		builder.addIndex(entity.tableName, columnName, {
+			name: indexName,
+		})
 		const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
 		builder.dropConstraint(entity.tableName, uniqueConstraintName)
 		this.subModification.createSql(builder)
@@ -45,6 +58,8 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 	public getSchemaUpdater(): SchemaUpdater {
 		const { relation } = this.getRelation()
 		const { entityName, fieldName } = this.data
+		const entity = this.schema.model.entities[this.data.entityName]
+		const field = entity.fields[fieldName] as Model.OneHasOneOwningRelation
 		return updateSchema(
 			updateModel(
 				updateEntity(
@@ -72,6 +87,7 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 						),
 					),
 				) : undefined,
+			addTakenIndexName(NamingHelper.createForeignKeyIndexName(entity.tableName, field.joiningColumn.columnName)),
 		)
 	}
 

package/src/modifications/relations/CreateRelationModification.ts

@@ -7,7 +7,14 @@ import {
 	NamingHelper,
 } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
+import {
+	addField,
+	addTakenIndexName,
+	SchemaUpdater,
+	updateEntity,
+	updateModel,
+	updateSchema,
+} from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
@@ -19,13 +26,14 @@ import { createFields } from '../utils/diffUtils'
 import { getPrimaryColumnType } from '../utils/getPrimaryColumnType'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
 import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
+import { resolveIndexName, SchemaWithMeta } from '../utils/schemaMeta'
 
 
 export class CreateRelationModificationHandler implements ModificationHandler<CreateRelationModificationData> {
 
 	constructor(
 		private readonly data: CreateRelationModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {}
 
@@ -61,7 +69,12 @@ export class CreateRelationModificationHandler implements ModificationHandler<Cr
 		acceptRelationTypeVisitor(this.schema.model, entity, this.getNormalizedOwningSide(), {
 			visitManyHasOne: ({ relation }) => {
 				createOwningSide(relation)
-				builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
+				const columnName = relation.joiningColumn.columnName
+				const proposedIndexName = NamingHelper.createForeignKeyIndexName(entity.tableName, columnName)
+				const indexName = resolveIndexName(this.schema, proposedIndexName)
+				builder.addIndex(entity.tableName, columnName, {
+					name: indexName,
+				})
 			},
 			visitOneHasMany: () => {},
 			visitOneHasOneOwning: ({ relation }) => {
@@ -71,17 +84,26 @@ export class CreateRelationModificationHandler implements ModificationHandler<Cr
 			},
 			visitOneHasOneInverse: () => {},
 			visitManyHasManyOwning: ({ relation }) => {
-				createJunctionTableSql(builder, this.options.systemSchema,  entity, targetEntity, relation)
+				createJunctionTableSql(builder, this.options.systemSchema, this.schema, entity, targetEntity, relation)
 			},
 			visitManyHasManyInverse: () => {},
 		})
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
-		return updateModel(
-			updateEntity(this.data.entityName, addField(this.getNormalizedOwningSide())),
-			this.data.inverseSide !== undefined
-				? updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))
+		const entity = this.schema.model.entities[this.data.entityName]
+		return updateSchema(
+			updateModel(
+				updateEntity(this.data.entityName, addField(this.getNormalizedOwningSide())),
+				this.data.inverseSide !== undefined
+					? updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))
+					: undefined,
+			),
+			this.data.owningSide.type === Model.RelationType.ManyHasOne
+				? addTakenIndexName(NamingHelper.createForeignKeyIndexName(entity.tableName, this.data.owningSide.joiningColumn.columnName))
+				: undefined,
+			this.data.owningSide.type === Model.RelationType.ManyHasMany && isOwningRelation(this.data.owningSide)
+				? addTakenIndexName(NamingHelper.createJunctionTablePrimaryConstraintName(this.data.owningSide.joiningTable.tableName))
 				: undefined,
 		)
 	}

package/src/modifications/utils/columnUtils.ts

@@ -1,5 +1,5 @@
 import { Model } from '@contember/schema'
 
-export const getColumnSqlType = (column: Model.AnyColumn) => column.type === Model.ColumnType.Enum
+export const getColumnSqlType = (column: Pick<Model.AnyColumn, 'type' | 'columnType'>) => column.type === Model.ColumnType.Enum
 	? `"${column.columnType}"`
 	: column.columnType

package/src/modifications/utils/createJunctionTable.ts

@@ -2,10 +2,12 @@ import { createEventTrigger, createEventTrxTrigger } from './sqlUpdateUtils'
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model } from '@contember/schema'
 import { getPrimaryColumnType } from './getPrimaryColumnType'
+import { resolveIndexName, SchemaWithMeta } from './schemaMeta'
 
 export const createJunctionTableSql = (
 	builder: MigrationBuilder,
 	systemSchema: string,
+	schema: SchemaWithMeta,
 	entity: Model.Entity,
 	targetEntity: Model.Entity,
 	relation: Model.ManyHasManyOwningRelation,
@@ -30,12 +32,12 @@ export const createJunctionTableSql = (
 				onDelete: 'CASCADE',
 			},
 		},
-		{
-			constraints: {
-				primaryKey: primaryColumns,
-			},
-		},
 	)
+	const proposedIndexName = `${relation.joiningTable.tableName}_pkey`
+	const indexName = resolveIndexName(schema, proposedIndexName)
+	builder.addConstraint(relation.joiningTable.tableName, indexName, {
+		primaryKey: primaryColumns,
+	})
 	if (relation.joiningTable.eventLog.enabled) {
 		createEventTrigger(builder, systemSchema, relation.joiningTable.tableName, primaryColumns)
 		createEventTrxTrigger(builder, systemSchema, relation.joiningTable.tableName)

package/src/modifications/utils/diffUtils.ts

@@ -4,7 +4,7 @@ import { isColumn, isRelation } from '@contember/schema-utils'
 import { isDefined } from '../../utils/isDefined'
 import deepEqual from 'fast-deep-equal'
 
-export const updateFields = (
+export const updateFields = <Data = { [field: string]: any }>(
 	originalSchema: Schema,
 	updatedSchema: Schema,
 	modificationGenerator: (args: {
@@ -12,8 +12,8 @@ export const updateFields = (
 		updatedEntity: Model.Entity
 		originalField: Model.AnyField
 		updatedField: Model.AnyField
-	}) => Migration.Modification | Migration.Modification[] | undefined,
-): Migration.Modification[] => {
+	}) => Migration.Modification<Data> | Migration.Modification<Data>[] | undefined,
+): Migration.Modification<Data>[] => {
 	return Object.values(updatedSchema.model.entities)
 		.filter(({ name }) => originalSchema.model.entities[name])
 		.flatMap(updatedEntity => {
@@ -43,7 +43,7 @@ export const updateFields = (
 		})
 }
 
-export const updateColumns = (
+export const updateColumns = <Data = { [field: string]: any }>(
 	originalSchema: Schema,
 	updatedSchema: Schema,
 	modificationGenerator: (args: {
@@ -51,8 +51,8 @@ export const updateColumns = (
 		originalColumn: Model.AnyColumn
 		updatedEntity: Model.Entity
 		updatedColumn: Model.AnyColumn
-	}) => Migration.Modification | undefined,
-) => {
+	}) => Migration.Modification<Data> | undefined,
+): Migration.Modification<Data>[] => {
 	return updateFields(
 		originalSchema,
 		updatedSchema,
@@ -70,7 +70,7 @@ export const updateColumns = (
 	)
 }
 
-export const updateRelations = (
+export const updateRelations = <Data = { [field: string]: any }>(
 	originalSchema: Schema,
 	updatedSchema: Schema,
 	modificationGenerator: (args: {
@@ -78,8 +78,8 @@ export const updateRelations = (
 		originalRelation: Model.AnyRelation
 		updatedEntity: Model.Entity
 		updatedRelation: Model.AnyRelation
-	}) => Migration.Modification | undefined,
-) => {
+	}) => Migration.Modification<Data> | undefined,
+): Migration.Modification<Data>[] => {
 	return updateFields(
 		originalSchema,
 		updatedSchema,
@@ -97,15 +97,15 @@ export const updateRelations = (
 	)
 }
 
-export const createFields = (
+export const createFields = <Data = { [field: string]: any }>(
 	originalSchema: Schema,
 	updatedSchema: Schema,
 	modificationGenerator: (args: {
 		originalEntity: Model.Entity
 		updatedEntity: Model.Entity
 		newField: Model.AnyField
-	}) => Migration.Modification | undefined,
-) => {
+	}) => Migration.Modification<Data> | undefined,
+): Migration.Modification<Data>[] => {
 	return Object.values(updatedSchema.model.entities)
 		.filter(({ name }) => originalSchema.model.entities[name])
 		.flatMap(updatedEntity => {

package/src/modifications/utils/schemaMeta.ts

@@ -0,0 +1,18 @@
+import { Schema } from '@contember/schema'
+
+export type SchemaWithMeta =
+	& Schema
+	& {
+		meta?: {
+			takenIndexNames: Record<string, true>
+		}
+	}
+
+export const resolveIndexName = (schema: SchemaWithMeta, indexName: string): string => {
+	for (let i = 0; ; i++) {
+		const name = indexName + (i === 0 ? '' : `${i}`)
+		if (!schema.meta || !(name in schema.meta.takenIndexNames)) {
+			return name
+		}
+	}
+}

package/src/modifications/utils/schemaUpdateUtils.ts

@@ -3,8 +3,10 @@ import { SchemaUpdateError } from '../exceptions'
 import { isDefined } from '../../utils/isDefined'
 import { isInverseRelation, isOwningRelation, isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { VERSION_ACL_PATCH, VERSION_REMOVE_RELATION_INVERSE_SIDE } from '../ModificationVersions'
+import { resolveIndexName, SchemaWithMeta } from './schemaMeta'
 
-export type SchemaUpdater = (args: { schema: Schema }) => Schema
+
+export type SchemaUpdater = (args: { schema: SchemaWithMeta }) => SchemaWithMeta
 export type ModelUpdater = (args: { schema: Schema; model: Model.Schema }) => Model.Schema
 export type EntityUpdater = (args: { schema: Schema; model: Model.Schema; entity: Model.Entity }) => Model.Entity
 export type FieldUpdater<In extends Model.AnyField, Out extends Model.AnyField> = (args: {
@@ -281,3 +283,14 @@ export const removeField = (entityName: string, fieldName: string, version: numb
 		)({ schema })
 	}
 }
+
+export const addTakenIndexName = (indexName: string): SchemaUpdater => ({ schema }) => ({
+	...schema,
+	meta: {
+		...schema.meta,
+		takenIndexNames: {
+			...schema.meta?.takenIndexNames,
+			[resolveIndexName(schema, indexName)]: true,
+		},
+	},
+})

package/src/modifications/utils/viewDependencies.ts

@@ -1,8 +1,10 @@
 import { Model } from '@contember/schema'
+import { Migration } from '../../Migration'
+import { removeEntityModification } from '../entities'
 
-type ViewDependants = Map<string, Set<Model.Entity>>
-export const getViewDirectDependants = (model: Model.Schema): ViewDependants => {
-	const dependants: ViewDependants = new Map(Object.values(model.entities).filter(it => it.view).map(it => [it.name, new Set()]))
+type EntityDependantViews = Map<string, Set<Model.Entity>>
+export const getEntityDependantViews = (model: Model.Schema): EntityDependantViews => {
+	const dependants: EntityDependantViews = new Map(Object.values(model.entities).map(it => [it.name, new Set()]))
 	for (const entity of Object.values(model.entities)) {
 		if (!entity.view?.dependencies?.length) {
 			continue
@@ -10,11 +12,32 @@ export const getViewDirectDependants = (model: Model.Schema): ViewDependants =>
 		for (const dependency of entity.view.dependencies) {
 			const entityDependants = dependants.get(dependency)
 			if (!entityDependants) {
-				// not a view
-				continue
+				throw new Error()
 			}
 			entityDependants.add(entity)
 		}
 	}
 	return dependants
 }
+
+export const cascadeRemoveDependantViews = (model: Model.Schema, entities: Model.Entity[]): Migration.Modification[] => {
+	const removed = new Set<string>()
+	const dependants = getEntityDependantViews(model)
+	const modifications: Migration.Modification[] = []
+	const removeCascade = (entity: Model.Entity) => {
+		if (removed.has(entity.name)) {
+			return
+		}
+		removed.add(entity.name)
+		for (const dependant of dependants.get(entity.name) ?? []) {
+			removeCascade(dependant)
+		}
+		if (entity.view) {
+			modifications.push(removeEntityModification.createModification({ entityName: entity.name }))
+		}
+	}
+	for (const entity of entities) {
+		removeCascade(entity)
+	}
+	return modifications
+}

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

@@ -64,9 +64,10 @@ testMigrations('convert one has many to many has many', {
 	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")
+		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE
 	);
+	ALTER TABLE "article_categories"
+		ADD 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

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

@@ -90,9 +90,10 @@ testMigrations('create many has many relation (post with categories)', {
 		ADD "title" text;
 	CREATE TABLE "post_categories" (
 		"post_id"     uuid NOT NULL REFERENCES "post"("id") ON DELETE CASCADE,
-		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE,
-		CONSTRAINT "post_categories_pkey" PRIMARY KEY ("post_id", "category_id")
+		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE
 	);
+	ALTER TABLE "post_categories"
+		ADD CONSTRAINT "post_categories_pkey" PRIMARY KEY ("post_id", "category_id");
 	CREATE TRIGGER "log_event"
 		AFTER INSERT OR UPDATE OR DELETE
 		ON "post_categories"