@contember/schema-migrations 1.2.1 → 1.3.0-alpha.13

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/MigrationFilesManager.ts

@@ -1,4 +1,4 @@
-import { MigrationVersionHelper } from './MigrationVersionHelper'
+import { MigrationVersionHelper } from '@contember/engine-common'
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 

package/src/MigrationsResolver.ts

@@ -1,6 +1,6 @@
 import { MigrationFilesManager } from './MigrationFilesManager'
 import { VERSION_INITIAL } from './modifications/ModificationVersions'
-import { MigrationVersionHelper } from './MigrationVersionHelper'
+import { MigrationVersionHelper } from '@contember/engine-common'
 import { Migration } from './Migration'
 
 export class MigrationsResolver {

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,6 +27,7 @@ import {
 	UpdateAclSchemaDiffer,
 	UpdateColumnDefinitionDiffer,
 	UpdateColumnNameDiffer,
+	UpdateEntityOrderByDiffer,
 	UpdateEntityTableNameDiffer,
 	UpdateEnumDiffer,
 	UpdateRelationOnDeleteDiffer,
@@ -43,8 +37,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 }
 
@@ -67,6 +65,7 @@ export class SchemaDiffer {
 		}
 
 		const differs: Differ[] = [
+			new RemoveIndexNamesDiffer(),
 			new UpdateSettingsDiffer(),
 			new ConvertOneToManyRelationDiffer(),
 			new ConvertOneHasManyToManyHasManyRelationDiffer(),
@@ -101,6 +100,13 @@ export class SchemaDiffer {
 			new RemoveEnumDiffer(),
 			new UpdateAclSchemaDiffer(),
 			new UpdateValidationSchemaDiffer(),
+			new UpdateEntityOrderByDiffer(),
+			new UpdateTargetDiffer(),
+			new CreateTargetDiffer(),
+			new UpdateTriggerDiffer(),
+			new CreateTriggerDiffer(),
+			new RemoveTriggerDiffer(),
+			new RemoveTargetDiffer(),
 		]
 
 		const diffs: Migration.Modification[] = []
@@ -111,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/index.ts

@@ -8,4 +8,4 @@ export * from './MigrationCreator'
 export * from './MigrationDescriber'
 export * from './modifications'
 export * from './MigrationFilesManager'
-export * from './MigrationVersionHelper'
+export { MigrationVersionHelper } from '@contember/engine-common'

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,39 +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}`)
 		}
@@ -48,6 +53,7 @@ namespace ModificationHandlerFactory {
 	type HandlerMap<D> = { [modificationName: string]: ModificationType<string, D> }
 
 	const handlers = [
+		removeIndexNamesModification,
 		updateSettingsModification,
 		updateAclSchemaModification,
 		patchAclSchemaModification,
@@ -83,6 +89,13 @@ namespace ModificationHandlerFactory {
 		toggleEventLogModification,
 		toggleJunctionEventLogModification,
 		convertOneHasManyToManyHasManyRelationModification,
+		updateEntityOrderByModification,
+		createTriggerModification,
+		updateTriggerModification,
+		removeTriggerModification,
+		createTargetModification,
+		updateTargetModification,
+		removeTargetModification,
 	]
 
 	export const defaultFactoryMap: HandlerMap<any> = Object.fromEntries(handlers.map(it => [it.id, it]))

package/src/modifications/ModificationVersions.ts

@@ -1,7 +1,9 @@
 export const VERSION_INITIAL = 1
-export const VERSION_LATEST = 3
+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 _REMOVED_VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE = 4
+export const VERSION_UPDATE_INDEX_FIELDS = 5

package/src/modifications/actions/CreateTargetModification.ts

@@ -0,0 +1,46 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Actions, Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class CreateTargetModificationHandler implements ModificationHandler<CreateTargetModificationData> {
+	constructor(private readonly data: CreateTargetModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => ({
+			...schema,
+			actions: {
+				...schema.actions,
+				targets: {
+					...schema.actions.targets,
+					[this.data.target.name]: this.data.target,
+				},
+			},
+		})
+	}
+
+	describe() {
+		return { message: `Create target ${this.data.target.name}` }
+	}
+}
+
+export interface CreateTargetModificationData {
+	target: Actions.AnyTarget
+}
+
+export const createTargetModification = createModificationType({
+	id: 'createTarget',
+	handler: CreateTargetModificationHandler,
+})
+
+export class CreateTargetDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.actions.targets)
+			.filter(([name]) => !originalSchema.actions.targets[name])
+			.map(([, target]) => createTargetModification.createModification({ target }))
+	}
+}

package/src/modifications/actions/CreateTriggerModification.ts

@@ -0,0 +1,46 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Actions, Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class CreateTriggerModificationHandler implements ModificationHandler<CreateTriggerModificationData> {
+	constructor(private readonly data: CreateTriggerModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => ({
+			...schema,
+			actions: {
+				...schema.actions,
+				triggers: {
+					...schema.actions.triggers,
+					[this.data.trigger.name]: this.data.trigger,
+				},
+			},
+		})
+	}
+
+	describe() {
+		return { message: `Create trigger ${this.data.trigger.name}` }
+	}
+}
+
+export interface CreateTriggerModificationData {
+	trigger: Actions.AnyTrigger
+}
+
+export const createTriggerModification = createModificationType({
+	id: 'createTrigger',
+	handler: CreateTriggerModificationHandler,
+})
+
+export class CreateTriggerDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.actions.triggers)
+			.filter(([name]) => !originalSchema.actions.triggers[name])
+			.map(([, trigger]) => createTriggerModification.createModification({ trigger }))
+	}
+}

package/src/modifications/actions/RemoveTargetModification.ts

@@ -0,0 +1,46 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class RemoveTargetModificationHandler implements ModificationHandler<RemoveTargetModificationData> {
+	constructor(private readonly data: RemoveTargetModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			const { [this.data.name]: _, ...targets } = schema.actions.targets
+			return ({
+				...schema,
+				actions: {
+					...schema.actions,
+					targets,
+				},
+			})
+		}
+	}
+
+	describe() {
+		return { message: `Remove target ${this.data.name}` }
+	}
+}
+
+export interface RemoveTargetModificationData {
+	name: string
+}
+
+export const removeTargetModification = createModificationType({
+	id: 'removeTarget',
+	handler: RemoveTargetModificationHandler,
+})
+
+export class RemoveTargetDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(originalSchema.actions.targets)
+			.filter(([name]) => !updatedSchema.actions.targets[name])
+			.map(([name]) => removeTargetModification.createModification({ name }))
+	}
+}

package/src/modifications/actions/RemoveTriggerModification.ts

@@ -0,0 +1,46 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class RemoveTriggerModificationHandler implements ModificationHandler<RemoveTriggerModificationData> {
+	constructor(private readonly data: RemoveTriggerModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			const { [this.data.name]: _, ...triggers } = schema.actions.triggers
+			return ({
+				...schema,
+				actions: {
+					...schema.actions,
+					triggers,
+				},
+			})
+		}
+	}
+
+	describe() {
+		return { message: `Remove trigger ${this.data.name}` }
+	}
+}
+
+export interface RemoveTriggerModificationData {
+	name: string
+}
+
+export const removeTriggerModification = createModificationType({
+	id: 'removeTrigger',
+	handler: RemoveTriggerModificationHandler,
+})
+
+export class RemoveTriggerDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(originalSchema.actions.triggers)
+			.filter(([name]) => !updatedSchema.actions.triggers[name])
+			.map(([name]) => removeTriggerModification.createModification({ name }))
+	}
+}

package/src/modifications/actions/UpdateTargetModification.ts

@@ -0,0 +1,51 @@
+
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Actions, Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import deepEqual from 'fast-deep-equal'
+
+export class UpdateTargetModificationHandler implements ModificationHandler<UpdateTargetModificationData> {
+	constructor(private readonly data: UpdateTargetModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			return ({
+				...schema,
+				actions: {
+					...schema.actions,
+					targets: {
+						...schema.actions.targets,
+						[this.data.name]: this.data.target,
+					},
+				},
+			})
+		}
+	}
+
+	describe() {
+		return { message: `Update target ${this.data.name}` }
+	}
+}
+
+export interface UpdateTargetModificationData {
+	name: string
+	target: Actions.AnyTarget
+}
+
+export const updateTargetModification = createModificationType({
+	id: 'updateTarget',
+	handler: UpdateTargetModificationHandler,
+})
+
+export class UpdateTargetDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.actions.targets)
+			.filter(([name, target]) => originalSchema.actions.targets[name] && !deepEqual(target, originalSchema.actions.targets[name]))
+			.map(([name, target]) => updateTargetModification.createModification({ name, target }))
+	}
+}

package/src/modifications/actions/UpdateTriggerModification.ts

@@ -0,0 +1,49 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Actions, Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import deepEqual from 'fast-deep-equal'
+
+export class UpdateTriggerModificationHandler implements ModificationHandler<UpdateTriggerModificationData> {
+	constructor(private readonly data: UpdateTriggerModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			return ({
+				...schema,
+				actions: {
+					...schema.actions,
+					triggers: {
+						...schema.actions.triggers,
+						[this.data.trigger.name]: this.data.trigger,
+					},
+				},
+			})
+		}
+	}
+
+	describe() {
+		return { message: `Update trigger ${this.data.trigger.name}` }
+	}
+}
+
+export interface UpdateTriggerModificationData {
+	trigger: Actions.AnyTrigger
+}
+
+export const updateTriggerModification = createModificationType({
+	id: 'updateTrigger',
+	handler: UpdateTriggerModificationHandler,
+})
+
+export class UpdateTriggerDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.actions.triggers)
+			.filter(([name, trigger]) => originalSchema.actions.triggers[name] && !deepEqual(trigger, originalSchema.actions.triggers[name]))
+			.map(([, trigger]) => updateTriggerModification.createModification({ trigger }))
+	}
+}

package/src/modifications/actions/index.ts

@@ -0,0 +1,3 @@
+export * from './CreateTriggerModification'
+export * from './RemoveTriggerModification'
+export * from './UpdateTriggerModification'

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) {}