@contember/schema-migrations 1.2.0-alpha.8 → 1.2.0-beta.1

package/src/modifications/relations/EnableOrphanRemovalModification.ts

@@ -1,12 +1,11 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { isOwningRelation } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 
-export const EnableOrphanRemovalModification: ModificationHandlerStatic<EnableOrphanRemovalModificationData> = class {
-	static id = 'enableOrphanRemoval'
+export class EnableOrphanRemovalModificationHandler implements ModificationHandler<EnableOrphanRemovalModificationData> {
 	constructor(private readonly data: EnableOrphanRemovalModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {}
@@ -30,11 +29,20 @@ export const EnableOrphanRemovalModification: ModificationHandlerStatic<EnableOr
 		}
 	}
 
-	static createModification(data: EnableOrphanRemovalModificationData) {
-		return { modification: this.id, ...data }
-	}
+}
+
+export interface EnableOrphanRemovalModificationData {
+	entityName: string
+	fieldName: string
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const enableOrphanRemovalModification = createModificationType({
+	id: 'enableOrphanRemoval',
+	handler: EnableOrphanRemovalModificationHandler,
+})
+
+export class EnableOrphanRemovalDiffer implements Differ {
+	 createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				isOwningRelation(originalRelation) &&
@@ -44,7 +52,7 @@ export const EnableOrphanRemovalModification: ModificationHandlerStatic<EnableOr
 				!originalRelation.orphanRemoval &&
 				updatedRelation.orphanRemoval
 			) {
-				return EnableOrphanRemovalModification.createModification({
+				return enableOrphanRemovalModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
 				})
@@ -53,8 +61,3 @@ export const EnableOrphanRemovalModification: ModificationHandlerStatic<EnableOr
 		})
 	}
 }
-
-export interface EnableOrphanRemovalModificationData {
-	entityName: string
-	fieldName: string
-}

package/src/modifications/relations/MakeRelationNotNullModification.ts

@@ -1,13 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { getEntity, tryGetColumnName } from '@contember/schema-utils'
 import { isIt } from '../../utils/isIt'
 import { updateRelations } from '../utils/diffUtils'
 
-export const MakeRelationNotNullModification: ModificationHandlerStatic<MakeRelationNotNullModificationData> = class {
-	static id = 'makeRelationNotNull'
+export class MakeRelationNotNullModificationHandler implements ModificationHandler<MakeRelationNotNullModificationData> {
 	constructor(private readonly data: MakeRelationNotNullModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -43,12 +42,21 @@ export const MakeRelationNotNullModification: ModificationHandlerStatic<MakeRela
 			failureWarning: 'Changing to not-null may fail in runtime',
 		}
 	}
+}
 
-	static createModification(data: MakeRelationNotNullModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface MakeRelationNotNullModificationData {
+	entityName: string
+	fieldName: string
+	// todo fillValue
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const makeRelationNotNullModification = createModificationType({
+	id: 'makeRelationNotNull',
+	handler: MakeRelationNotNullModificationHandler,
+})
+
+export class MakeRelationNotNullDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				originalRelation.type === updatedRelation.type &&
@@ -57,7 +65,7 @@ export const MakeRelationNotNullModification: ModificationHandlerStatic<MakeRela
 				!updatedRelation.nullable &&
 				originalRelation.nullable
 			) {
-				return MakeRelationNotNullModification.createModification({
+				return makeRelationNotNullModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
 				})
@@ -66,9 +74,3 @@ export const MakeRelationNotNullModification: ModificationHandlerStatic<MakeRela
 		})
 	}
 }
-
-export interface MakeRelationNotNullModificationData {
-	entityName: string
-	fieldName: string
-	// todo fillValue
-}

package/src/modifications/relations/MakeRelationNullableModification.ts

@@ -1,13 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { getEntity, tryGetColumnName } from '@contember/schema-utils'
 import { isIt } from '../../utils/isIt'
 import { updateRelations } from '../utils/diffUtils'
 
-export const MakeRelationNullableModification: ModificationHandlerStatic<MakeRelationNullableModificationData> = class {
-	static id = 'makeRelationNullable'
+export class MakeRelationNullableModificationHandler implements ModificationHandler<MakeRelationNullableModificationData> {
 	constructor(private readonly data: MakeRelationNullableModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
@@ -43,11 +42,21 @@ export const MakeRelationNullableModification: ModificationHandlerStatic<MakeRel
 		}
 	}
 
-	static createModification(data: MakeRelationNullableModificationData) {
-		return { modification: this.id, ...data }
-	}
+}
+
+export interface MakeRelationNullableModificationData {
+	entityName: string
+	fieldName: string
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+
+export const makeRelationNullableModification = createModificationType({
+	id: 'makeRelationNullable',
+	handler: MakeRelationNullableModificationHandler,
+})
+
+export class MakeRelationNullableDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				originalRelation.type === updatedRelation.type &&
@@ -56,7 +65,7 @@ export const MakeRelationNullableModification: ModificationHandlerStatic<MakeRel
 				updatedRelation.nullable &&
 				!originalRelation.nullable
 			) {
-				return MakeRelationNullableModification.createModification({
+				return makeRelationNullableModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
 				})
@@ -65,8 +74,3 @@ export const MakeRelationNullableModification: ModificationHandlerStatic<MakeRel
 		})
 	}
 }
-
-export interface MakeRelationNullableModificationData {
-	entityName: string
-	fieldName: string
-}

package/src/modifications/relations/{ToggleManyHasManyEventLogModification.ts → ToggleJunctionEventLogModification.ts}

@@ -1,7 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerOptions,
+} from '../ModificationHandler'
 import {
 	createEventTrigger,
 	createEventTrxTrigger,
@@ -12,8 +17,7 @@ import { isOwningRelation, isRelation } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 import { isIt } from '../../utils/isIt'
 
-export const ToggleJunctionEventLogModification: ModificationHandlerStatic<ToggleJunctionEventLogModificationData> = class {
-	static id = 'toggleJunctionEventLog'
+export class ToggleJunctionEventLogModificationHandler implements ModificationHandler<ToggleJunctionEventLogModificationData> {
 
 	constructor(
 		private readonly data: ToggleJunctionEventLogModificationData,
@@ -67,12 +71,21 @@ export const ToggleJunctionEventLogModification: ModificationHandlerStatic<Toggl
 			message: `${this.data.enabled ? 'Enable' : 'Disable'} event log for ${this.data.entityName}.${this.data.fieldName}`,
 		}
 	}
+}
 
-	static createModification(data: ToggleJunctionEventLogModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface ToggleJunctionEventLogModificationData {
+	entityName: string
+	fieldName: string
+	enabled: boolean
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const toggleJunctionEventLogModification = createModificationType({
+	id: 'toggleJunctionEventLog',
+	handler: ToggleJunctionEventLogModificationHandler,
+})
+
+export class ToggleJunctionEventLogDiffer implements Differ {
+	 createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				originalRelation.type === updatedRelation.type &&
@@ -82,7 +95,7 @@ export const ToggleJunctionEventLogModification: ModificationHandlerStatic<Toggl
 				const newValue = updatedRelation.joiningTable.eventLog?.enabled ?? false
 				const oldValue = originalRelation.joiningTable.eventLog?.enabled ?? false
 				if (newValue !== oldValue) {
-					return ToggleJunctionEventLogModification.createModification({
+					return toggleJunctionEventLogModification.createModification({
 						entityName: updatedEntity.name,
 						fieldName: updatedRelation.name,
 						enabled: newValue,
@@ -94,9 +107,3 @@ export const ToggleJunctionEventLogModification: ModificationHandlerStatic<Toggl
 
 	}
 }
-
-export interface ToggleJunctionEventLogModificationData {
-	entityName: string
-	fieldName: string
-	enabled: boolean
-}

package/src/modifications/relations/UpdateRelationOnDeleteModification.ts

@@ -1,12 +1,11 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
 import { updateRelations } from '../utils/diffUtils'
 
-export const UpdateRelationOnDeleteModification: ModificationHandlerStatic<UpdateRelationOnDeleteModificationData> = class {
-	static id = 'updateRelationOnDelete'
+export class UpdateRelationOnDeleteModificationHandler implements ModificationHandler<UpdateRelationOnDeleteModificationData> {
 	constructor(private readonly data: UpdateRelationOnDeleteModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {}
@@ -27,12 +26,21 @@ export const UpdateRelationOnDeleteModification: ModificationHandlerStatic<Updat
 	describe() {
 		return { message: `Change on-delete policy of relation ${this.data.entityName}.${this.data.fieldName}` }
 	}
+}
 
-	static createModification(data: UpdateRelationOnDeleteModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface UpdateRelationOnDeleteModificationData {
+	entityName: string
+	fieldName: string
+	onDelete: Model.OnDelete
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const updateRelationOnDeleteModification = createModificationType({
+	id: 'updateRelationOnDelete',
+	handler: UpdateRelationOnDeleteModificationHandler,
+})
+
+export class UpdateRelationOnDeleteDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
 				originalRelation.type === updatedRelation.type &&
@@ -40,7 +48,7 @@ export const UpdateRelationOnDeleteModification: ModificationHandlerStatic<Updat
 				isIt<Model.JoiningColumnRelation>(originalRelation, 'joiningColumn') &&
 				updatedRelation.joiningColumn.onDelete !== originalRelation.joiningColumn.onDelete
 			) {
-				return UpdateRelationOnDeleteModification.createModification({
+				return updateRelationOnDeleteModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
 					onDelete: updatedRelation.joiningColumn.onDelete,
@@ -50,9 +58,3 @@ export const UpdateRelationOnDeleteModification: ModificationHandlerStatic<Updat
 		})
 	}
 }
-
-export interface UpdateRelationOnDeleteModificationData {
-	entityName: string
-	fieldName: string
-	onDelete: Model.OnDelete
-}

package/src/modifications/relations/UpdateRelationOrderByModification.ts

@@ -1,12 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { updateRelations } from '../utils/diffUtils'
 
-export const UpdateRelationOrderByModification: ModificationHandlerStatic<UpdateRelationOrderByModificationData> = class {
-	static id = 'updateRelationOrderBy'
+export class UpdateRelationOrderByModificationHandler implements ModificationHandler<UpdateRelationOrderByModificationData> {
+
 	constructor(private readonly data: UpdateRelationOrderByModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {}
@@ -27,12 +27,21 @@ export const UpdateRelationOrderByModification: ModificationHandlerStatic<Update
 	describe() {
 		return { message: `Update order-by of relation ${this.data.entityName}.${this.data.fieldName}` }
 	}
+}
 
-	static createModification(data: UpdateRelationOrderByModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface UpdateRelationOrderByModificationData {
+	entityName: string
+	fieldName: string
+	orderBy: readonly Model.OrderBy[]
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const updateRelationOrderByModification = createModificationType({
+	id: 'updateRelationOrderBy',
+	handler: UpdateRelationOrderByModificationHandler,
+})
+
+export class UpdateRelationOrderByDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ updatedRelation, originalRelation, updatedEntity }) => {
 			const isItOrderable = (relation: Model.AnyRelation): relation is Model.OrderableRelation & Model.AnyRelation =>
 				relation.type === Model.RelationType.ManyHasMany || relation.type === Model.RelationType.OneHasMany
@@ -42,7 +51,7 @@ export const UpdateRelationOrderByModification: ModificationHandlerStatic<Update
 				isItOrderable(originalRelation) &&
 				!deepEqual(updatedRelation.orderBy || [], originalRelation.orderBy || [])
 			) {
-				return UpdateRelationOrderByModification.createModification({
+				return updateRelationOrderByModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
 					orderBy: updatedRelation.orderBy || [],
@@ -52,9 +61,3 @@ export const UpdateRelationOrderByModification: ModificationHandlerStatic<Update
 		})
 	}
 }
-
-export interface UpdateRelationOrderByModificationData {
-	entityName: string
-	fieldName: string
-	orderBy: readonly Model.OrderBy[]
-}

package/src/modifications/relations/index.ts

@@ -6,6 +6,6 @@ export * from './DisableOrphanRemovalModification'
 export * from './EnableOrphanRemovalModification'
 export * from './MakeRelationNotNullModification'
 export * from './MakeRelationNullableModification'
-export * from './ToggleManyHasManyEventLogModification'
+export * from './ToggleJunctionEventLogModification'
 export * from './UpdateRelationOnDeleteModification'
 export * from './UpdateRelationOrderByModification'

package/src/modifications/settings/UpdateSettingsModification.ts

@@ -0,0 +1,87 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Schema, Settings } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import deepEqual from 'fast-deep-equal'
+
+export class UpdateSettingsModificationHandler implements ModificationHandler<UpdateSettingsModificationData> {
+	constructor(
+		private readonly data: UpdateSettingsModificationData,
+	) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			const { [this.data.key]: _, ...settings } = schema.settings
+			if (this.data.op === 'unset') {
+				return {
+					...schema,
+					settings,
+				}
+			}
+			return {
+				...schema,
+				settings: { ...settings, [this.data.key]: this.data.value },
+			}
+		}
+	}
+
+
+	describe() {
+		return { message: `Change settings of ${this.data.key}` }
+	}
+
+}
+
+export const updateSettingsModification = createModificationType({
+	id: 'updateSettings',
+	handler: UpdateSettingsModificationHandler,
+})
+
+export class UpdateSettingsDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		const allKeys = Array.from(new Set([
+			...Object.keys(originalSchema.settings),
+			...Object.keys(updatedSchema.settings),
+		] as (keyof Settings.Schema)[]))
+
+		return allKeys
+			.filter(key => !deepEqual(originalSchema.settings[key], updatedSchema.settings[key]))
+			.map(key => {
+				const value = updatedSchema.settings[key]
+				if (value === undefined) {
+					return updateSettingsModification.createModification({
+						op: 'unset',
+						key,
+					})
+				}
+				return updateSettingsModification.createModification({
+					op: 'set',
+					key,
+					value,
+				})
+			})
+	}
+}
+
+
+
+export interface SetSettingsModificationData<K extends keyof Settings.Schema = keyof Settings.Schema> {
+	op: 'set'
+	key: K
+	value: Settings.Schema[K]
+}
+
+
+export interface UnsetSettingsModificationData<K extends keyof Settings.Schema = keyof Settings.Schema> {
+	op: 'unset'
+	key: K
+}
+
+
+export type UpdateSettingsModificationData =
+	| SetSettingsModificationData
+	| UnsetSettingsModificationData

package/src/modifications/settings/index.ts

@@ -0,0 +1 @@
+export * from './UpdateSettingsModification'

package/src/modifications/utils/columnUtils.ts

@@ -0,0 +1,5 @@
+import { Model } from '@contember/schema'
+
+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: {
@@ -269,7 +271,14 @@ export const removeField = (entityName: string, fieldName: string, version: numb
 			updateModel(
 				updateEntity(entity.name, ({ entity }) => {
 					const { [field.name]: removed, ...fields } = entity.fields
-					return { ...entity, fields }
+					const indexes = Object.entries(entity.indexes).filter(([, index]) => !index.fields.includes(field.name))
+					const unique = Object.entries(entity.unique).filter(([, index]) => !index.fields.includes(field.name))
+					return {
+						...entity,
+						fields,
+						indexes: Object.fromEntries(indexes),
+						unique: Object.fromEntries(unique),
+					}
 				}),
 				isRelation(field) && isInverseRelation(field)
 					? updateEntity(
@@ -281,3 +290,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,
+		},
+	},
+})