@contember/schema-migrations 2.1.0-alpha.30 → 2.1.0-alpha.36

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'
@@ -70,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

package/src/modifications/relations/CreateRelationModification.ts

@@ -5,7 +5,8 @@ import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from
 import {
 	createModificationType,
 	Differ,
-	ModificationHandler, ModificationHandlerCreateSqlOptions,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
@@ -16,9 +17,7 @@ import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './norm
 import { addForeignKeyConstraint } from './helpers'
 import { wrapIdentifier } from '../../utils/dbHelpers'
 
-
 export class CreateRelationModificationHandler implements ModificationHandler<CreateRelationModificationData> {
-
 	constructor(
 		private readonly data: CreateRelationModificationData,
 		private readonly schema: Schema,
@@ -82,14 +81,12 @@ export class CreateRelationModificationHandler implements ModificationHandler<Cr
 
 	describe({ createdEntities }: { createdEntities: string[] }) {
 		const notNull = isIt<Model.NullableRelation>(this.data.owningSide, 'nullable') && !this.data.owningSide.nullable
-		const failureWarning =
-			notNull && !createdEntities.includes(this.data.entityName)
-				? `May fail in runtime, because relation is not-null`
-				: undefined
+		const failureWarning = notNull && !createdEntities.includes(this.data.entityName)
+			? `May fail in runtime, because relation is not-null`
+			: undefined
 		return { message: `Add relation ${this.data.entityName}.${this.data.owningSide.name}`, failureWarning }
 	}
 
-
 	private getNormalizedOwningSide(): Model.AnyOwningRelation {
 		if (this.data.owningSide.type === Model.RelationType.ManyHasMany) {
 			return normalizeManyHasManyRelation(this.data.owningSide)
@@ -98,7 +95,6 @@ export class CreateRelationModificationHandler implements ModificationHandler<Cr
 	}
 }
 
-
 export type CreateRelationModificationData = {
 	entityName: string
 	owningSide:

package/src/modifications/relations/DisableOrphanRemovalModification.ts

@@ -5,7 +5,6 @@ import { isOwningRelation } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 
 export class DisableOrphanRemovalModificationHandler implements ModificationHandler<DisableOrphanRemovalModificationData> {
-
 	constructor(private readonly data: DisableOrphanRemovalModificationData, private readonly schema: Schema) {}
 
 	public createSql(): void {}
@@ -41,12 +40,12 @@ export class DisableOrphanRemovalDiffer 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.OneHasOne &&
-				originalRelation.orphanRemoval &&
-				!updatedRelation.orphanRemoval
+				isOwningRelation(originalRelation)
+				&& isOwningRelation(updatedRelation)
+				&& originalRelation.type === Model.RelationType.OneHasOne
+				&& updatedRelation.type === Model.RelationType.OneHasOne
+				&& originalRelation.orphanRemoval
+				&& !updatedRelation.orphanRemoval
 			) {
 				return disableOrphanRemovalModification.createModification({
 					entityName: updatedEntity.name,

package/src/modifications/relations/EnableOrphanRemovalModification.ts

@@ -27,7 +27,6 @@ export class EnableOrphanRemovalModificationHandler implements ModificationHandl
 			message: `Enable orphan removal on ${this.data.entityName}.${this.data.fieldName}`,
 		}
 	}
-
 }
 
 export interface EnableOrphanRemovalModificationData {
@@ -41,15 +40,15 @@ export const enableOrphanRemovalModification = createModificationType({
 })
 
 export class EnableOrphanRemovalDiffer implements Differ {
-	 createDiff(originalSchema: Schema, updatedSchema: Schema) {
+	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.OneHasOne &&
-				!originalRelation.orphanRemoval &&
-				updatedRelation.orphanRemoval
+				isOwningRelation(originalRelation)
+				&& isOwningRelation(updatedRelation)
+				&& originalRelation.type === Model.RelationType.OneHasOne
+				&& updatedRelation.type === Model.RelationType.OneHasOne
+				&& !originalRelation.orphanRemoval
+				&& updatedRelation.orphanRemoval
 			) {
 				return enableOrphanRemovalModification.createModification({
 					entityName: updatedEntity.name,

package/src/modifications/relations/MakeRelationNotNullModification.ts

@@ -59,11 +59,11 @@ export class MakeRelationNotNullDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
-				originalRelation.type === updatedRelation.type &&
-				isIt<Model.NullableRelation>(updatedRelation, 'nullable') &&
-				isIt<Model.NullableRelation>(originalRelation, 'nullable') &&
-				!updatedRelation.nullable &&
-				originalRelation.nullable
+				originalRelation.type === updatedRelation.type
+				&& isIt<Model.NullableRelation>(updatedRelation, 'nullable')
+				&& isIt<Model.NullableRelation>(originalRelation, 'nullable')
+				&& !updatedRelation.nullable
+				&& originalRelation.nullable
 			) {
 				return makeRelationNotNullModification.createModification({
 					entityName: updatedEntity.name,

package/src/modifications/relations/MakeRelationNullableModification.ts

@@ -41,7 +41,6 @@ export class MakeRelationNullableModificationHandler implements ModificationHand
 			message: `Make relation ${this.data.entityName}.${this.data.fieldName} nullable`,
 		}
 	}
-
 }
 
 export interface MakeRelationNullableModificationData {
@@ -49,7 +48,6 @@ export interface MakeRelationNullableModificationData {
 	fieldName: string
 }
 
-
 export const makeRelationNullableModification = createModificationType({
 	id: 'makeRelationNullable',
 	handler: MakeRelationNullableModificationHandler,
@@ -59,11 +57,11 @@ export class MakeRelationNullableDiffer implements Differ {
 	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
-				originalRelation.type === updatedRelation.type &&
-				isIt<Model.NullableRelation>(updatedRelation, 'nullable') &&
-				isIt<Model.NullableRelation>(originalRelation, 'nullable') &&
-				updatedRelation.nullable &&
-				!originalRelation.nullable
+				originalRelation.type === updatedRelation.type
+				&& isIt<Model.NullableRelation>(updatedRelation, 'nullable')
+				&& isIt<Model.NullableRelation>(originalRelation, 'nullable')
+				&& updatedRelation.nullable
+				&& !originalRelation.nullable
 			) {
 				return makeRelationNullableModification.createModification({
 					entityName: updatedEntity.name,

package/src/modifications/relations/ToggleJunctionEventLogModification.ts

@@ -1,24 +1,13 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import {
-	createModificationType,
-	Differ,
-	ModificationHandler,
-	ModificationHandlerCreateSqlOptions,
-} from '../ModificationHandler'
-import {
-	createEventTrigger,
-	createEventTrxTrigger,
-	dropEventTrigger,
-	dropEventTrxTrigger,
-} from '../utils/sqlUpdateUtils'
+import { createModificationType, Differ, ModificationHandler, ModificationHandlerCreateSqlOptions } from '../ModificationHandler'
+import { createEventTrigger, createEventTrxTrigger, dropEventTrigger, dropEventTrxTrigger } from '../utils/sqlUpdateUtils'
 import { isOwningRelation, isRelation } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 import { isIt } from '../../utils/isIt'
 
 export class ToggleJunctionEventLogModificationHandler implements ModificationHandler<ToggleJunctionEventLogModificationData> {
-
 	constructor(
 		private readonly data: ToggleJunctionEventLogModificationData,
 		private readonly schema: Schema,
@@ -84,12 +73,12 @@ export const toggleJunctionEventLogModification = createModificationType({
 })
 
 export class ToggleJunctionEventLogDiffer implements Differ {
-	 createDiff(originalSchema: Schema, updatedSchema: Schema) {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		return updateRelations(originalSchema, updatedSchema, ({ originalRelation, updatedRelation, updatedEntity }) => {
 			if (
-				originalRelation.type === updatedRelation.type &&
-				isIt<Model.JoiningTableRelation>(updatedRelation, 'joiningTable') &&
-				isIt<Model.JoiningTableRelation>(originalRelation, 'joiningTable')
+				originalRelation.type === updatedRelation.type
+				&& isIt<Model.JoiningTableRelation>(updatedRelation, 'joiningTable')
+				&& isIt<Model.JoiningTableRelation>(originalRelation, 'joiningTable')
 			) {
 				const newValue = updatedRelation.joiningTable.eventLog?.enabled ?? false
 				const oldValue = originalRelation.joiningTable.eventLog?.enabled ?? false
@@ -103,6 +92,5 @@ export class ToggleJunctionEventLogDiffer implements Differ {
 			}
 			return undefined
 		})
-
 	}
 }