@contember/schema-migrations 2.1.0-alpha.3 → 2.1.0-alpha.35

package/src/modifications/entities/UpdateEntityOrderByModification.ts

@@ -5,10 +5,9 @@ import { createModificationType, Differ, ModificationHandler } from '../Modifica
 import deepEqual from 'fast-deep-equal'
 
 export class UpdateEntityOrderByModificationHandler implements ModificationHandler<UpdateEntityOrderByModificationData> {
+	constructor(private readonly data: UpdateEntityOrderByModificationData, private readonly schema: Schema) {}
 
-	constructor(private readonly data: UpdateEntityOrderByModificationData, private readonly schema: Schema) { }
-
-	public createSql(builder: MigrationBuilder): void { }
+	public createSql(builder: MigrationBuilder): void {}
 
 	public getSchemaUpdater(): SchemaUpdater {
 		const { entityName, orderBy } = this.data
@@ -63,6 +62,5 @@ export class UpdateEntityOrderByDiffer implements Differ {
 				}
 				return []
 			})
-
 	}
 }

package/src/modifications/entities/UpdateEntityTableNameModification.ts

@@ -43,12 +43,13 @@ export class UpdateEntityTableNameDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(updatedSchema.model.entities)
 			.filter(
-				it =>
-					originalSchema.model.entities[it.name] && originalSchema.model.entities[it.name].tableName !== it.tableName,
+				it => originalSchema.model.entities[it.name] && originalSchema.model.entities[it.name].tableName !== it.tableName,
+			)
+			.map(it =>
+				updateEntityTableNameModification.createModification({
+					entityName: it.name,
+					tableName: it.tableName,
+				})
 			)
-			.map(it => updateEntityTableNameModification.createModification({
-				entityName: it.name,
-				tableName: it.tableName,
-			}))
 	}
 }

package/src/modifications/entities/UpdateViewModification.ts

@@ -29,7 +29,6 @@ export class UpdateViewModificationHandler implements ModificationHandler<Update
 	describe() {
 		return { message: `Update SQL definition of a view` }
 	}
-
 }
 
 export interface UpdateViewModificationData {

package/src/modifications/enums/CreateEnumModification.ts

@@ -43,9 +43,11 @@ export class CreateEnumDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.entries(updatedSchema.model.enums)
 			.filter(([name]) => !originalSchema.model.enums[name])
-			.map(([enumName, values]) => createEnumModification.createModification({
-				enumName,
-				values,
-			}))
+			.map(([enumName, values]) =>
+				createEnumModification.createModification({
+					enumName,
+					values,
+				})
+			)
 	}
 }

package/src/modifications/enums/UpdateEnumModification.ts

@@ -1,20 +1,57 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Schema } from '@contember/schema'
+import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateModel } from '../utils/schemaUpdateUtils'
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { createCheck, getConstraintName } from './enumUtils'
+import { getColumnSqlType } from '../utils/columnUtils'
 
 export class UpdateEnumModificationHandler implements ModificationHandler<UpdateEnumModificationData> {
 	constructor(private readonly data: UpdateEnumModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder): void {
-		builder.sql(`
-			ALTER DOMAIN "${this.data.enumName}"
-			DROP CONSTRAINT ${getConstraintName(this.data.enumName)}`)
-		builder.sql(`
-			ALTER DOMAIN "${this.data.enumName}"
-			ADD CONSTRAINT ${getConstraintName(this.data.enumName)} CHECK (${createCheck(this.data.values)})`)
+		if (!this.requiresNewDomain()) {
+			builder.sql(`
+				ALTER DOMAIN "${this.data.enumName}"
+				DROP CONSTRAINT ${getConstraintName(this.data.enumName)}`)
+			builder.sql(`
+				ALTER DOMAIN "${this.data.enumName}"
+				ADD CONSTRAINT ${getConstraintName(this.data.enumName)} CHECK (${createCheck(this.data.values)})`)
+		} else {
+			/**
+			 * Because postgres does not support altering domain constrains
+			 * when used in composite types (like arrays) we need to:
+			 * - create a new domain with the new constraint
+			 * - update all the columns using the old domain to use the new domain
+			 * - drop the old domain and rename the new domain to the old name
+			 */
+			const oldName = `${this.data.enumName}__old`
+			builder.renameDomain(this.data.enumName, oldName)
+
+			builder.createDomain(this.data.enumName, 'text', {
+				check: createCheck(this.data.values),
+				constraintName: getConstraintName(this.data.enumName),
+			})
+			for (const entity of Object.values(this.schema.model.entities)) {
+				for (const field of Object.values(entity.fields)) {
+					if (field.type === Model.ColumnType.Enum && field.columnType === this.data.enumName) {
+						builder.alterColumn(entity.tableName, field.columnName, {
+							type: getColumnSqlType(field),
+						})
+					}
+				}
+			}
+
+			builder.dropDomain(oldName)
+		}
+	}
+
+	private requiresNewDomain(): boolean {
+		return Object.values(this.schema.model.entities).some(it => {
+			return Object.values(it.fields).some(field => {
+				return field.type === Model.ColumnType.Enum && field.columnType === this.data.enumName && field.list
+			})
+		})
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -30,10 +67,9 @@ export class UpdateEnumModificationHandler implements ModificationHandler<Update
 	describe() {
 		const currentValues = this.schema.model.enums[this.data.enumName]
 		const missingValues = currentValues.filter(it => !this.data.values.includes(it))
-		const failureWarning =
-			missingValues.length > 0
-				? `Removing values (${missingValues.join(', ')}) from enum, this may fail in runtime`
-				: undefined
+		const failureWarning = missingValues.length > 0
+			? `Removing values (${missingValues.join(', ')}) from enum, this may fail in runtime`
+			: undefined
 		return { message: `Update enum ${this.data.enumName}`, failureWarning }
 	}
 }
@@ -53,8 +89,8 @@ export class UpdateEnumDiffer implements Differ {
 		return Object.entries(updatedSchema.model.enums)
 			.filter(
 				([name]) =>
-					originalSchema.model.enums[name] &&
-					!deepEqual(updatedSchema.model.enums[name], originalSchema.model.enums[name]),
+					originalSchema.model.enums[name]
+					&& !deepEqual(updatedSchema.model.enums[name], originalSchema.model.enums[name]),
 			)
 			.map(([enumName, values]) => updateEnumModification.createModification({ enumName, values }))
 	}

package/src/modifications/fields/RemoveFieldModification.ts

@@ -6,7 +6,6 @@ import { createModificationType, Differ, ModificationHandler, ModificationHandle
 import { isDefined } from '../../utils/isDefined'
 
 export class RemoveFieldModificationHandler implements ModificationHandler<RemoveFieldModificationData> {
-
 	constructor(
 		private readonly data: RemoveFieldModificationData,
 		private readonly schema: Schema,
@@ -44,7 +43,6 @@ export class RemoveFieldModificationHandler implements ModificationHandler<Remov
 	describe() {
 		return { message: `Remove field ${this.data.entityName}.${this.data.fieldName}`, isDestructive: true }
 	}
-
 }
 
 export interface RemoveFieldModificationData {

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -13,18 +13,9 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import {
-	createModificationType,
-	ModificationHandler,
-	ModificationHandlerCreateSqlOptions,
-	ModificationHandlerOptions,
-} from '../ModificationHandler'
+import { createModificationType, ModificationHandler, ModificationHandlerCreateSqlOptions, ModificationHandlerOptions } from '../ModificationHandler'
 import { acceptFieldVisitor, PredicateDefinitionProcessor } from '@contember/schema-utils'
-import {
-	VERSION_ACL_PATCH,
-	VERSION_UPDATE_CONSTRAINT_FIELDS,
-	VERSION_UPDATE_INDEX_FIELDS,
-} from '../ModificationVersions'
+import { VERSION_ACL_PATCH, VERSION_UPDATE_CONSTRAINT_FIELDS, VERSION_UPDATE_INDEX_FIELDS } from '../ModificationVersions'
 import { changeValue } from '../utils/valueUtils'
 import { updateColumnNameModification } from '../columns'
 import { NoopModification } from '../NoopModification'
@@ -38,11 +29,15 @@ export class UpdateFieldNameModificationHandler implements ModificationHandler<U
 		private readonly options: ModificationHandlerOptions,
 	) {
 		if (this.data.columnName) {
-			this.renameColumnSubModification = updateColumnNameModification.createHandler({
-				entityName: this.data.entityName,
-				columnName: this.data.columnName,
-				fieldName: this.data.fieldName,
-			}, this.schema, this.options)
+			this.renameColumnSubModification = updateColumnNameModification.createHandler(
+				{
+					entityName: this.data.entityName,
+					columnName: this.data.columnName,
+					fieldName: this.data.fieldName,
+				},
+				this.schema,
+				this.options,
+			)
 		}
 	}
 
@@ -55,30 +50,28 @@ export class UpdateFieldNameModificationHandler implements ModificationHandler<U
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
-		const updateConstraintFields =
-			this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_FIELDS
-				? updateEntity(this.data.entityName, ({ entity }) => {
-					return {
-						...entity,
-						unique: entity.unique.map(unique => ({
-							...unique,
-							fields: unique.fields.map(changeValue(this.data.fieldName, this.data.newFieldName)),
-						})),
-					}
-				  })
-				: undefined
-		const updateIndexFields =
-			this.options.formatVersion >= VERSION_UPDATE_INDEX_FIELDS
-				? updateEntity(this.data.entityName, ({ entity }) => {
-					return {
-						...entity,
-						indexes: entity.indexes.map(unique => ({
-							...unique,
-							fields: unique.fields.map(changeValue(this.data.fieldName, this.data.newFieldName)),
-						})),
-					}
-				})
-				: undefined
+		const updateConstraintFields = this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_FIELDS
+			? updateEntity(this.data.entityName, ({ entity }) => {
+				return {
+					...entity,
+					unique: entity.unique.map(unique => ({
+						...unique,
+						fields: unique.fields.map(changeValue(this.data.fieldName, this.data.newFieldName)),
+					})),
+				}
+			})
+			: undefined
+		const updateIndexFields = this.options.formatVersion >= VERSION_UPDATE_INDEX_FIELDS
+			? updateEntity(this.data.entityName, ({ entity }) => {
+				return {
+					...entity,
+					indexes: entity.indexes.map(unique => ({
+						...unique,
+						fields: unique.fields.map(changeValue(this.data.fieldName, this.data.newFieldName)),
+					})),
+				}
+			})
+			: undefined
 		const updateRelationReferences = updateEveryEntity(
 			updateEveryField(({ field, entity }) => {
 				const isUpdatedRelation = (entity: Model.Entity, relation: Model.AnyRelation | null) => {
@@ -130,46 +123,45 @@ export class UpdateFieldNameModificationHandler implements ModificationHandler<U
 				},
 			}
 		})
-		const updateAclOp =
-			this.options.formatVersion >= VERSION_ACL_PATCH
-				? updateAcl(
-					updateAclEveryRole(
-						updateAclEveryEntity(
-							updateAclFieldPermissions((permissions, entityName) => {
-								if (entityName !== this.data.entityName) {
-									return permissions
-								}
-								if (!permissions[this.data.fieldName]) {
-									return permissions
-								}
-								const { [this.data.fieldName]: field, ...other } = permissions
-								return {
-									[this.data.newFieldName]: field,
-									...other,
-								}
-							}),
-							updateAclEveryPredicate(({ predicate, entityName, schema }) => {
-								const processor = new PredicateDefinitionProcessor(schema.model)
-								const currentEntity = schema.model.entities[entityName]
-								return processor.process<Input.Condition<Value.FieldValue<never>> | string, never>(
-									currentEntity,
-									predicate,
-									{
-										handleColumn: ctx =>
-											ctx.entity.name === this.data.entityName && ctx.column.name === this.data.fieldName
-												? [this.data.newFieldName, ctx.value]
-												: ctx.value,
-										handleRelation: ctx =>
-											ctx.entity.name === this.data.entityName && ctx.relation.name === this.data.fieldName
-												? [this.data.newFieldName, ctx.value]
-												: ctx.value,
-									},
-								)
-							}),
-						),
+		const updateAclOp = this.options.formatVersion >= VERSION_ACL_PATCH
+			? updateAcl(
+				updateAclEveryRole(
+					updateAclEveryEntity(
+						updateAclFieldPermissions((permissions, entityName) => {
+							if (entityName !== this.data.entityName) {
+								return permissions
+							}
+							if (!permissions[this.data.fieldName]) {
+								return permissions
+							}
+							const { [this.data.fieldName]: field, ...other } = permissions
+							return {
+								[this.data.newFieldName]: field,
+								...other,
+							}
+						}),
+						updateAclEveryPredicate(({ predicate, entityName, schema }) => {
+							const processor = new PredicateDefinitionProcessor(schema.model)
+							const currentEntity = schema.model.entities[entityName]
+							return processor.process<Input.Condition<Value.FieldValue<never>> | string, never>(
+								currentEntity,
+								predicate,
+								{
+									handleColumn: ctx =>
+										ctx.entity.name === this.data.entityName && ctx.column.name === this.data.fieldName
+											? [this.data.newFieldName, ctx.value]
+											: ctx.value,
+									handleRelation: ctx =>
+										ctx.entity.name === this.data.entityName && ctx.relation.name === this.data.fieldName
+											? [this.data.newFieldName, ctx.value]
+											: ctx.value,
+								},
+							)
+						}),
 					),
-				  )
-				: undefined
+				),
+			)
+			: undefined
 		return updateSchema(
 			updateAclOp,
 			this.renameColumnSubModification.getSchemaUpdater(),

package/src/modifications/indexes/CreateIndexModification.ts

@@ -1,12 +1,7 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import {
-	createModificationType,
-	Differ,
-	ModificationHandler,
-	ModificationHandlerCreateSqlOptions,
-} from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler'
 import { wrapIdentifier } from '../../utils/dbHelpers'
 import { getIndexColumns } from './utils'
 import deepEqual from 'fast-deep-equal'
@@ -28,8 +23,9 @@ export class CreateIndexModificationHandler implements ModificationHandler<Creat
 
 		const tableNameId = wrapIdentifier(entity.tableName)
 		const columnNameIds = columns.map(wrapIdentifier)
+		const methodClause = this.data.index.method ? ` USING ${this.data.index.method}` : ''
 
-		builder.sql(`CREATE INDEX ON ${tableNameId} (${columnNameIds.join(', ')})`)
+		builder.sql(`CREATE INDEX ON ${tableNameId}${methodClause} (${columnNameIds.join(', ')})`)
 
 		invalidateDatabaseMetadata()
 	}
@@ -47,8 +43,9 @@ export class CreateIndexModificationHandler implements ModificationHandler<Creat
 	}
 
 	describe() {
+		const methodText = this.data.index.method ? ` using ${this.data.index.method}` : ''
 		return {
-			message: `Create index(${this.data.index.fields.join(', ')}) on entity ${this.data.entityName}`,
+			message: `Create index(${this.data.index.fields.join(', ')})${methodText} on entity ${this.data.entityName}`,
 		}
 	}
 }
@@ -68,10 +65,12 @@ export class CreateIndexDiffer implements Differ {
 		return Object.values(updatedSchema.model.entities).flatMap(entity =>
 			entity.indexes
 				.filter(it => !originalSchema.model.entities[entity.name].indexes.find(idx => deepEqual(idx, it)))
-				.map(index => createIndexModification.createModification({
-					entityName: entity.name,
-					index,
-				})),
+				.map(index =>
+					createIndexModification.createModification({
+						entityName: entity.name,
+						index,
+					})
+				)
 		)
 	}
 }

package/src/modifications/indexes/RemoveIndexModification.ts

@@ -1,17 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
-import {
-	createModificationType,
-	Differ,
-	ModificationHandler,
-	ModificationHandlerCreateSqlOptions,
-} from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { getIndexColumns } from './utils'
 import { wrapIdentifier } from '../../utils/dbHelpers'
 
-export class RemoveIndexModificationHandler implements ModificationHandler<RemoveIndexModificationData>  {
+export class RemoveIndexModificationHandler implements ModificationHandler<RemoveIndexModificationData> {
 	constructor(private readonly data: RemoveIndexModificationData, private readonly schema: Schema) {}
 
 	public createSql(builder: MigrationBuilder, { databaseMetadata, invalidateDatabaseMetadata }: ModificationHandlerCreateSqlOptions): void {
@@ -70,7 +65,6 @@ export const removeIndexModification = createModificationType({
 	handler: RemoveIndexModificationHandler,
 })
 
-
 export type RemoveIndexModificationData =
 	| {
 		entityName: string
@@ -84,7 +78,6 @@ export type RemoveIndexModificationData =
 	}
 
 export class RemoveIndexDiffer implements Differ {
-
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return Object.values(originalSchema.model.entities).flatMap(entity =>
 			entity.indexes
@@ -101,8 +94,8 @@ export class RemoveIndexDiffer implements Differ {
 					removeIndexModification.createModification({
 						entityName: entity.name,
 						fields: index.fields,
-					}),
-				),
+					})
+				)
 		)
 	}
 }

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

@@ -4,7 +4,8 @@ import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from
 import {
 	createModificationType,
 	Differ,
-	ModificationHandler, ModificationHandlerCreateSqlOptions,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
 import { isInverseRelation, isOwningRelation } from '@contember/schema-utils'
@@ -14,7 +15,9 @@ import { wrapIdentifier } from '../../utils/dbHelpers'
 import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
 import { updateFieldNameModification } from '../fields'
 
-export class ConvertOneHasManyToManyHasManyRelationModificationHandler implements ModificationHandler<ConvertOneHasManyToManyHasManyRelationModificationData> {
+export class ConvertOneHasManyToManyHasManyRelationModificationHandler
+	implements ModificationHandler<ConvertOneHasManyToManyHasManyRelationModificationData>
+{
 	private subModification: ModificationHandler<any>
 
 	constructor(
@@ -93,10 +96,10 @@ export class ConvertOneHasManyToManyHasManyRelationDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
-				isInverseRelation(originalRelation) &&
-				isInverseRelation(updatedRelation) &&
-				originalRelation.type === Model.RelationType.OneHasMany &&
-				updatedRelation.type === Model.RelationType.ManyHasMany
+				isInverseRelation(originalRelation)
+				&& isInverseRelation(updatedRelation)
+				&& originalRelation.type === Model.RelationType.OneHasMany
+				&& updatedRelation.type === Model.RelationType.ManyHasMany
 			) {
 				const owningOldName = originalRelation.ownedBy
 				const owningNewName = updatedRelation.ownedBy

package/src/modifications/relations/ConvertOneHasManyToOneHasOneRelationModification.ts

@@ -14,7 +14,9 @@ import { NoopModification } from '../NoopModification'
 import { updateFieldNameModification } from '../fields'
 import { wrapIdentifier } from '../../utils/dbHelpers'
 
-export class ConvertOneHasManyToOneHasOneRelationModificationHandler implements ModificationHandler<ConvertOneHasManyToOneHasOneRelationModificationData> {
+export class ConvertOneHasManyToOneHasOneRelationModificationHandler
+	implements ModificationHandler<ConvertOneHasManyToOneHasOneRelationModificationData>
+{
 	private subModification: ModificationHandler<any>
 
 	constructor(
@@ -23,8 +25,8 @@ export class ConvertOneHasManyToOneHasOneRelationModificationHandler implements
 		private readonly options: ModificationHandlerOptions,
 	) {
 		const { relation } = this.getRelation()
-		this.subModification = data.newInverseSideFieldName && relation.inversedBy ?
-			updateFieldNameModification.createHandler(
+		this.subModification = data.newInverseSideFieldName && relation.inversedBy
+			? updateFieldNameModification.createHandler(
 				{
 					entityName: relation.target,
 					fieldName: relation.inversedBy,
@@ -76,8 +78,8 @@ export class ConvertOneHasManyToOneHasOneRelationModificationHandler implements
 				),
 			),
 			this.subModification.getSchemaUpdater(),
-			inverseFieldName ?
-				updateModel(
+			inverseFieldName
+				? updateModel(
 					updateEntity(
 						relation.target,
 						updateField<Model.OneHasManyRelation, Model.OneHasOneInverseRelation>(
@@ -89,7 +91,8 @@ export class ConvertOneHasManyToOneHasOneRelationModificationHandler implements
 							}),
 						),
 					),
-				) : undefined,
+				)
+				: undefined,
 		)
 	}
 
@@ -125,18 +128,21 @@ export class ConvertOneHasManyToOneHasOneRelationDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
-				isOwningRelation(originalRelation) &&
-				isOwningRelation(updatedRelation) &&
-				originalRelation.type === Model.RelationType.ManyHasOne &&
-				updatedRelation.type === Model.RelationType.OneHasOne
+				isOwningRelation(originalRelation)
+				&& isOwningRelation(updatedRelation)
+				&& originalRelation.type === Model.RelationType.ManyHasOne
+				&& updatedRelation.type === Model.RelationType.OneHasOne
 			) {
-				const isInverseSideRenamed = originalRelation.inversedBy && updatedRelation.inversedBy && originalRelation.inversedBy !== updatedRelation.inversedBy
+				const isInverseSideRenamed = originalRelation.inversedBy && updatedRelation.inversedBy
+					&& originalRelation.inversedBy !== updatedRelation.inversedBy
 				return convertOneHasManyToOneHasOneRelationModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
-					...(isInverseSideRenamed ? {
-						newInverseSideFieldName: updatedRelation.inversedBy,
-					} : {}),
+					...(isInverseSideRenamed
+						? {
+							newInverseSideFieldName: updatedRelation.inversedBy,
+						}
+						: {}),
 				})
 			}
 			return undefined

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -23,8 +23,8 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 		private readonly options: ModificationHandlerOptions,
 	) {
 		const { relation } = this.getRelation()
-		this.subModification = data.newInverseSideFieldName && relation.inversedBy ?
-			updateFieldNameModification.createHandler(
+		this.subModification = data.newInverseSideFieldName && relation.inversedBy
+			? updateFieldNameModification.createHandler(
 				{
 					entityName: relation.target,
 					fieldName: relation.inversedBy,
@@ -76,19 +76,20 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 				),
 			),
 			this.subModification.getSchemaUpdater(),
-			inverseFieldName ?
-				updateModel(
+			inverseFieldName
+				? updateModel(
 					updateEntity(
 						relation.target,
 						updateField<Model.OneHasOneInverseRelation, Model.OneHasManyRelation>(
 							inverseFieldName,
-							({ field: { type,  nullable, ...field } }) => ({
+							({ field: { type, nullable, ...field } }) => ({
 								type: Model.RelationType.OneHasMany,
 								...field,
 							}),
 						),
 					),
-				) : undefined,
+				)
+				: undefined,
 		)
 	}
 
@@ -123,18 +124,21 @@ export class ConvertOneToManyRelationDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
-				isOwningRelation(originalRelation) &&
-				isOwningRelation(updatedRelation) &&
-				originalRelation.type === Model.RelationType.OneHasOne &&
-				updatedRelation.type === Model.RelationType.ManyHasOne
+				isOwningRelation(originalRelation)
+				&& isOwningRelation(updatedRelation)
+				&& originalRelation.type === Model.RelationType.OneHasOne
+				&& updatedRelation.type === Model.RelationType.ManyHasOne
 			) {
-				const isInverseSideRenamed = originalRelation.inversedBy && updatedRelation.inversedBy && originalRelation.inversedBy !== updatedRelation.inversedBy
+				const isInverseSideRenamed = originalRelation.inversedBy && updatedRelation.inversedBy
+					&& originalRelation.inversedBy !== updatedRelation.inversedBy
 				return convertOneToManyRelationModification.createModification({
 					entityName: updatedEntity.name,
 					fieldName: updatedRelation.name,
-					...(isInverseSideRenamed ? {
-						newInverseSideFieldName: updatedRelation.inversedBy,
-					} : {}),
+					...(isInverseSideRenamed
+						? {
+							newInverseSideFieldName: updatedRelation.inversedBy,
+						}
+						: {}),
 				})
 			}
 			return undefined