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

package/src/MigrationFilesManager.ts

@@ -1,38 +1,28 @@
 import { MigrationVersionHelper } from './MigrationVersionHelper'
-import * as fs from 'fs'
-import { promisify } from 'util'
-import * as path from 'path'
-
-const readFile = promisify(fs.readFile)
-const fsWrite = promisify(fs.writeFile)
-const fsRemove = promisify(fs.unlink)
-const fsRealpath = promisify(fs.realpath)
-const mkdir = promisify(fs.mkdir)
-const lstatFile = promisify(fs.lstat)
-const readDir = promisify(fs.readdir)
-const mvFile = promisify(fs.rename)
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
 
 class MigrationFilesManager {
 	constructor(public readonly directory: string) {}
 
 	public async createFile(content: string, name: string): Promise<string> {
 		const path = this.formatPath(name)
-		await fsWrite(path, content, { encoding: 'utf8' })
-		return await fsRealpath(path)
+		await fs.writeFile(path, content, { encoding: 'utf8' })
+		return await fs.realpath(path)
 	}
 
 	public async removeFile(name: string) {
 		const path = this.formatPath(name)
-		await fsRemove(path)
+		await fs.unlink(path)
 	}
 
 	public async moveFile(oldName: string, newName: string) {
-		await mvFile(this.formatPath(oldName), this.formatPath(newName))
+		await fs.rename(this.formatPath(oldName), this.formatPath(newName))
 	}
 
 	public async createDirIfNotExist(): Promise<void> {
 		try {
-			await mkdir(this.directory)
+			await fs.mkdir(this.directory)
 		} catch (e) {
 			if (!(e instanceof Error) || !('code' in e) || (e as any).code !== 'EEXIST') {
 				throw e
@@ -47,7 +37,7 @@ class MigrationFilesManager {
 			files
 				.filter(file => file.endsWith(`.json`))
 				.filter(async file => {
-					return (await lstatFile(`${this.directory}/${file}`)).isFile()
+					return (await fs.lstat(`${this.directory}/${file}`)).isFile()
 				}),
 		)
 		return filteredFiles.sort()
@@ -55,7 +45,7 @@ class MigrationFilesManager {
 
 	private async tryReadDir(): Promise<string[]> {
 		try {
-			return await readDir(this.directory)
+			return await fs.readdir(this.directory)
 		} catch (e) {
 			if (e instanceof Error && 'code' in e && (e as any).code === 'ENOENT') {
 				return []
@@ -72,7 +62,7 @@ class MigrationFilesManager {
 		const filesWithContent = files.map(async filename => ({
 			filename: filename,
 			path: `${this.directory}/${filename}`,
-			content: await readFile(`${this.directory}/${filename}`, { encoding: 'utf8' }),
+			content: await fs.readFile(`${this.directory}/${filename}`, { encoding: 'utf8' }),
 		}))
 
 		return await Promise.all(filesWithContent)

package/src/MigrationsResolver.ts

@@ -18,6 +18,7 @@ export class MigrationsResolver {
 				name: MigrationVersionHelper.extractName(filename),
 				formatVersion: parsed.formatVersion || VERSION_INITIAL,
 				modifications: parsed.modifications,
+				...(parsed.skippedErrors ? { skippedErrors: parsed.skippedErrors } : {}),
 			}
 		})
 	}

package/src/SchemaDiffer.ts

@@ -43,14 +43,23 @@ import {
 } from './modifications'
 import { ChangeViewNonViewDiffer, RemoveChangedFieldDiffer, RemoveChangedViewDiffer } from './modifications/differs'
 import { CreateIndexDiffer, RemoveIndexDiffer } from './modifications/indexes'
+import { SchemaWithMeta } from './modifications/utils/schemaMeta'
+import { UpdateSettingsDiffer } from './modifications/settings'
+
+type DiffOptions = { skipRecreateValidation?: boolean; skipInitialSchemaValidation?: boolean }
 
 export class SchemaDiffer {
 	constructor(private readonly schemaMigrator: SchemaMigrator) {}
 
-	diffSchemas(originalSchema: Schema, updatedSchema: Schema, checkRecreate: boolean = true): Migration.Modification[] {
-		const originalErrors = SchemaValidator.validate(originalSchema)
-		if (originalErrors.length > 0) {
-			throw new InvalidSchemaException('original schema is not valid', originalErrors)
+	diffSchemas(originalSchema: Schema, updatedSchema: Schema, {
+		skipInitialSchemaValidation = false,
+		skipRecreateValidation = false,
+	}: DiffOptions = {}): Migration.Modification[] {
+		if (!skipInitialSchemaValidation) {
+			const originalErrors = SchemaValidator.validate(originalSchema)
+			if (originalErrors.length > 0) {
+				throw new InvalidSchemaException('original schema is not valid', originalErrors)
+			}
 		}
 		const updatedErrors = SchemaValidator.validate(updatedSchema)
 		if (updatedErrors.length > 0) {
@@ -58,6 +67,7 @@ export class SchemaDiffer {
 		}
 
 		const differs: Differ[] = [
+			new UpdateSettingsDiffer(),
 			new ConvertOneToManyRelationDiffer(),
 			new ConvertOneHasManyToManyHasManyRelationDiffer(),
 			new RemoveUniqueConstraintDiffer(),
@@ -83,8 +93,8 @@ export class SchemaDiffer {
 			new RemoveChangedFieldDiffer(it => isRelation(it) && isInverseRelation(it)),
 			new CreateEntityDiffer(),
 			new CreateColumnDiffer(),
-			new CreateViewDiffer(),
 			new CreateRelationDiffer(),
+			new CreateViewDiffer(),
 			new CreateRelationInverseSideDiffer(),
 			new CreateUniqueConstraintDiffer(),
 			new CreateIndexDiffer(),
@@ -102,8 +112,9 @@ export class SchemaDiffer {
 		}
 
 
-		if (checkRecreate) {
-			const errors = deepCompare(updatedSchema, appliedDiffsSchema, [])
+		if (!skipRecreateValidation) {
+			const { meta, ...appliedDiffsSchema2 } = appliedDiffsSchema as SchemaWithMeta
+			const errors = deepCompare(updatedSchema, appliedDiffsSchema2, [])
 			if (errors.length === 0) {
 				return diffs
 			}

package/src/SchemaMigrator.ts

@@ -1,11 +1,12 @@
 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): Schema {
+	public applyModifications(schema: Schema, diff: readonly Migration.Modification[], formatVersion: number): SchemaWithMeta {
 		for (const modification of diff) {
 			const { modification: name, ...data } = modification
 			const modificationHandler = this.modificationHandlerFactory.create(name, data, schema, {

package/src/modifications/ModificationHandler.ts

@@ -2,6 +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'
 
 export interface ModificationDescription {
 	message: string
@@ -26,18 +27,18 @@ export interface ModificationHandlerOptions {
 }
 
 export interface ModificationHandlerConstructor<Data> {
-	new(data: Data, schema: Schema, options: ModificationHandlerOptions): ModificationHandler<Data>
+	new(data: Data, schema: SchemaWithMeta, options: ModificationHandlerOptions): ModificationHandler<Data>
 }
 
-export interface Differ {
-	createDiff: (originalSchema: Schema, updatedSchema: Schema) => Migration.Modification[]
+export interface Differ<Data = { [field: string]: any }> {
+	createDiff: (originalSchema: Schema, updatedSchema: Schema) => Migration.Modification<Data>[]
 }
 
 
 export interface ModificationType<Id extends String, Data> {
 	id: Id
 	createModification: (data: Data) => Migration.Modification<Data>
-	createHandler: (data: Data, schema: Schema, options: ModificationHandlerOptions) => ModificationHandler<Data>
+	createHandler: (data: Data, schema: SchemaWithMeta, options: ModificationHandlerOptions) => ModificationHandler<Data>
 }
 
 export const createModificationType = <Data, Id extends string>({ handler, id }: {

package/src/modifications/ModificationHandlerFactory.ts

@@ -29,12 +29,14 @@ import {
 } from './relations'
 import { patchValidationSchemaModification, updateValidationSchemaModification } from './validation'
 import { createIndexModification, removeIndexModification } from './indexes'
+import { SchemaWithMeta } from './utils/schemaMeta'
+import { updateSettingsModification } from './settings'
 
 
 class ModificationHandlerFactory {
 	constructor(private readonly map: Record<string, ModificationType<string, any>>) {}
 
-	public create<D>(name: string, data: D, schema: Schema, options: ModificationHandlerOptions): ModificationHandler<D> {
+	public create<D>(name: string, data: D, schema: SchemaWithMeta, options: ModificationHandlerOptions): ModificationHandler<D> {
 		if (!this.map[name]) {
 			throw new Error(`Undefined modification handler for ${name}`)
 		}
@@ -46,6 +48,7 @@ namespace ModificationHandlerFactory {
 	type HandlerMap<D> = { [modificationName: string]: ModificationType<string, D> }
 
 	const handlers = [
+		updateSettingsModification,
 		updateAclSchemaModification,
 		patchAclSchemaModification,
 		createColumnModification,

package/src/modifications/columns/CreateColumnModification.ts

@@ -6,6 +6,7 @@ import { wrapIdentifier } from '../../utils/dbHelpers'
 import { getColumnName, isColumn } from '@contember/schema-utils'
 import { ImplementationException } from '../../exceptions'
 import { createFields } from '../utils/diffUtils'
+import { getColumnSqlType } from '../utils/columnUtils'
 
 export class CreateColumnModificationHandler implements ModificationHandler<CreateColumnModificationData> {
 	constructor(private readonly data: CreateColumnModificationData, private readonly schema: Schema) {}
@@ -19,7 +20,7 @@ export class CreateColumnModificationHandler implements ModificationHandler<Crea
 		const hasSeed = this.data.fillValue !== undefined || this.data.copyValue !== undefined
 		builder.addColumn(entity.tableName, {
 			[column.columnName]: {
-				type: column.type === Model.ColumnType.Enum ? `"${column.columnType}"` : column.columnType,
+				type: getColumnSqlType(column),
 				notNull: !column.nullable && !hasSeed,
 				sequenceGenerated: column.sequence,
 			},
@@ -31,7 +32,7 @@ export class CreateColumnModificationHandler implements ModificationHandler<Crea
 			} 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)}`)
+	  SET ${wrapIdentifier(column.columnName)} = ${wrapIdentifier(copyFrom)}::${getColumnSqlType(column)}`)
 			} else {
 				throw new ImplementationException()
 			}

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -1,10 +1,12 @@
-import { MigrationBuilder } from '@contember/database-migrations'
+import { escapeValue, MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { updateColumns } from '../utils/diffUtils'
 import { wrapIdentifier } from '@contember/database'
+import { getColumnSqlType } from '../utils/columnUtils'
+import { getEntityDependantViews } from '../utils/viewDependencies'
 
 export class UpdateColumnDefinitionModificationHandler implements ModificationHandler<UpdateColumnDefinitionModificationData>  {
 	constructor(private readonly data: UpdateColumnDefinitionModificationData, private readonly schema: Schema) {}
@@ -14,34 +16,40 @@ export class UpdateColumnDefinitionModificationHandler implements ModificationHa
 		if (entity.view) {
 			return
 		}
-		const field = entity.fields[this.data.fieldName] as Model.AnyColumn
-		const definition = this.data.definition
-		const newType = definition.columnType !== field.columnType
-			? definition.type === Model.ColumnType.Enum
-				? `"${definition.columnType}"`
-				: definition.columnType
-			: undefined
-		builder.alterColumn(entity.tableName, field.columnName, {
-			type: newType,
-			notNull: field.nullable !== definition.nullable ? !definition.nullable : undefined,
-			using: newType !== undefined ? `${wrapIdentifier(field.columnName)}::${newType}` : undefined,
-			sequenceGenerated: field.sequence && !definition.sequence ? false : (!field.sequence ? definition.sequence : undefined),
+		const oldColumn = entity.fields[this.data.fieldName] as Model.AnyColumn
+		const newColumn = this.data.definition
+
+		const hasNewSequence = !oldColumn.sequence && newColumn.sequence
+		const hasNewType = newColumn.columnType !== oldColumn.columnType
+		const columnType = getColumnSqlType(newColumn)
+
+		const usingCast = `${wrapIdentifier(oldColumn.columnName)}::${columnType}`
+
+		builder.alterColumn(entity.tableName, oldColumn.columnName, {
+			type: hasNewSequence || hasNewType ? columnType : undefined,
+			notNull: oldColumn.nullable !== newColumn.nullable ? !newColumn.nullable : undefined,
+			using: hasNewSequence
+				? `COALESCE(${usingCast}, nextval(PG_GET_SERIAL_SEQUENCE(${escapeValue(entity.tableName)}, ${escapeValue(oldColumn.columnName)})))`
+				: hasNewType
+					? usingCast
+					: undefined,
+			sequenceGenerated: oldColumn.sequence && !newColumn.sequence ? false : (!oldColumn.sequence ? newColumn.sequence : undefined),
 		})
 
 		const seqAlter = []
-		if (field.sequence && definition.sequence) {
-			if (field.sequence.precedence !== definition.sequence.precedence) {
-				seqAlter.push(`SET GENERATED ${definition.sequence.precedence}`)
+		if (oldColumn.sequence && newColumn.sequence) {
+			if (oldColumn.sequence.precedence !== newColumn.sequence.precedence) {
+				seqAlter.push(`SET GENERATED ${newColumn.sequence.precedence}`)
 			}
-			if (field.sequence.start !== definition.sequence.start && typeof definition.sequence.start == 'number') {
-				seqAlter.push(`SET START WITH ${definition.sequence.start}`)
+			if (oldColumn.sequence.start !== newColumn.sequence.start && typeof newColumn.sequence.start == 'number') {
+				seqAlter.push(`SET START WITH ${newColumn.sequence.start}`)
 			}
-			if (definition.sequence.restart) {
+			if (newColumn.sequence.restart) {
 				seqAlter.push('RESTART')
 			}
 		}
 		if (seqAlter.length > 0) {
-			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} ALTER ${wrapIdentifier(field.columnName)} ${seqAlter.join(' ')}`)
+			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} ALTER ${wrapIdentifier(oldColumn.columnName)} ${seqAlter.join(' ')}`)
 		}
 	}
 
@@ -79,7 +87,7 @@ type SequenceDefinitionAlter =
 	}
 
 type ColumnDefinitionAlter =
-	& Model.AnyColumn
+	& Omit<Model.AnyColumn, 'sequence' | 'columnName' | 'name'>
 	& {
 		sequence?: SequenceDefinitionAlter
 	}
@@ -95,22 +103,23 @@ export const updateColumnDefinitionModification = createModificationType({
 	handler: UpdateColumnDefinitionModificationHandler,
 })
 
-export class UpdateColumnDefinitionDiffer implements Differ {
+export class UpdateColumnDefinitionDiffer implements Differ<UpdateColumnDefinitionModificationData> {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateColumns(originalSchema, updatedSchema, ({ originalColumn, updatedColumn, updatedEntity }) => {
 			const {
 				name: {},
 				columnName: {},
 				...updatedDefinition
-			} = updatedColumn as any
+			} = updatedColumn
 			const {
 				name: {},
 				columnName: {},
 				...originalDefinition
-			} = originalColumn as any
+			} = originalColumn
 			if (deepEqual(updatedDefinition, originalDefinition)) {
 				return undefined
 			}
+
 			return updateColumnDefinitionModification.createModification({
 				entityName: updatedEntity.name,
 				fieldName: updatedColumn.name,

package/src/modifications/columns/UpdateColumnNameModification.ts

@@ -15,13 +15,13 @@ export class UpdateColumnNameModificationHandler implements ModificationHandler<
 			return
 		}
 		acceptFieldVisitor(this.schema.model, entity, this.data.fieldName, {
-			visitColumn: (entity, column) => {
+			visitColumn: ({ entity, column }) => {
 				builder.renameColumn(entity.tableName, column.columnName, this.data.columnName)
 			},
-			visitManyHasOne: (entity, relation) => {
+			visitManyHasOne: ({ entity, relation }) => {
 				builder.renameColumn(entity.tableName, relation.joiningColumn.columnName, this.data.columnName)
 			},
-			visitOneHasOneOwning: (entity, relation) => {
+			visitOneHasOneOwning: ({ entity, relation }) => {
 				builder.renameColumn(entity.tableName, relation.joiningColumn.columnName, this.data.columnName)
 			},
 			visitManyHasManyInverse: () => {
@@ -43,47 +43,47 @@ export class UpdateColumnNameModificationHandler implements ModificationHandler<
 		return updateModel(
 			updateEntity(
 				this.data.entityName,
-				updateField(this.data.fieldName, ({
-													  field,
-													  entity,
-												  }) => acceptFieldVisitor<Model.AnyField>(this.schema.model, entity, field, {
-					visitColumn: (entity, column) => {
-						return {
-							...column,
-							columnName: this.data.columnName,
-						}
-					},
-					visitManyHasOne: (entity, relation) => {
-						return {
-							...relation,
-							joiningColumn: {
-								...relation.joiningColumn,
-								columnName: this.data.columnName,
-							},
-						}
-					},
-					visitOneHasOneOwning: (entity, relation) => {
-						return {
-							...relation,
-							joiningColumn: {
-								...relation.joiningColumn,
+				updateField(this.data.fieldName, ({ field, entity }) =>
+					acceptFieldVisitor<Model.AnyField>(this.schema.model, entity, field, {
+						visitColumn: ({ column }) => {
+							return {
+								...column,
 								columnName: this.data.columnName,
-							},
-						}
-					},
-					visitManyHasManyInverse: () => {
-						throw new Error('Cannot rename column of many-to-many relation')
-					},
-					visitManyHasManyOwning: () => {
-						throw new Error('Cannot rename column of many-to-many relation')
-					},
-					visitOneHasMany: () => {
-						throw new Error('Cannot rename column of one-to-many relation')
-					},
-					visitOneHasOneInverse: () => {
-						throw new Error('Cannot rename column of one-to-one inverse relation')
+							}
+						},
+						visitManyHasOne: ({ entity, relation }) => {
+							return {
+								...relation,
+								joiningColumn: {
+									...relation.joiningColumn,
+									columnName: this.data.columnName,
+								},
+							}
+						},
+						visitOneHasOneOwning: ({ entity, relation }) => {
+							return {
+								...relation,
+								joiningColumn: {
+									...relation.joiningColumn,
+									columnName: this.data.columnName,
+								},
+							}
+						},
+						visitManyHasManyInverse: () => {
+							throw new Error('Cannot rename column of many-to-many relation')
+						},
+						visitManyHasManyOwning: () => {
+							throw new Error('Cannot rename column of many-to-many relation')
+						},
+						visitOneHasMany: () => {
+							throw new Error('Cannot rename column of one-to-many relation')
+						},
+						visitOneHasOneInverse: () => {
+							throw new Error('Cannot rename column of one-to-one inverse relation')
+						},
 					},
-				})),
+					),
+				),
 			),
 		)
 	}

package/src/modifications/constraints/CreateUniqueConstraintModification.ts

@@ -16,10 +16,10 @@ export class CreateUniqueConstraintModificationHandler implements ModificationHa
 		const fields = this.data.unique.fields
 		const columns = fields.map(fieldName => {
 			return acceptFieldVisitor(this.schema.model, entity, fieldName, {
-				visitColumn: ({}, column) => {
+				visitColumn: ({ column }) => {
 					return column.columnName
 				},
-				visitManyHasOne: ({}, relation) => {
+				visitManyHasOne: ({ relation }) => {
 					return relation.joiningColumn.columnName
 				},
 				visitOneHasMany: () => {

package/src/modifications/differs/RemoveChangedViewDiffer.ts

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

package/src/modifications/entities/CreateEntityModification.ts

@@ -9,6 +9,7 @@ import {
 } from '../ModificationHandler'
 import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
 import { PartialEntity } from '../../utils/PartialEntity.js'
+import { getColumnSqlType } from '../utils/columnUtils'
 
 export class CreateEntityModificationHandler implements ModificationHandler<CreateEntityModificationData> {
 	constructor(
@@ -29,7 +30,7 @@ export class CreateEntityModificationHandler implements ModificationHandler<Crea
 		builder.createTable(entity.tableName, {
 			[primaryColumn.name]: {
 				primaryKey: true,
-				type: primaryColumn.type === Model.ColumnType.Enum ? `"${primaryColumn.columnType}"` : primaryColumn.columnType,
+				type: getColumnSqlType(primaryColumn),
 				notNull: true,
 				sequenceGenerated: primaryColumn.sequence,
 			},

package/src/modifications/entities/RemoveEntityModification.ts

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

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -19,13 +19,14 @@ import { NoopModification } from '../NoopModification'
 import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../utils/renameConstraintsHelper'
 import { changeValue } from '../utils/valueUtils'
 import { updateEntityTableNameModification } from './UpdateEntityTableNameModification'
+import { SchemaWithMeta } from '../utils/schemaMeta'
 
 export class UpdateEntityNameModificationHandler implements ModificationHandler<UpdateEntityNameModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: UpdateEntityNameModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		this.subModification = data.tableName

package/src/modifications/fields/RemoveFieldModification.ts

@@ -19,19 +19,19 @@ export class RemoveFieldModificationHandler implements ModificationHandler<Remov
 			return
 		}
 		acceptFieldVisitor(this.schema.model, this.data.entityName, this.data.fieldName, {
-			visitColumn: (entity, column) => {
+			visitColumn: ({ entity, column }) => {
 				builder.dropColumn(entity.tableName, column.columnName)
 			},
-			visitManyHasOne: (entity, relation, {}, _) => {
+			visitManyHasOne: ({ entity, relation }) => {
 				builder.dropColumn(entity.tableName, relation.joiningColumn.columnName)
 			},
 			visitOneHasMany: () => {},
-			visitOneHasOneOwning: (entity, relation, {}, _) => {
+			visitOneHasOneOwning: ({ entity, relation }) => {
 				builder.dropConstraint(entity.tableName, NamingHelper.createUniqueConstraintName(entity.name, [relation.name]))
 				builder.dropColumn(entity.tableName, relation.joiningColumn.columnName)
 			},
 			visitOneHasOneInverse: () => {},
-			visitManyHasManyOwning: ({}, relation, {}, _) => {
+			visitManyHasManyOwning: ({ relation }) => {
 				builder.dropTable(relation.joiningTable.tableName)
 			},
 			visitManyHasManyInverse: () => {},

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -20,13 +20,14 @@ import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../u
 import { changeValue } from '../utils/valueUtils'
 import { updateColumnNameModification } from '../columns'
 import { NoopModification } from '../NoopModification'
+import { SchemaWithMeta } from '../utils/schemaMeta'
 
 export class UpdateFieldNameModificationHandler implements ModificationHandler<UpdateFieldNameModificationData> {
 	private renameColumnSubModification: ModificationHandler<any> = new NoopModification()
 
 	constructor(
 		private readonly data: UpdateFieldNameModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		if (this.data.columnName) {
@@ -79,33 +80,33 @@ export class UpdateFieldNameModificationHandler implements ModificationHandler<U
 				}
 
 				return acceptFieldVisitor<Model.AnyField>(this.schema.model, entity, field, {
-					visitColumn: (entity, field) => field,
-					visitManyHasOne: (entity, relation, targetEntity, targetRelation) => {
+					visitColumn: ({ column }) => column,
+					visitManyHasOne: ({ targetEntity, relation, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, inversedBy: this.data.newFieldName }
 							: relation
 					},
-					visitOneHasMany: (entity, relation, targetEntity, targetRelation) => {
+					visitOneHasMany: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, ownedBy: this.data.newFieldName }
 							: relation
 					},
-					visitOneHasOneOwning: (entity, relation, targetEntity, targetRelation) => {
+					visitOneHasOneOwning: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, inversedBy: this.data.newFieldName }
 							: relation
 					},
-					visitOneHasOneInverse: (entity, relation, targetEntity, targetRelation) => {
+					visitOneHasOneInverse: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, ownedBy: this.data.newFieldName }
 							: relation
 					},
-					visitManyHasManyOwning: (entity, relation, targetEntity, targetRelation) => {
+					visitManyHasManyOwning: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, inversedBy: this.data.newFieldName }
 							: relation
 					},
-					visitManyHasManyInverse: (entity, relation, targetEntity, targetRelation) => {
+					visitManyHasManyInverse: ({ relation, targetEntity, targetRelation }) => {
 						return isUpdatedRelation(targetEntity, targetRelation)
 							? { ...relation, ownedBy: this.data.newFieldName }
 							: relation