@contember/schema-migrations 1.2.0-alpha.8 → 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

@@ -10,114 +10,111 @@ import {
 import { SchemaMigrator } from './SchemaMigrator'
 import { Migration } from './Migration'
 import { ImplementationException } from './exceptions'
-import { VERSION_LATEST } from './modifications/ModificationVersions'
-import { CreateUniqueConstraintModification, RemoveUniqueConstraintModification } from './modifications/constraints'
-import { RemoveFieldModification } from './modifications/fields'
 import {
-	CreateEntityModification,
-	CreateViewModification,
-	RemoveEntityModification,
-	ToggleEventLogModification,
-	UpdateEntityTableNameModification,
-} from './modifications/entities'
-import { CreateEnumModification, RemoveEnumModification, UpdateEnumModification } from './modifications/enums'
-import {
-	CreateColumnModification,
-	UpdateColumnDefinitionModification,
-	UpdateColumnNameModification,
-} from './modifications/columns'
-import {
-	ConvertOneHasManyToManyHasManyRelationModification,
-	ConvertOneToManyRelationModification,
-	CreateRelationInverseSideModification,
-	CreateRelationModification,
-	DisableOrphanRemovalModification,
-	EnableOrphanRemovalModification,
-	MakeRelationNotNullModification,
-	MakeRelationNullableModification,
-	ToggleJunctionEventLogModification,
-	UpdateRelationOnDeleteModification,
-	UpdateRelationOrderByModification,
-} from './modifications/relations'
-import { PatchAclSchemaModification, UpdateAclSchemaModification } from './modifications/acl'
-import { PatchValidationSchemaModification, UpdateValidationSchemaModification } from './modifications/validation'
-import { CreateDiff, Differ } from './modifications/ModificationHandler'
-import { isDefined } from './utils/isDefined'
+	ConvertOneHasManyToManyHasManyRelationDiffer,
+	ConvertOneToManyRelationDiffer,
+	CreateColumnDiffer,
+	CreateEntityDiffer,
+	CreateEnumDiffer,
+	CreateRelationDiffer,
+	CreateRelationInverseSideDiffer,
+	CreateUniqueConstraintDiffer,
+	CreateViewDiffer,
+	Differ,
+	DisableOrphanRemovalDiffer,
+	EnableOrphanRemovalDiffer,
+	MakeRelationNotNullDiffer,
+	MakeRelationNullableDiffer,
+	RemoveEntityDiffer,
+	RemoveEnumDiffer,
+	RemoveFieldDiffer,
+	RemoveUniqueConstraintDiffer,
+	ToggleEventLogDiffer,
+	ToggleJunctionEventLogDiffer,
+	UpdateAclSchemaDiffer,
+	UpdateColumnDefinitionDiffer,
+	UpdateColumnNameDiffer,
+	UpdateEntityTableNameDiffer,
+	UpdateEnumDiffer,
+	UpdateRelationOnDeleteDiffer,
+	UpdateRelationOrderByDiffer,
+	UpdateValidationSchemaDiffer,
+	VERSION_LATEST,
+} from './modifications'
 import { ChangeViewNonViewDiffer, RemoveChangedFieldDiffer, RemoveChangedViewDiffer } from './modifications/differs'
-import { CreateIndexModification, RemoveIndexModification } from './modifications/indexes'
+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) {
 			throw new InvalidSchemaException('updated schema is not valid', updatedErrors)
 		}
 
-		const differs: (CreateDiff | Differ)[] = [
-			ConvertOneToManyRelationModification.createDiff,
-			ConvertOneHasManyToManyHasManyRelationModification.createDiff,
-
-			RemoveUniqueConstraintModification.createDiff,
-			RemoveIndexModification.createDiff,
-			new ChangeViewNonViewDiffer().createDiff,
-			new RemoveChangedViewDiffer().createDiff,
-			RemoveEntityModification.createDiff,
-			RemoveFieldModification.createDiff,
-			CreateEnumModification.createDiff,
-
-			UpdateEntityTableNameModification.createDiff,
-			ToggleEventLogModification.createDiff,
-			ToggleJunctionEventLogModification.createDiff,
-			UpdateColumnDefinitionModification.createDiff,
-			UpdateColumnNameModification.createDiff,
-			UpdateRelationOnDeleteModification.createDiff,
-			MakeRelationNotNullModification.createDiff,
-			MakeRelationNullableModification.createDiff,
-			EnableOrphanRemovalModification.createDiff,
-			DisableOrphanRemovalModification.createDiff,
-			UpdateRelationOrderByModification.createDiff,
-			UpdateEnumModification.createDiff,
-
+		const differs: Differ[] = [
+			new UpdateSettingsDiffer(),
+			new ConvertOneToManyRelationDiffer(),
+			new ConvertOneHasManyToManyHasManyRelationDiffer(),
+			new RemoveUniqueConstraintDiffer(),
+			new RemoveIndexDiffer(),
+			new ChangeViewNonViewDiffer(),
+			new RemoveChangedViewDiffer(),
+			new RemoveEntityDiffer(),
+			new RemoveFieldDiffer(),
+			new CreateEnumDiffer(),
+			new UpdateEntityTableNameDiffer(),
+			new ToggleEventLogDiffer(),
+			new ToggleJunctionEventLogDiffer(),
+			new UpdateColumnDefinitionDiffer(),
+			new UpdateColumnNameDiffer(),
+			new UpdateRelationOnDeleteDiffer(),
+			new MakeRelationNotNullDiffer(),
+			new MakeRelationNullableDiffer(),
+			new EnableOrphanRemovalDiffer(),
+			new DisableOrphanRemovalDiffer(),
+			new UpdateRelationOrderByDiffer(),
+			new UpdateEnumDiffer(),
 			new RemoveChangedFieldDiffer(it => !isRelation(it) || isOwningRelation(it)),
 			new RemoveChangedFieldDiffer(it => isRelation(it) && isInverseRelation(it)),
-			CreateEntityModification.createDiff,
-			CreateColumnModification.createDiff,
-			CreateViewModification.createDiff,
-
-			CreateRelationModification.createDiff,
-			CreateRelationInverseSideModification.createDiff,
-
-			CreateUniqueConstraintModification.createDiff,
-			CreateIndexModification.createDiff,
-
-			RemoveEnumModification.createDiff,
-
-			UpdateAclSchemaModification.createDiff,
-			PatchAclSchemaModification.createDiff,
-
-			UpdateValidationSchemaModification.createDiff,
-			PatchValidationSchemaModification.createDiff,
-		].filter(isDefined)
+			new CreateEntityDiffer(),
+			new CreateColumnDiffer(),
+			new CreateRelationDiffer(),
+			new CreateViewDiffer(),
+			new CreateRelationInverseSideDiffer(),
+			new CreateUniqueConstraintDiffer(),
+			new CreateIndexDiffer(),
+			new RemoveEnumDiffer(),
+			new UpdateAclSchemaDiffer(),
+			new UpdateValidationSchemaDiffer(),
+		]
 
 		const diffs: Migration.Modification[] = []
 		let appliedDiffsSchema = originalSchema
 		for (const differ of differs) {
-			const differDiffs = 'createDiff' in differ
-				? differ.createDiff(appliedDiffsSchema, updatedSchema)
-				: differ(appliedDiffsSchema, updatedSchema)
+			const differDiffs = differ.createDiff(appliedDiffsSchema, updatedSchema)
 			appliedDiffsSchema = this.schemaMigrator.applyModifications(appliedDiffsSchema, differDiffs, VERSION_LATEST)
 			diffs.push(...differDiffs)
 		}
 
 
-		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/ModificationHandlerFactory'
+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/index.ts

@@ -6,10 +6,6 @@ export * from './SchemaMigrator'
 export * from './SchemaDiffer'
 export * from './MigrationCreator'
 export * from './MigrationDescriber'
-export { default as ModificationHandlerFactory } from './modifications/ModificationHandlerFactory'
-export * from './modifications/ModificationVersions'
-export * from './modifications/ModificationHandler'
-export * from './modifications/utils/sqlUpdateUtils'
+export * from './modifications'
 export * from './MigrationFilesManager'
 export * from './MigrationVersionHelper'
-export { SchemaUpdateError } from './modifications/exceptions'

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
@@ -20,21 +21,33 @@ export interface ModificationHandler<Data> {
 	describe(context: ModificationDescriptionContext): ModificationDescription
 }
 
-export type CreateDiff = (originalSchema: Schema, updatedSchema: Schema) => Migration.Modification[]
-
 export interface ModificationHandlerOptions {
 	formatVersion: number
 	systemSchema: string
 }
 
-export interface ModificationHandlerStatic<Data> {
-	id: string
-	createModification: (data: Data) => Migration.Modification<Data>
-	createDiff?: CreateDiff
+export interface ModificationHandlerConstructor<Data> {
+	new(data: Data, schema: SchemaWithMeta, options: ModificationHandlerOptions): ModificationHandler<Data>
+}
 
-	new(data: Data, schema: Schema, options: ModificationHandlerOptions): ModificationHandler<Data>
+export interface Differ<Data = { [field: string]: any }> {
+	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: SchemaWithMeta, options: ModificationHandlerOptions) => ModificationHandler<Data>
 }
 
-export interface Differ {
-	createDiff: CreateDiff
+export const createModificationType = <Data, Id extends string>({ handler, id }: {
+	id: Id
+	handler: ModificationHandlerConstructor<Data>
+}): ModificationType<Id, Data> => {
+	return {
+		id,
+		createModification: data => ({ modification: id, ...data }),
+		createHandler: (data, schema, options) => new handler(data, schema, options),
+	}
 }

package/src/modifications/ModificationHandlerFactory.ts

@@ -1,87 +1,91 @@
 import { Schema } from '@contember/schema'
-import { ModificationHandler, ModificationHandlerOptions, ModificationHandlerStatic } from './ModificationHandler'
-import { CreateColumnModification, UpdateColumnDefinitionModification, UpdateColumnNameModification } from './columns'
-import { PatchValidationSchemaModification, UpdateValidationSchemaModification } from './validation'
-import { PatchAclSchemaModification, UpdateAclSchemaModification } from './acl'
-import { CreateUniqueConstraintModification, RemoveUniqueConstraintModification } from './constraints'
+import { ModificationHandler, ModificationHandlerOptions, ModificationType } from './ModificationHandler'
+import { patchAclSchemaModification, updateAclSchemaModification } from './acl'
+import { createColumnModification, updateColumnDefinitionModification, updateColumnNameModification } from './columns'
+import { createUniqueConstraintModification, removeUniqueConstraintModification } from './constraints'
 import {
-	CreateEntityModification,
-	CreateViewModification,
-	RemoveEntityModification,
-	ToggleEventLogModification,
-	UpdateEntityNameModification,
-	UpdateEntityTableNameModification,
+	createEntityModification, createViewModification,
+	removeEntityModification, toggleEventLogModification,
+	updateEntityNameModification,
+	updateEntityTableNameModification,
 } from './entities'
-import { CreateEnumModification, RemoveEnumModification, UpdateEnumModification } from './enums'
-import { RemoveFieldModification, UpdateFieldNameModification } from './fields'
+import { updateViewModification } from './entities/UpdateViewModification'
 import {
-	ConvertOneHasManyToManyHasManyRelationModification,
-	ConvertOneToManyRelationModification,
-	CreateRelationInverseSideModification,
-	CreateRelationModification,
-	DisableOrphanRemovalModification,
-	EnableOrphanRemovalModification,
-	MakeRelationNotNullModification,
-	MakeRelationNullableModification,
-	ToggleJunctionEventLogModification,
-	UpdateRelationOnDeleteModification,
-	UpdateRelationOrderByModification,
+	createEnumModification,
+	removeEnumModification,
+	updateEnumModification,
+} from './enums'
+import { removeFieldModification, updateFieldNameModification } from './fields'
+import {
+	convertOneHasManyToManyHasManyRelationModification,
+	convertOneToManyRelationModification,
+	createRelationInverseSideModification,
+	createRelationModification, disableOrphanRemovalModification,
+	enableOrphanRemovalModification,
+	makeRelationNotNullModification,
+	makeRelationNullableModification, toggleJunctionEventLogModification,
+	updateRelationOnDeleteModification,
+	updateRelationOrderByModification,
 } from './relations'
-import { UpdateViewModification } from './entities/UpdateViewModification'
-import { CreateIndexModification, RemoveIndexModification } from './indexes'
+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, ModificationHandlerStatic<any>>) {}
+	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}`)
 		}
-		return new this.map[name](data, schema, options)
+		return this.map[name].createHandler(data, schema, options)
 	}
 }
 
 namespace ModificationHandlerFactory {
-	export type HandlerMap<D> = { [modificationName: string]: ModificationHandlerStatic<D> }
+	type HandlerMap<D> = { [modificationName: string]: ModificationType<string, D> }
 
 	const handlers = [
-		UpdateAclSchemaModification,
-		PatchAclSchemaModification,
-		CreateColumnModification,
-		UpdateColumnDefinitionModification,
-		UpdateColumnNameModification,
-		CreateUniqueConstraintModification,
-		RemoveUniqueConstraintModification,
-		CreateIndexModification,
-		RemoveIndexModification,
-		CreateEntityModification,
-		RemoveEntityModification,
-		UpdateEntityNameModification,
-		UpdateEntityTableNameModification,
-		UpdateViewModification,
-		CreateViewModification,
-		CreateEnumModification,
-		RemoveEnumModification,
-		UpdateEnumModification,
-		RemoveFieldModification,
-		UpdateFieldNameModification,
-		CreateRelationInverseSideModification,
-		CreateRelationModification,
-		UpdateRelationOnDeleteModification,
-		UpdateRelationOrderByModification,
-		MakeRelationNotNullModification,
-		MakeRelationNullableModification,
-		EnableOrphanRemovalModification,
-		DisableOrphanRemovalModification,
-		UpdateValidationSchemaModification,
-		PatchValidationSchemaModification,
-		ConvertOneToManyRelationModification,
-		ToggleEventLogModification,
-		ToggleJunctionEventLogModification,
-		ConvertOneHasManyToManyHasManyRelationModification,
+		updateSettingsModification,
+		updateAclSchemaModification,
+		patchAclSchemaModification,
+		createColumnModification,
+		updateColumnDefinitionModification,
+		updateColumnNameModification,
+		createUniqueConstraintModification,
+		removeUniqueConstraintModification,
+		createIndexModification,
+		removeIndexModification,
+		createEntityModification,
+		removeEntityModification,
+		updateEntityNameModification,
+		updateEntityTableNameModification,
+		updateViewModification,
+		createViewModification,
+		createEnumModification,
+		removeEnumModification,
+		updateEnumModification,
+		removeFieldModification,
+		updateFieldNameModification,
+		createRelationInverseSideModification,
+		createRelationModification,
+		updateRelationOnDeleteModification,
+		updateRelationOrderByModification,
+		makeRelationNotNullModification,
+		makeRelationNullableModification,
+		enableOrphanRemovalModification,
+		disableOrphanRemovalModification,
+		updateValidationSchemaModification,
+		patchValidationSchemaModification,
+		convertOneToManyRelationModification,
+		toggleEventLogModification,
+		toggleJunctionEventLogModification,
+		convertOneHasManyToManyHasManyRelationModification,
 	]
 
 	export const defaultFactoryMap: HandlerMap<any> = Object.fromEntries(handlers.map(it => [it.id, it]))
 }
 
-export default ModificationHandlerFactory
+export { ModificationHandlerFactory }

package/src/modifications/acl/PatchAclSchemaModification.ts

@@ -1,12 +1,10 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, ModificationHandler } from '../ModificationHandler'
 import { applyPatch, Operation } from 'rfc6902'
 import deepCopy from '../../utils/deepCopy'
 
-export const PatchAclSchemaModification: ModificationHandlerStatic<PatchAclSchemaModificationData> = class {
-	static id = 'patchAclSchema'
-
+export class PatchAclSchemaModificationHandler implements ModificationHandler<PatchAclSchemaModificationData>{
 	constructor(private readonly data: PatchAclSchemaModificationData) {}
 
 	public createSql(builder: MigrationBuilder): void {}
@@ -29,12 +27,13 @@ export const PatchAclSchemaModification: ModificationHandlerStatic<PatchAclSchem
 	describe() {
 		return { message: 'Update ACL schema' }
 	}
-
-	static createModification(data: PatchAclSchemaModificationData) {
-		return { modification: this.id, ...data }
-	}
 }
 
+export const patchAclSchemaModification = createModificationType({
+	id: 'patchAclSchema',
+	handler: PatchAclSchemaModificationHandler,
+})
+
 export interface PatchAclSchemaModificationData {
 	patch: Operation[]
 }

package/src/modifications/acl/UpdateAclSchemaModification.ts

@@ -1,14 +1,12 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Acl, Schema } from '@contember/schema'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
-import { ModificationHandlerStatic } from '../ModificationHandler'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { createPatch } from 'rfc6902'
-import { PatchAclSchemaModification } from './PatchAclSchemaModification'
-
-export const UpdateAclSchemaModification: ModificationHandlerStatic<UpdateAclSchemaModificationData> = class {
-	public static id = 'updateAclSchema'
+import { patchAclSchemaModification } from './PatchAclSchemaModification'
 
+export class UpdateAclSchemaModificationHandler implements ModificationHandler<UpdateAclSchemaModificationData>{
 	constructor(private readonly data: UpdateAclSchemaModificationData) {}
 
 	public createSql(builder: MigrationBuilder): void {}
@@ -23,23 +21,26 @@ export const UpdateAclSchemaModification: ModificationHandlerStatic<UpdateAclSch
 	describe() {
 		return { message: 'Update ACL schema' }
 	}
+}
 
-	static createModification(data: UpdateAclSchemaModificationData) {
-		return { modification: this.id, ...data }
-	}
+export interface UpdateAclSchemaModificationData {
+	schema: Acl.Schema
+}
 
-	static createDiff(originalSchema: Schema, updatedSchema: Schema) {
+export const updateAclSchemaModification = createModificationType({
+	id: 'updateAclSchema',
+	handler: UpdateAclSchemaModificationHandler,
+})
+
+export class UpdateAclSchemaDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
 		if (deepEqual(originalSchema.acl, updatedSchema.acl)) {
 			return []
 		}
 		const patch = createPatch(originalSchema.acl, updatedSchema.acl)
 		if (patch.length <= 100) {
-			return [PatchAclSchemaModification.createModification({ patch })]
+			return [patchAclSchemaModification.createModification({ patch })]
 		}
-		return [UpdateAclSchemaModification.createModification({ schema: updatedSchema.acl })]
+		return [updateAclSchemaModification.createModification({ schema: updatedSchema.acl })]
 	}
 }
-
-export interface UpdateAclSchemaModificationData {
-	schema: Acl.Schema
-}