@contember/schema-migrations 1.3.0-alpha.7 → 1.3.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "1.3.0-alpha.7",
+  "version": "1.3.0-beta.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -9,21 +9,20 @@
     "default": "./dist/src/index.js"
   },
   "scripts": {
-    "test": "vitest"
+    "test": "vitest --dir ./tests/cases"
   },
   "dependencies": {
-    "@contember/database": "^1.3.0-alpha.7",
-    "@contember/database-migrations": "^1.3.0-alpha.7",
-    "@contember/engine-common": "^1.3.0-alpha.7",
-    "@contember/schema": "^1.3.0-alpha.7",
-    "@contember/schema-utils": "^1.3.0-alpha.7",
+    "@contember/database-migrations": "1.3.0-beta.1",
+    "@contember/engine-common": "1.3.0-beta.1",
+    "@contember/schema": "1.3.0-beta.1",
+    "@contember/schema-utils": "1.3.0-beta.1",
     "fast-deep-equal": "^3.1.3",
     "rfc6902": "^5.0.1"
   },
   "devDependencies": {
-    "@contember/schema-definition": "^1.3.0-alpha.7"
+    "@contember/schema-definition": "1.3.0-beta.1"
   },
   "peerDependencies": {
     "pg": "^8.9.0"
   }
-}
+}

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

@@ -1,12 +1,5 @@
 import { Schema } from '@contember/schema'
-import {
-	deepCompare,
-	isInverseRelation,
-	isOwningRelation,
-	isRelation,
-	SchemaValidator,
-	ValidationError,
-} from '@contember/schema-utils'
+import { compareArraysIgnoreOrder, deepCompare, isInverseRelation, isOwningRelation, isRelation, SchemaValidator, ValidationError } from '@contember/schema-utils'
 import { SchemaMigrator } from './SchemaMigrator'
 import { Migration } from './Migration'
 import { ImplementationException } from './exceptions'
@@ -34,22 +27,22 @@ import {
 	UpdateAclSchemaDiffer,
 	UpdateColumnDefinitionDiffer,
 	UpdateColumnNameDiffer,
+	UpdateEntityOrderByDiffer,
 	UpdateEntityTableNameDiffer,
 	UpdateEnumDiffer,
 	UpdateRelationOnDeleteDiffer,
 	UpdateRelationOrderByDiffer,
-	UpdateEntityOrderByDiffer,
 	UpdateValidationSchemaDiffer,
 	VERSION_LATEST,
 } 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 +65,7 @@ export class SchemaDiffer {
 		}
 
 		const differs: Differ[] = [
+			new RemoveIndexNamesDiffer(),
 			new UpdateSettingsDiffer(),
 			new ConvertOneToManyRelationDiffer(),
 			new ConvertOneHasManyToManyHasManyRelationDiffer(),
@@ -123,10 +117,15 @@ export class SchemaDiffer {
 			diffs.push(...differDiffs)
 		}
 
-
 		if (!skipRecreateValidation) {
-			const { meta, ...appliedDiffsSchema2 } = appliedDiffsSchema as SchemaWithMeta
-			const errors = deepCompare(updatedSchema, appliedDiffsSchema2, [])
+			const errors = deepCompare(updatedSchema, appliedDiffsSchema, [], path => {
+				if (path[0] === 'model' && path[1] === 'entities' && (path[3] === 'unique' || path[3] === 'index')) {
+					return (a, b) => {
+						return compareArraysIgnoreOrder(a, b, path)
+					}
+				}
+				return null
+			})
 			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/CreateColumnModification.ts

@@ -1,12 +1,11 @@
-import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
-import { Model, Schema } from '@contember/schema'
+import { MigrationBuilder } from '@contember/database-migrations'
+import { JSONValue, Model, Schema } from '@contember/schema'
 import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
-import { wrapIdentifier } from '../../utils/dbHelpers'
-import { getColumnName, isColumn } from '@contember/schema-utils'
-import { ImplementationException } from '../../exceptions'
+import { isColumn } from '@contember/schema-utils'
 import { createFields } from '../utils/diffUtils'
 import { getColumnSqlType } from '../utils/columnUtils'
+import { fillSeed } from './columnUtils'
 
 export class CreateColumnModificationHandler implements ModificationHandler<CreateColumnModificationData> {
 	constructor(private readonly data: CreateColumnModificationData, private readonly schema: Schema) {}
@@ -18,34 +17,27 @@ export class CreateColumnModificationHandler implements ModificationHandler<Crea
 		}
 		const column = this.data.field
 		const hasSeed = this.data.fillValue !== undefined || this.data.copyValue !== undefined
+		const columnType = getColumnSqlType(column)
 		builder.addColumn(entity.tableName, {
 			[column.columnName]: {
-				type: getColumnSqlType(column),
+				type: columnType,
 				notNull: !column.nullable && !hasSeed,
 				sequenceGenerated: column.sequence,
 			},
 		})
-		if (hasSeed) {
-			if (this.data.fillValue !== undefined) {
-				builder.sql(`UPDATE ${wrapIdentifier(entity.tableName)}
-	  SET ${wrapIdentifier(column.columnName)} = ${escapeValue(this.data.fillValue)}`)
-			} else if (this.data.copyValue !== undefined) {
-				const copyFrom = getColumnName(this.schema.model, entity, this.data.copyValue)
-				builder.sql(`UPDATE ${wrapIdentifier(entity.tableName)}
-	  SET ${wrapIdentifier(column.columnName)} = ${wrapIdentifier(copyFrom)}::${getColumnSqlType(column)}`)
-			} else {
-				throw new ImplementationException()
-			}
-
-			// event applier defers constraint check, we need to fire them before ALTER
-			builder.sql(`SET CONSTRAINTS ALL IMMEDIATE`)
-			builder.sql(`SET CONSTRAINTS ALL DEFERRED`)
 
-			if (!column.nullable) {
-				builder.alterColumn(entity.tableName, column.columnName, {
-					notNull: true,
-				})
-			}
+		if (hasSeed) {
+			fillSeed({
+				builder,
+				type: 'creating',
+				model: this.schema.model,
+				entity,
+				columnName: column.columnName,
+				nullable: column.nullable,
+				columnType,
+				copyValue: this.data.copyValue,
+				fillValue: this.data.fillValue,
+			})
 		}
 	}
 
@@ -67,7 +59,7 @@ export class CreateColumnModificationHandler implements ModificationHandler<Crea
 export interface CreateColumnModificationData {
 	entityName: string
 	field: Model.AnyColumn
-	fillValue?: any
+	fillValue?: JSONValue
 	copyValue?: string
 }
 

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -1,12 +1,12 @@
 import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
-import { Model, Schema } from '@contember/schema'
+import { JSONValue, Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 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'
+import { fillSeed } from './columnUtils'
 
 export class UpdateColumnDefinitionModificationHandler implements ModificationHandler<UpdateColumnDefinitionModificationData>  {
 	constructor(private readonly data: UpdateColumnDefinitionModificationData, private readonly schema: Schema) {}
@@ -25,9 +25,11 @@ export class UpdateColumnDefinitionModificationHandler implements ModificationHa
 
 		const usingCast = `${wrapIdentifier(oldColumn.columnName)}::${columnType}`
 
+		const hasSeed = this.data.fillValue !== undefined || this.data.copyValue !== undefined
+
 		builder.alterColumn(entity.tableName, oldColumn.columnName, {
 			type: hasNewSequence || hasNewType ? columnType : undefined,
-			notNull: oldColumn.nullable !== newColumn.nullable ? !newColumn.nullable : undefined,
+			notNull: oldColumn.nullable !== newColumn.nullable && (!hasSeed || newColumn.nullable) ? !newColumn.nullable : undefined,
 			using: hasNewSequence
 				? `COALESCE(${usingCast}, nextval(PG_GET_SERIAL_SEQUENCE(${escapeValue(entity.tableName)}, ${escapeValue(oldColumn.columnName)})))`
 				: hasNewType
@@ -36,6 +38,20 @@ export class UpdateColumnDefinitionModificationHandler implements ModificationHa
 			sequenceGenerated: oldColumn.sequence && !newColumn.sequence ? false : (!oldColumn.sequence ? newColumn.sequence : undefined),
 		})
 
+		if (hasSeed) {
+			fillSeed({
+				builder,
+				type: 'updating',
+				model: this.schema.model,
+				entity,
+				columnName: oldColumn.columnName,
+				nullable: newColumn.nullable,
+				columnType,
+				copyValue: this.data.copyValue,
+				fillValue: this.data.fillValue,
+			})
+		}
+
 		const seqAlter = []
 		if (oldColumn.sequence && newColumn.sequence) {
 			if (oldColumn.sequence.precedence !== newColumn.sequence.precedence) {
@@ -96,6 +112,8 @@ export interface UpdateColumnDefinitionModificationData {
 	entityName: string
 	fieldName: string
 	definition: ColumnDefinitionAlter
+	fillValue?: JSONValue
+	copyValue?: string
 }
 
 export const updateColumnDefinitionModification = createModificationType({

package/src/modifications/columns/columnUtils.ts

@@ -0,0 +1,35 @@
+import { wrapIdentifier } from '../../utils/dbHelpers'
+import { ImplementationException } from '../../exceptions'
+import { JSONValue, Model } from '@contember/schema'
+import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
+import { getColumnName } from '@contember/schema-utils'
+
+export const fillSeed = ({ builder, fillValue, copyValue, entity, columnName, nullable, model, columnType, type }: {
+	model: Model.Schema
+	entity: Model.Entity
+	columnName: string
+	columnType: string
+	nullable: boolean
+	builder: MigrationBuilder
+	fillValue?: JSONValue
+	copyValue?: string
+	type: 'creating' | 'updating'
+}) => {
+	const where = type === 'updating' ? ` WHERE ${wrapIdentifier(columnName)} IS NULL` : ''
+	if (fillValue !== undefined) {
+		builder.sql(`UPDATE ${wrapIdentifier(entity.tableName)}
+                     SET ${wrapIdentifier(columnName)} = ${escapeValue(fillValue)}${where}`)
+	} else if (copyValue !== undefined) {
+		const copyFrom = getColumnName(model, entity, copyValue)
+		builder.sql(`UPDATE ${wrapIdentifier(entity.tableName)}
+                     SET ${wrapIdentifier(columnName)} = ${wrapIdentifier(copyFrom)}::${columnType}${where}`)
+	} else {
+		throw new ImplementationException()
+	}
+
+	if (!nullable) {
+		builder.alterColumn(entity.tableName, columnName, {
+			notNull: true,
+		})
+	}
+}

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,