@contember/schema-migrations 1.1.0-alpha.4 → 1.1.0-alpha.7

package/src/modifications/columns/UpdateColumnDefinitionModification.ts

@@ -26,7 +26,24 @@ export const UpdateColumnDefinitionModification: ModificationHandlerStatic<Updat
 			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 seqAlter = []
+		if (field.sequence && definition.sequence) {
+			if (field.sequence.precedence !== definition.sequence.precedence) {
+				seqAlter.push(`SET GENERATED ${definition.sequence.precedence}`)
+			}
+			if (field.sequence.start !== definition.sequence.start && typeof definition.sequence.start == 'number') {
+				seqAlter.push(`SET START WITH ${definition.sequence.start}`)
+			}
+			if (definition.sequence.restart) {
+				seqAlter.push('RESTART')
+			}
+		}
+		if (seqAlter.length > 0) {
+			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} ALTER ${wrapIdentifier(field.columnName)} ${seqAlter.join(' ')}`)
+		}
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -83,8 +100,20 @@ export const UpdateColumnDefinitionModification: ModificationHandlerStatic<Updat
 	}
 }
 
+type SequenceDefinitionAlter =
+	& Model.AnyColumn['sequence']
+	& {
+		restart?: boolean
+	}
+
+type ColumnDefinitionAlter =
+	& Model.AnyColumn
+	& {
+		sequence?: SequenceDefinitionAlter
+	}
+
 export interface UpdateColumnDefinitionModificationData {
 	entityName: string
 	fieldName: string
-	definition: Model.AnyColumn
+	definition: ColumnDefinitionAlter
 }

package/src/modifications/columns/UpdateColumnNameModification.ts

@@ -3,6 +3,7 @@ import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { updateColumns } from '../utils/diffUtils'
+import { acceptFieldVisitor } from '@contember/schema-utils'
 
 export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColumnNameModificationData> = class {
 	static id = 'updateColumnName'
@@ -13,15 +14,73 @@ export const UpdateColumnNameModification: ModificationHandlerStatic<UpdateColum
 		if (entity.view) {
 			return
 		}
-		const field = entity.fields[this.data.fieldName] as Model.AnyColumn
-		builder.renameColumn(entity.tableName, field.columnName, this.data.columnName)
+		acceptFieldVisitor(this.schema.model, entity, this.data.fieldName, {
+			visitColumn: (entity, column) => {
+				builder.renameColumn(entity.tableName, column.columnName, this.data.columnName)
+			},
+			visitManyHasOne: (entity, relation) => {
+				builder.renameColumn(entity.tableName, relation.joiningColumn.columnName, this.data.columnName)
+			},
+			visitOneHasOneOwning: (entity, relation) =>  {
+				builder.renameColumn(entity.tableName, 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')
+			},
+		})
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
 		return updateModel(
 			updateEntity(
 				this.data.entityName,
-				updateField(this.data.fieldName, ({ field }) => ({ ...field, columnName: this.data.columnName })),
+				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,
+								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/entities/CreateEntityModification.ts

@@ -20,15 +20,20 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 			return
 		}
 		const primaryColumn = entity.fields[entity.primary] as Model.AnyColumn
+
 		builder.createTable(entity.tableName, {
 			[primaryColumn.name]: {
 				primaryKey: true,
 				type: primaryColumn.type === Model.ColumnType.Enum ? `"${primaryColumn.columnType}"` : primaryColumn.columnType,
 				notNull: true,
+				sequenceGenerated: primaryColumn.sequence,
 			},
 		})
-		createEventTrigger(builder, this.options.systemSchema, entity.tableName, [entity.primaryColumn])
-		createEventTrxTrigger(builder, this.options.systemSchema, entity.tableName)
+
+		if  (entity.eventLog?.enabled !== false) {
+			createEventTrigger(builder, this.options.systemSchema, entity.tableName, [entity.primaryColumn])
+			createEventTrxTrigger(builder, this.options.systemSchema, entity.tableName)
+		}
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -36,7 +41,10 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 			...model,
 			entities: {
 				...model.entities,
-				[this.data.entity.name]: this.data.entity,
+				[this.data.entity.name]: {
+					eventLog: { enabled: true },
+					...this.data.entity,
+				},
 			},
 		}))
 	}
@@ -68,6 +76,8 @@ export const CreateEntityModification: ModificationHandlerStatic<CreateEntityMod
 	}
 }
 
+type SomePartial<E, K extends keyof E> = Omit<E, K> & Partial<Pick<E, K>>
+
 export interface CreateEntityModificationData {
-	entity: Model.Entity
+	entity: SomePartial<Model.Entity, 'eventLog'>
 }

package/src/modifications/entities/CreateViewModification.ts

@@ -21,7 +21,10 @@ export const CreateViewModification: ModificationHandlerStatic<CreateViewModific
 			...model,
 			entities: {
 				...model.entities,
-				[this.data.entity.name]: this.data.entity,
+				[this.data.entity.name]: {
+					eventLog: { enabled: true }, // not relevant here...
+					...this.data.entity,
+				},
 			},
 		}))
 	}
@@ -60,6 +63,8 @@ export const CreateViewModification: ModificationHandlerStatic<CreateViewModific
 	}
 }
 
+type SomePartial<E, K extends keyof E> = Omit<E, K> & Partial<Pick<E, K>>
+
 export interface CreateViewModificationData {
-	entity: Model.Entity
+	entity: SomePartial<Model.Entity, 'eventLog'>
 }

package/src/modifications/entities/ToggleEventLogModification.ts

@@ -0,0 +1,83 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
+import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import {
+	createEventTrigger,
+	createEventTrxTrigger,
+	dropEventTrigger,
+	dropEventTrxTrigger,
+} from '../utils/sqlUpdateUtils'
+
+export const ToggleEventLogModification: ModificationHandlerStatic<ToggleEventLogModificationData> = class {
+	static id = 'toggleEventLog'
+
+	constructor(
+		private readonly data: ToggleEventLogModificationData,
+		private readonly schema: Schema,
+		private readonly options: ModificationHandlerOptions,
+	) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+		const entity = this.schema.model.entities[this.data.entityName]
+		if (entity.view) {
+			return
+		}
+		if (this.data.enabled) {
+			createEventTrigger(builder, this.options.systemSchema, entity.tableName, [entity.primaryColumn])
+			createEventTrxTrigger(builder, this.options.systemSchema, entity.tableName)
+		} else {
+			dropEventTrigger(builder, entity.tableName)
+			dropEventTrxTrigger(builder, entity.tableName)
+		}
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		const { entityName, enabled } = this.data
+		return updateModel(
+			updateEntity(
+				entityName,
+				({ entity: { eventLog, ...entity } }) => ({
+					...entity,
+					eventLog: { enabled },
+				}),
+			),
+		)
+	}
+
+	describe() {
+		return {
+			message: `${this.data.enabled ? 'Enable' : 'Disable'} event log for ${this.data.entityName}`,
+		}
+	}
+
+	static createModification(data: ToggleEventLogModificationData) {
+		return { modification: this.id, ...data }
+	}
+
+	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.values(updatedSchema.model.entities)
+			.flatMap(updatedEntity => {
+				const origEntity = originalSchema.model.entities[updatedEntity.name]
+				if (!origEntity) {
+					return []
+				}
+				const newValue = updatedEntity.eventLog.enabled
+				const oldValue = origEntity.eventLog.enabled
+				if (newValue !== oldValue) {
+					return [ToggleEventLogModification.createModification({
+						entityName: updatedEntity.name,
+						enabled: newValue,
+					})]
+				}
+				return []
+			})
+
+	}
+}
+
+export interface ToggleEventLogModificationData {
+	entityName: string
+	enabled: boolean
+}

package/src/modifications/entities/index.ts

@@ -1,5 +1,6 @@
 export * from './CreateEntityModification'
 export * from './CreateViewModification'
 export * from './RemoveEntityModification'
+export * from './ToggleEventLogModification'
 export * from './UpdateEntityNameModification'
 export * from './UpdateEntityTableNameModification'

package/src/modifications/enums/CreateEnumModification.ts

@@ -42,5 +42,5 @@ export const CreateEnumModification: ModificationHandlerStatic<CreateEnumModific
 
 export interface CreateEnumModificationData {
 	enumName: string
-	values: string[]
+	values: readonly string[]
 }

package/src/modifications/enums/UpdateEnumModification.ts

@@ -55,5 +55,5 @@ export const UpdateEnumModification: ModificationHandlerStatic<UpdateEnumModific
 
 export interface UpdateEnumModificationData {
 	enumName: string
-	values: string[]
+	values: readonly string[]
 }

package/src/modifications/enums/enumUtils.ts

@@ -1,6 +1,6 @@
 import { escapeSqlString } from '../../utils/escapeSqlString'
 
-export const createCheck = (values: string[]) => {
+export const createCheck = (values: readonly string[]) => {
 	const joinedValues = values.map(it => `'${escapeSqlString(it)}'`).join(',')
 	return `VALUE IN(${joinedValues})`
 }

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -13,19 +13,32 @@ import {
 	updateModel,
 	updateSchema,
 } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
+import { ModificationHandler, ModificationHandlerOptions, ModificationHandlerStatic } from '../ModificationHandler'
 import { acceptFieldVisitor, NamingHelper, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { VERSION_ACL_PATCH, VERSION_UPDATE_CONSTRAINT_NAME } from '../ModificationVersions'
 import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../utils/renameConstraintsHelper'
 import { changeValue } from '../utils/valueUtils'
+import { UpdateColumnNameModification } from '../columns'
+import { NoopModification } from '../NoopModification'
 
 export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldNameModificationData> = class {
 	static id = 'updateFieldName'
+
+	private renameColumnSubModification: ModificationHandler<any> = new NoopModification()
+
 	constructor(
 		private readonly data: UpdateFieldNameModificationData,
 		private readonly schema: Schema,
 		private readonly options: ModificationHandlerOptions,
-	) {}
+	) {
+		if (this.data.columnName) {
+			this.renameColumnSubModification = new UpdateColumnNameModification({
+				entityName: this.data.entityName,
+				columnName: this.data.columnName,
+				fieldName: this.data.fieldName,
+			}, this.schema, this.options)
+		}
+	}
 
 	public createSql(builder: MigrationBuilder): void {
 		const entity = this.schema.model.entities[this.data.entityName]
@@ -35,6 +48,7 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 		if (this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
 			renameConstraintsSqlBuilder(builder, entity, this.getNewConstraintName.bind(this))
 		}
+		this.renameColumnSubModification.createSql(builder)
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
@@ -101,7 +115,7 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 				})
 			}),
 		)
-		const updateEntityName = updateEntity(this.data.entityName, ({ entity }) => {
+		const updateFieldName = updateEntity(this.data.entityName, ({ entity }) => {
 			const { [this.data.fieldName]: updated, ...fields } = entity.fields
 			return {
 				...entity,
@@ -153,10 +167,17 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 				: undefined
 		return updateSchema(
 			updateAclOp,
-			updateModel(updateConstraintName, updateConstraintFields, updateRelationReferences, updateEntityName),
+			this.renameColumnSubModification.getSchemaUpdater(),
+			updateModel(
+				updateConstraintName,
+				updateConstraintFields,
+				updateRelationReferences,
+				updateFieldName,
+			),
 		)
 	}
 
+
 	private getNewConstraintName(constraint: Model.UniqueConstraint): string | null {
 		const generatedName = NamingHelper.createUniqueConstraintName(this.data.entityName, constraint.fields)
 		const isGenerated = constraint.name === generatedName
@@ -181,4 +202,5 @@ export interface UpdateFieldNameModificationData {
 	entityName: string
 	fieldName: string
 	newFieldName: string
+	columnName?: string
 }

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

@@ -7,6 +7,7 @@ import { updateRelations } from '../utils/diffUtils'
 import { UpdateFieldNameModification } from '../fields'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
 import { wrapIdentifier } from '@contember/database'
+import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
 
 export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHandlerStatic<ConvertOneHasManyToManyHasManyRelationModificationData> = class {
 	static id = 'convertOneHasManyToManyHasManyRelation'
@@ -33,7 +34,7 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 		const { relation: oldRelation } = this.getRelation()
 		const entity = this.schema.model.entities[this.data.entityName]
 
-		createJunctionTableSql(builder, this.options.systemSchema, entity, targetEntity, this.data.owningSide)
+		createJunctionTableSql(builder, this.options.systemSchema, entity, targetEntity, normalizeManyHasManyRelation(this.data.owningSide))
 		const joiningTable = this.data.owningSide.joiningTable
 		builder.sql(`
 			INSERT INTO ${wrapIdentifier(joiningTable.tableName)} (
@@ -51,7 +52,7 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 		const { entityName } = this.data
 		return updateSchema(
 			this.subModification.getSchemaUpdater(),
-			updateModel(updateEntity(entityName, addField(this.data.owningSide))),
+			updateModel(updateEntity(entityName, addField(normalizeManyHasManyRelation(this.data.owningSide)))),
 			this.data.inverseSide ? updateModel(updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))) : undefined,
 		)
 	}
@@ -104,6 +105,6 @@ export const ConvertOneHasManyToManyHasManyRelationModification: ModificationHan
 export interface ConvertOneHasManyToManyHasManyRelationModificationData {
 	entityName: string
 	fieldName: string
-	owningSide: Model.ManyHasManyOwningRelation
+	owningSide: PartialManyHasManyRelation
 	inverseSide?: Model.ManyHasManyInverseRelation
 }

package/src/modifications/relations/CreateRelationModification.ts

@@ -13,6 +13,7 @@ import { isIt } from '../../utils/isIt'
 import { createFields } from '../utils/diffUtils'
 import { getPrimaryColumnType } from '../utils/getPrimaryColumnType'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
+import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
 
 
 export const CreateRelationModification: ModificationHandlerStatic<CreateRelationModificationData> = class {
@@ -53,7 +54,7 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 				deferred: false,
 			})
 		}
-		acceptRelationTypeVisitor(this.schema.model, entity, this.data.owningSide, {
+		acceptRelationTypeVisitor(this.schema.model, entity, this.getNormalizedOwningSide(), {
 			visitManyHasOne: ({}, relation, {}, _) => {
 				createOwningSide(relation)
 				builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
@@ -74,7 +75,7 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 
 	public getSchemaUpdater(): SchemaUpdater {
 		return updateModel(
-			updateEntity(this.data.entityName, addField(this.data.owningSide)),
+			updateEntity(this.data.entityName, addField(this.getNormalizedOwningSide())),
 			this.data.inverseSide !== undefined
 				? updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))
 				: undefined,
@@ -112,10 +113,21 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 			})
 		})
 	}
+
+	private getNormalizedOwningSide(): Model.AnyOwningRelation {
+		if (this.data.owningSide.type === Model.RelationType.ManyHasMany) {
+			return normalizeManyHasManyRelation(this.data.owningSide)
+		}
+		return this.data.owningSide
+	}
 }
 
-export interface CreateRelationModificationData {
+
+export type CreateRelationModificationData = {
 	entityName: string
-	owningSide: Model.AnyRelation & Model.OwningRelation
-	inverseSide?: Model.AnyRelation & Model.InverseRelation
+	owningSide:
+		| Model.ManyHasOneRelation
+		| Model.OneHasOneOwningRelation
+		| PartialManyHasManyRelation
+	inverseSide?: Model.AnyInverseRelation
 }

package/src/modifications/relations/ToggleManyHasManyEventLogModification.ts

@@ -0,0 +1,102 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model, Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
+import { ModificationHandlerOptions, ModificationHandlerStatic } 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 const ToggleJunctionEventLogModification: ModificationHandlerStatic<ToggleJunctionEventLogModificationData> = class {
+	static id = 'toggleJunctionEventLog'
+
+	constructor(
+		private readonly data: ToggleJunctionEventLogModificationData,
+		private readonly schema: Schema,
+		private readonly options: ModificationHandlerOptions,
+	) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+		const entity = this.schema.model.entities[this.data.entityName]
+		const relation = entity.fields[this.data.fieldName]
+		if (!isRelation(relation) || relation.type !== Model.RelationType.ManyHasMany || !isOwningRelation(relation)) {
+			throw new Error('invalid field')
+		}
+		const tableName = relation.joiningTable.tableName
+		if (this.data.enabled) {
+			const primaryColumns = [
+				relation.joiningTable.joiningColumn.columnName,
+				relation.joiningTable.inverseJoiningColumn.columnName,
+			]
+			createEventTrigger(builder, this.options.systemSchema, tableName, primaryColumns)
+			createEventTrxTrigger(builder, this.options.systemSchema, tableName)
+		} else {
+			dropEventTrigger(builder, tableName)
+			dropEventTrxTrigger(builder, tableName)
+		}
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		const { entityName, fieldName, enabled } = this.data
+		return updateModel(
+			updateEntity(
+				entityName,
+				updateField<Model.ManyHasManyOwningRelation>(fieldName, ({ field: { joiningTable: { eventLog, ...joiningTable }, ...field } }) => {
+					return {
+						...field,
+						joiningTable: {
+							...joiningTable,
+							eventLog: {
+								enabled,
+							},
+						},
+					}
+				}),
+			),
+		)
+	}
+
+	describe() {
+		return {
+			message: `${this.data.enabled ? 'Enable' : 'Disable'} event log for ${this.data.entityName}.${this.data.fieldName}`,
+		}
+	}
+
+	static createModification(data: ToggleJunctionEventLogModificationData) {
+		return { modification: this.id, ...data }
+	}
+
+	static 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')
+			) {
+				const newValue = updatedRelation.joiningTable.eventLog?.enabled ?? false
+				const oldValue = originalRelation.joiningTable.eventLog?.enabled ?? false
+				if (newValue !== oldValue) {
+					return ToggleJunctionEventLogModification.createModification({
+						entityName: updatedEntity.name,
+						fieldName: updatedRelation.name,
+						enabled: newValue,
+					})
+				}
+			}
+			return undefined
+		})
+
+	}
+}
+
+export interface ToggleJunctionEventLogModificationData {
+	entityName: string
+	fieldName: string
+	enabled: boolean
+}

package/src/modifications/relations/UpdateRelationOrderByModification.ts

@@ -56,5 +56,5 @@ export const UpdateRelationOrderByModification: ModificationHandlerStatic<Update
 export interface UpdateRelationOrderByModificationData {
 	entityName: string
 	fieldName: string
-	orderBy: Model.OrderBy[]
+	orderBy: readonly Model.OrderBy[]
 }

package/src/modifications/relations/index.ts

@@ -6,5 +6,6 @@ export * from './DisableOrphanRemovalModification'
 export * from './EnableOrphanRemovalModification'
 export * from './MakeRelationNotNullModification'
 export * from './MakeRelationNullableModification'
+export * from './ToggleManyHasManyEventLogModification'
 export * from './UpdateRelationOnDeleteModification'
 export * from './UpdateRelationOrderByModification'

package/src/modifications/relations/normalization.ts

@@ -0,0 +1,21 @@
+import { Model } from '@contember/schema'
+
+type SomePartial<E, K extends keyof E> = Omit<E, K> & Partial<Pick<E, K>>
+
+export type PartialManyHasManyRelation =
+	& Omit<Model.ManyHasManyOwningRelation, 'joiningTable'>
+	& {
+		joiningTable: SomePartial<Model.JoiningTable, 'eventLog'>
+	}
+
+export const normalizeManyHasManyRelation = (rel: PartialManyHasManyRelation): Model.ManyHasManyOwningRelation => {
+	return {
+		...rel,
+		joiningTable: {
+			eventLog: {
+				enabled: true,
+			},
+			...rel.joiningTable,
+		},
+	}
+}

package/src/modifications/utils/createJunctionTable.ts

@@ -36,6 +36,8 @@ export const createJunctionTableSql = (
 			},
 		},
 	)
-	createEventTrigger(builder, systemSchema, relation.joiningTable.tableName, primaryColumns)
-	createEventTrxTrigger(builder, systemSchema, relation.joiningTable.tableName)
+	if (relation.joiningTable.eventLog.enabled) {
+		createEventTrigger(builder, systemSchema, relation.joiningTable.tableName, primaryColumns)
+		createEventTrxTrigger(builder, systemSchema, relation.joiningTable.tableName)
+	}
 }

package/src/modifications/utils/renameConstraintsHelper.ts

@@ -1,4 +1,4 @@
-import { Model } from '@contember/schema'
+import { Model, Writable } from '@contember/schema'
 import { MigrationBuilder } from '@contember/database-migrations'
 import { EntityUpdater } from './schemaUpdateUtils'
 
@@ -20,7 +20,7 @@ export const renameConstraintsSqlBuilder = (
 
 export const renameConstraintSchemaUpdater = (nameGenerator: NameGenerator): EntityUpdater => {
 	return ({ entity }) => {
-		const newConstraints: Model.UniqueConstraints = {}
+		const newConstraints: Writable<Model.UniqueConstraints> = {}
 		for (const constraint of Object.values(entity.unique)) {
 			const newName = nameGenerator(constraint)
 			if (newName === null) {

package/src/modifications/utils/schemaUpdateUtils.ts

@@ -1,4 +1,4 @@
-import { Acl, Model, Schema } from '@contember/schema'
+import { Acl, Model, Schema, Writable } from '@contember/schema'
 import { SchemaUpdateError } from '../exceptions'
 import { isDefined } from '../../utils/isDefined'
 import { isInverseRelation, isOwningRelation, isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
@@ -111,7 +111,7 @@ type EntityOperationHandler = {
 export const updateAclFieldPermissions =
 	(updater: EntityAclFieldPermissionsUpdater): AclEntityPermissionsUpdater =>
 		({ entityPermissions, entityName }) => {
-			const operations: Acl.EntityOperations = {}
+			const operations: Writable<Acl.EntityOperations> = {}
 			const handlers: EntityOperationHandler = {
 				create: value => updater(value, entityName, Acl.Operation.create),
 				update: value => updater(value, entityName, Acl.Operation.update),