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

package/src/MigrationDescriber.ts

@@ -4,6 +4,7 @@ import {
 	ModificationDescription,
 	ModificationDescriptionContext,
 	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerFactory,
 	ModificationHandlerOptions,
 	SchemaUpdateError,
@@ -14,23 +15,22 @@ import { Schema } from '@contember/schema'
 
 export interface ModificationDescriptionResult {
 	modification: Migration.Modification
-	sql: string
 	schema: Schema
 	description: ModificationDescription
 	handler: ModificationHandler<any>
+	getSql: (options: ModificationHandlerCreateSqlOptions) => string
 }
 
 export class MigrationDescriber {
 	constructor(private readonly modificationHandlerFactory: ModificationHandlerFactory) {
 	}
 
-	public async describeModification(
+	public describeModification(
 		schema: Schema,
 		modification: Migration.Modification,
 		options: ModificationHandlerOptions,
 		modificationDescriptionContext: ModificationDescriptionContext = emptyModificationDescriptionContext,
-	): Promise<ModificationDescriptionResult> {
-		const builder = createMigrationBuilder()
+	): ModificationDescriptionResult {
 		const modificationHandler = this.modificationHandlerFactory.create(
 			modification.modification,
 			modification,
@@ -45,29 +45,31 @@ export class MigrationDescriber {
 			}
 			throw new SchemaUpdateError(e.message + '\n for modification: \n' + JSON.stringify(modification))
 		}
-		await modificationHandler.createSql(builder)
 		return {
 			modification,
 			schema,
-			sql: builder.getSql(),
+			getSql: options => {
+				const builder = createMigrationBuilder()
+				modificationHandler.createSql(builder, options)
+				return builder.getSql()
+			},
 			description: modificationHandler.describe(modificationDescriptionContext),
 			handler: modificationHandler,
 		}
 	}
 
-	public async describeModifications(schema: Schema, migration: Migration, systemSchema: string): Promise<ModificationDescriptionResult[]> {
+	public describeModifications(schema: Schema, migration: Migration): ModificationDescriptionResult[] {
 		const result = []
 		const createdEntities = []
 		for (const modification of migration.modifications) {
 			if (modification.modification === createEntityModification.id) {
 				createdEntities.push(modification.entity.name)
 			}
-			const description = await this.describeModification(
+			const description = this.describeModification(
 				schema,
 				modification,
 				{
 					formatVersion: migration.formatVersion,
-					systemSchema,
 				},
 				{
 					createdEntities,

package/src/SchemaDiffer.ts

@@ -44,12 +44,12 @@ import {
 } from './modifications'
 import { ChangeViewNonViewDiffer, RemoveChangedFieldDiffer, RemoveChangedViewDiffer } from './modifications/differs'
 import { CreateIndexDiffer, RemoveIndexDiffer } from './modifications/indexes'
-import { SchemaWithMeta } from './modifications/utils/schemaMeta'
 import { CreateTriggerDiffer, RemoveTriggerDiffer, UpdateTriggerDiffer } from './modifications/actions'
 import { UpdateTargetDiffer } from './modifications/actions/UpdateTargetModification'
 import { CreateTargetDiffer } from './modifications/actions/CreateTargetModification'
 import { RemoveTargetDiffer } from './modifications/actions/RemoveTargetModification'
 import { UpdateSettingsDiffer } from './modifications/settings'
+import { RemoveIndexNamesDiffer } from './modifications/upgrade/RemoveIndexNamesModification'
 
 type DiffOptions = { skipRecreateValidation?: boolean; skipInitialSchemaValidation?: boolean }
 
@@ -72,6 +72,7 @@ export class SchemaDiffer {
 		}
 
 		const differs: Differ[] = [
+			new RemoveIndexNamesDiffer(),
 			new UpdateSettingsDiffer(),
 			new ConvertOneToManyRelationDiffer(),
 			new ConvertOneHasManyToManyHasManyRelationDiffer(),
@@ -125,8 +126,7 @@ export class SchemaDiffer {
 
 
 		if (!skipRecreateValidation) {
-			const { meta, ...appliedDiffsSchema2 } = appliedDiffsSchema as SchemaWithMeta
-			const errors = deepCompare(updatedSchema, appliedDiffsSchema2, [])
+			const errors = deepCompare(updatedSchema, appliedDiffsSchema, [])
 			if (errors.length === 0) {
 				return diffs
 			}

package/src/SchemaMigrator.ts

@@ -1,17 +1,15 @@
 import { Schema } from '@contember/schema'
 import { ModificationHandlerFactory } from './modifications'
 import { Migration } from './Migration'
-import { SchemaWithMeta } from './modifications/utils/schemaMeta'
 
 export class SchemaMigrator {
 	constructor(private readonly modificationHandlerFactory: ModificationHandlerFactory) {}
 
-	public applyModifications(schema: Schema, diff: readonly Migration.Modification[], formatVersion: number): SchemaWithMeta {
+	public applyModifications(schema: Schema, diff: readonly Migration.Modification[], formatVersion: number): Schema {
 		for (const modification of diff) {
 			const { modification: name, ...data } = modification
 			const modificationHandler = this.modificationHandlerFactory.create(name, data, schema, {
 				formatVersion,
-				systemSchema: 'system', // not important here
 			})
 			schema = modificationHandler.getSchemaUpdater()({ schema })
 		}

package/src/modifications/ModificationHandler.ts

@@ -2,7 +2,7 @@ import { MigrationBuilder } from '@contember/database-migrations'
 import { SchemaUpdater } from './utils/schemaUpdateUtils'
 import { Schema } from '@contember/schema'
 import { Migration } from '../Migration'
-import { SchemaWithMeta } from './utils/schemaMeta'
+import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 export interface ModificationDescription {
 	message: string
@@ -14,20 +14,25 @@ export const emptyModificationDescriptionContext: ModificationDescriptionContext
 export type ModificationDescriptionContext = { createdEntities: string[] }
 
 export interface ModificationHandler<Data> {
-	createSql(builder: MigrationBuilder): void | Promise<void>
+	createSql(builder: MigrationBuilder, options: ModificationHandlerCreateSqlOptions): void
 
 	getSchemaUpdater(): SchemaUpdater
 
 	describe(context: ModificationDescriptionContext): ModificationDescription
 }
 
+export interface ModificationHandlerCreateSqlOptions {
+	systemSchema: string
+	databaseMetadata: SchemaDatabaseMetadata
+	invalidateDatabaseMetadata: () => void
+}
+
 export interface ModificationHandlerOptions {
 	formatVersion: number
-	systemSchema: string
 }
 
 export interface ModificationHandlerConstructor<Data> {
-	new(data: Data, schema: SchemaWithMeta, options: ModificationHandlerOptions): ModificationHandler<Data>
+	new(data: Data, schema: Schema, options: ModificationHandlerOptions): ModificationHandler<Data>
 }
 
 export interface Differ<Data = { [field: string]: any }> {
@@ -38,7 +43,7 @@ export interface Differ<Data = { [field: string]: any }> {
 export interface ModificationType<Id extends String, Data> {
 	id: Id
 	createModification: (data: Data) => Migration.Modification<Data>
-	createHandler: (data: Data, schema: SchemaWithMeta, options: ModificationHandlerOptions) => ModificationHandler<Data>
+	createHandler: (data: Data, schema: Schema, options: ModificationHandlerOptions) => ModificationHandler<Data>
 }
 
 export const createModificationType = <Data, Id extends string>({ handler, id }: {

package/src/modifications/ModificationHandlerFactory.ts

@@ -4,44 +4,44 @@ import { patchAclSchemaModification, updateAclSchemaModification } from './acl'
 import { createColumnModification, updateColumnDefinitionModification, updateColumnNameModification } from './columns'
 import { createUniqueConstraintModification, removeUniqueConstraintModification } from './constraints'
 import {
-	createEntityModification, createViewModification,
-	removeEntityModification, toggleEventLogModification,
+	createEntityModification,
+	createViewModification,
+	removeEntityModification,
+	toggleEventLogModification,
 	updateEntityNameModification,
 	updateEntityTableNameModification,
 } from './entities'
 import { updateViewModification } from './entities/UpdateViewModification'
-import {
-	createEnumModification,
-	removeEnumModification,
-	updateEnumModification,
-} from './enums'
+import { createEnumModification, removeEnumModification, updateEnumModification } from './enums'
 import { removeFieldModification, updateFieldNameModification } from './fields'
 import {
 	convertOneHasManyToManyHasManyRelationModification,
 	convertOneToManyRelationModification,
 	createRelationInverseSideModification,
-	createRelationModification, disableOrphanRemovalModification,
+	createRelationModification,
+	disableOrphanRemovalModification,
 	enableOrphanRemovalModification,
 	makeRelationNotNullModification,
-	makeRelationNullableModification, toggleJunctionEventLogModification,
+	makeRelationNullableModification,
+	toggleJunctionEventLogModification,
 	updateRelationOnDeleteModification,
 	updateRelationOrderByModification,
 } from './relations'
 import { patchValidationSchemaModification, updateValidationSchemaModification } from './validation'
 import { createIndexModification, removeIndexModification } from './indexes'
-import { SchemaWithMeta } from './utils/schemaMeta'
 import { updateSettingsModification } from './settings'
 import { createTriggerModification, removeTriggerModification, updateTriggerModification } from './actions'
 import { createTargetModification } from './actions/CreateTargetModification'
 import { removeTargetModification } from './actions/RemoveTargetModification'
 import { updateTargetModification } from './actions/UpdateTargetModification'
 import { updateEntityOrderByModification } from './entities/UpdateEntityOrderByModification'
+import { removeIndexNamesModification } from './upgrade/RemoveIndexNamesModification'
 
 
 class ModificationHandlerFactory {
 	constructor(private readonly map: Record<string, ModificationType<string, any>>) {}
 
-	public create<D>(name: string, data: D, schema: SchemaWithMeta, options: ModificationHandlerOptions): ModificationHandler<D> {
+	public create<D>(name: string, data: D, schema: Schema, options: ModificationHandlerOptions): ModificationHandler<D> {
 		if (!this.map[name]) {
 			throw new Error(`Undefined modification handler for ${name}`)
 		}
@@ -53,6 +53,7 @@ namespace ModificationHandlerFactory {
 	type HandlerMap<D> = { [modificationName: string]: ModificationType<string, D> }
 
 	const handlers = [
+		removeIndexNamesModification,
 		updateSettingsModification,
 		updateAclSchemaModification,
 		patchAclSchemaModification,

package/src/modifications/ModificationVersions.ts

@@ -1,8 +1,9 @@
 export const VERSION_INITIAL = 1
-export const VERSION_LATEST = 4
+export const VERSION_LATEST = 5
 
 export const VERSION_ACL_PATCH = 2
-export const VERSION_UPDATE_CONSTRAINT_NAME = 2
+export const VERSION_UPDATE_CONSTRAINT_FIELDS = 2
 export const VERSION_REMOVE_RELATION_INVERSE_SIDE = 3
 export const VERSION_REMOVE_REFERENCING_RELATIONS = 3
-export const VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE = 4
+export const _REMOVED_VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE = 4
+export const VERSION_UPDATE_INDEX_FIELDS = 5

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -4,9 +4,8 @@ import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { updateColumns } from '../utils/diffUtils'
-import { wrapIdentifier } from '@contember/database'
+import { wrapIdentifier } from '../../utils/dbHelpers'
 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) {}

package/src/modifications/constraints/CreateUniqueConstraintModification.ts

@@ -1,57 +1,48 @@
 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 { getUniqueConstraintColumns } from './utils'
+import deepEqual from 'fast-deep-equal'
 
 export class CreateUniqueConstraintModificationHandler implements ModificationHandler<CreateUniqueConstraintModificationData> {
 	constructor(private readonly data: CreateUniqueConstraintModificationData, 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.unique.fields
-		const columns = fields.map(fieldName => {
-			return acceptFieldVisitor(this.schema.model, entity, fieldName, {
-				visitColumn: ({ column }) => {
-					return column.columnName
-				},
-				visitManyHasOne: ({ relation }) => {
-					return relation.joiningColumn.columnName
-				},
-				visitOneHasMany: () => {
-					throw new Error(`Cannot create unique key on 1:m relation in ${entity.name}.${fieldName}`)
-				},
-				visitOneHasOneOwning: () => {
-					throw new Error(
-						`Cannot create unique key on 1:1 relation, this relation has unique key by default in ${entity.name}.${fieldName}`,
-					)
-				},
-				visitOneHasOneInverse: () => {
-					throw new Error(`Cannot create unique key on 1:1 inverse relation in ${entity.name}.${fieldName}`)
-				},
-				visitManyHasManyOwning: () => {
-					throw new Error(`Cannot create unique key on m:m relation in ${entity.name}.${fieldName}`)
-				},
-				visitManyHasManyInverse: () => {
-					throw new Error(`Cannot create unique key on m:m inverse relation in ${entity.name}.${fieldName}`)
-				},
-			})
+		const columns = getUniqueConstraintColumns({
+			entity,
+			model: this.schema.model,
+			fields,
 		})
-		builder.addConstraint(entity.tableName, this.data.unique.name, { unique: columns })
+
+		const tableNameId = wrapIdentifier(entity.tableName)
+		const columnNameIds = columns.map(wrapIdentifier)
+
+		builder.sql(`ALTER TABLE ${tableNameId} ADD UNIQUE (${columnNameIds.join(', ')})`)
+
+		invalidateDatabaseMetadata()
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
 		return updateModel(
 			updateEntity(this.data.entityName, ({ entity }) => ({
 				...entity,
-				unique: {
+				unique: [
 					...entity.unique,
-					[this.data.unique.name]: this.data.unique,
-				},
+					this.data.unique,
+				],
 			})),
 		)
 	}
@@ -67,21 +58,21 @@ export class CreateUniqueConstraintModificationHandler implements ModificationHa
 
 }
 
-export interface CreateUniqueConstraintModificationData {
-	entityName: string
-	unique: Model.UniqueConstraint
-}
-
 export const createUniqueConstraintModification = createModificationType({
 	id: 'createUniqueConstraint',
 	handler: CreateUniqueConstraintModificationHandler,
 })
 
+export interface CreateUniqueConstraintModificationData {
+	entityName: string
+	unique: Model.UniqueConstraint
+}
+
 export class CreateUniqueConstraintDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(updatedSchema.model.entities).flatMap(entity =>
-			Object.values(entity.unique)
-				.filter(it => !originalSchema.model.entities[entity.name].unique[it.name])
+			entity.unique
+				.filter(it => !originalSchema.model.entities[entity.name].unique.find(uniq => deepEqual(uniq.fields, it.fields)))
 				.map(unique => createUniqueConstraintModification.createModification({
 					entityName: entity.name,
 					unique,

package/src/modifications/constraints/RemoveUniqueConstraintModification.ts

@@ -1,25 +1,48 @@
 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 { getUniqueConstraintColumns } from './utils'
+import { wrapIdentifier } from '../../utils/dbHelpers'
 
 export class RemoveUniqueConstraintModificationHandler implements ModificationHandler<RemoveUniqueConstraintModificationData> {
 	constructor(private readonly data: RemoveUniqueConstraintModificationData, 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.dropConstraint(entity.tableName, this.data.constraintName)
+
+		const fields = this.getFields()
+
+		const columns = getUniqueConstraintColumns({
+			entity,
+			fields: fields,
+			model: this.schema.model,
+		})
+
+		const constraintNames = databaseMetadata.getUniqueConstraintNames({ tableName: entity.tableName, columnNames: columns })
+
+		for (const name of constraintNames) {
+			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
+		}
+
+		invalidateDatabaseMetadata()
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
+		const fields = this.getFields()
 		return updateModel(
 			updateEntity(this.data.entityName, ({ entity }) => {
-				const { [this.data.constraintName]: removed, ...unique } = entity.unique
+				const unique = entity.unique.filter(it => !deepEqual(it.fields, fields))
 				return {
 					...entity,
 					unique,
@@ -29,14 +52,21 @@ export class RemoveUniqueConstraintModificationHandler implements ModificationHa
 	}
 
 	describe() {
-		const fields = this.schema.model.entities[this.data.entityName].unique[this.data.constraintName].fields
+		const fields = this.getFields()
 		return { message: `Remove unique constraint (${fields.join(', ')}) on entity ${this.data.entityName}` }
 	}
-}
 
-export interface RemoveUniqueConstraintModificationData {
-	entityName: string
-	constraintName: string
+	getFields() {
+		const entity = this.schema.model.entities[this.data.entityName]
+		const fields = 'constraintName' in this.data
+			? entity.unique.find(it => it.name === this.data.constraintName)?.fields
+			: this.data.fields
+
+		if (!fields) {
+			throw new Error()
+		}
+		return fields
+	}
 }
 
 export const removeUniqueConstraintModification = createModificationType({
@@ -44,21 +74,36 @@ export const removeUniqueConstraintModification = createModificationType({
 	handler: RemoveUniqueConstraintModificationHandler,
 })
 
+export type RemoveUniqueConstraintModificationData =
+	| {
+		entityName: string
+		constraintName: string
+		fields?: never
+	}
+	| {
+		entityName: string
+		fields: readonly string[]
+		constraintName?: never
+	}
+
 
 export class RemoveUniqueConstraintDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(originalSchema.model.entities).flatMap(entity =>
-			Object.values(entity.unique)
+			entity.unique
 				.filter(
-					it =>
-						updatedSchema.model.entities[entity.name] &&
-						(!updatedSchema.model.entities[entity.name].unique[it.name] ||
-							!deepEqual(it.fields, updatedSchema.model.entities[entity.name].unique[it.name].fields)),
+					it => {
+						const updatedEntity = updatedSchema.model.entities[entity.name]
+						if (!updatedEntity) {
+							return false
+						}
+						return !updatedEntity.unique.find(uniq => deepEqual(uniq.fields, it.fields))
+					},
 				)
 				.map(unique =>
 					removeUniqueConstraintModification.createModification({
 						entityName: entity.name,
-						constraintName: unique.name,
+						fields: unique.fields,
 					}),
 				),
 		)

package/src/modifications/constraints/utils.ts

@@ -0,0 +1,36 @@
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+
+export const getUniqueConstraintColumns = ({ 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
+			},
+			visitOneHasMany: () => {
+				throw new Error(`Cannot create unique key on 1:m relation in ${entity.name}.${fieldName}`)
+			},
+			visitOneHasOneOwning: () => {
+				throw new Error(
+					`Cannot create unique key on 1:1 relation, this relation has unique key by default in ${entity.name}.${fieldName}`,
+				)
+			},
+			visitOneHasOneInverse: () => {
+				throw new Error(`Cannot create unique key on 1:1 inverse relation in ${entity.name}.${fieldName}`)
+			},
+			visitManyHasManyOwning: () => {
+				throw new Error(`Cannot create unique key on m:m relation in ${entity.name}.${fieldName}`)
+			},
+			visitManyHasManyInverse: () => {
+				throw new Error(`Cannot create unique key on m:m inverse relation in ${entity.name}.${fieldName}`)
+			},
+		})
+	})
+}

package/src/modifications/entities/CreateEntityModification.ts

@@ -4,11 +4,11 @@ import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
-	ModificationHandler,
+	ModificationHandler, ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
 import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
-import { PartialEntity } from '../../utils/PartialEntity.js'
+import { PossibleEntityShapeInMigrations } from '../../utils/PartialEntity.js'
 import { getColumnSqlType } from '../utils/columnUtils'
 
 export class CreateEntityModificationHandler implements ModificationHandler<CreateEntityModificationData> {
@@ -18,7 +18,7 @@ export class CreateEntityModificationHandler implements ModificationHandler<Crea
 		private readonly options: ModificationHandlerOptions,
 	) {}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, { systemSchema }: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.data.entity
 		if (entity.view) {
 			// BC
@@ -37,8 +37,8 @@ export class CreateEntityModificationHandler implements ModificationHandler<Crea
 		})
 
 		if  (entity.eventLog?.enabled !== false) {
-			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)
 		}
 	}
 
@@ -49,8 +49,9 @@ export class CreateEntityModificationHandler implements ModificationHandler<Crea
 				...model.entities,
 				[this.data.entity.name]: {
 					eventLog: { enabled: true },
-					indexes: {},
 					...this.data.entity,
+					unique: Object.values(this.data.entity.unique),
+					indexes: Object.values(this.data.entity.indexes ?? []),
 				},
 			},
 		}))
@@ -80,7 +81,7 @@ export class CreateEntityDiffer implements Differ {
 						fields: {
 							[entity.primary]: entity.fields[entity.primary],
 						},
-						unique: {},
+						unique: [],
 					},
 				}),
 			)
@@ -88,5 +89,5 @@ export class CreateEntityDiffer implements Differ {
 }
 
 export interface CreateEntityModificationData {
-	entity: PartialEntity
+	entity: PossibleEntityShapeInMigrations
 }

package/src/modifications/entities/CreateViewModification.ts

@@ -3,7 +3,7 @@ import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { Migration } from '../../Migration'
-import { PartialEntity } from '../../utils/PartialEntity.js'
+import { PossibleEntityShapeInMigrations } from '../../utils/PartialEntity.js'
 
 export class CreateViewModificationHandler implements ModificationHandler<CreateViewModificationData> {
 	constructor(private readonly data: CreateViewModificationData, private readonly schema: Schema) {}
@@ -22,9 +22,10 @@ export class CreateViewModificationHandler implements ModificationHandler<Create
 			entities: {
 				...model.entities,
 				[this.data.entity.name]: {
-					indexes: {},
 					eventLog: { enabled: true }, // not relevant here...
 					...this.data.entity,
+					unique: Object.values(this.data.entity.unique),
+					indexes: Object.values(this.data.entity.indexes ?? []),
 				},
 			},
 		}))
@@ -68,5 +69,5 @@ export class CreateViewDiffer implements Differ {
 }
 
 export interface CreateViewModificationData {
-	entity: PartialEntity
+	entity: PossibleEntityShapeInMigrations
 }

package/src/modifications/entities/RemoveEntityModification.ts

@@ -14,22 +14,21 @@ import {
 import {
 	createModificationType,
 	Differ,
-	ModificationHandler,
+	ModificationHandler, ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
 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: SchemaWithMeta,
+		private readonly schema: Schema,
 		private readonly options: ModificationHandlerOptions,
 	) {}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, options: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.schema.model.entities[this.data.entityName]
 		if (entity.view) {
 			builder.dropView(entity.tableName)
@@ -37,7 +36,8 @@ export class RemoveEntityModificationHandler implements ModificationHandler<Remo
 		}
 		if (this.options.formatVersion >= VERSION_REMOVE_REFERENCING_RELATIONS) {
 			this.getFieldsToRemove(this.schema).forEach(([entityName, fieldName]) => {
-				removeFieldModification.createHandler({ entityName, fieldName }, this.schema, this.options).createSql(builder)
+				const removeFieldHandler = removeFieldModification.createHandler({ entityName, fieldName }, this.schema, this.options)
+				removeFieldHandler.createSql(builder, options)
 			})
 		}
 		builder.dropTable(entity.tableName)