@contember/schema-migrations 1.3.0-alpha.2 → 1.3.0-alpha.4

package/src/modifications/ModificationHandlerFactory.ts

@@ -31,6 +31,10 @@ import { patchValidationSchemaModification, updateValidationSchemaModification }
 import { createIndexModification, removeIndexModification } from './indexes'
 import { SchemaWithMeta } from './utils/schemaMeta'
 import { updateSettingsModification } from './settings'
+import { createTriggerModification, removeTriggerModification, updateTriggerModification } from './actions'
+import { createTargetModification } from './actions/CreateTargetModification'
+import { removeTargetModification } from './actions/RemoveTargetModification'
+import { updateTargetModification } from './actions/UpdateTargetModification'
 import { updateEntityOrderByModification } from './entities/UpdateEntityOrderByModification'
 
 
@@ -85,6 +89,12 @@ namespace ModificationHandlerFactory {
 		toggleJunctionEventLogModification,
 		convertOneHasManyToManyHasManyRelationModification,
 		updateEntityOrderByModification,
+		createTriggerModification,
+		updateTriggerModification,
+		removeTriggerModification,
+		createTargetModification,
+		updateTargetModification,
+		removeTargetModification,
 	]
 
 	export const defaultFactoryMap: HandlerMap<any> = Object.fromEntries(handlers.map(it => [it.id, it]))

package/src/modifications/actions/CreateTargetModification.ts

@@ -0,0 +1,46 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Actions, Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class CreateTargetModificationHandler implements ModificationHandler<CreateTargetModificationData> {
+	constructor(private readonly data: CreateTargetModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => ({
+			...schema,
+			actions: {
+				...schema.actions,
+				targets: {
+					...schema.actions.targets,
+					[this.data.target.name]: this.data.target,
+				},
+			},
+		})
+	}
+
+	describe() {
+		return { message: `Create target ${this.data.target.name}` }
+	}
+}
+
+export interface CreateTargetModificationData {
+	target: Actions.AnyTarget
+}
+
+export const createTargetModification = createModificationType({
+	id: 'createTarget',
+	handler: CreateTargetModificationHandler,
+})
+
+export class CreateTargetDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.actions.targets)
+			.filter(([name]) => !originalSchema.actions.targets[name])
+			.map(([, target]) => createTargetModification.createModification({ target }))
+	}
+}

package/src/modifications/actions/CreateTriggerModification.ts

@@ -0,0 +1,46 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Actions, Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class CreateTriggerModificationHandler implements ModificationHandler<CreateTriggerModificationData> {
+	constructor(private readonly data: CreateTriggerModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => ({
+			...schema,
+			actions: {
+				...schema.actions,
+				triggers: {
+					...schema.actions.triggers,
+					[this.data.trigger.name]: this.data.trigger,
+				},
+			},
+		})
+	}
+
+	describe() {
+		return { message: `Create trigger ${this.data.trigger.name}` }
+	}
+}
+
+export interface CreateTriggerModificationData {
+	trigger: Actions.AnyTrigger
+}
+
+export const createTriggerModification = createModificationType({
+	id: 'createTrigger',
+	handler: CreateTriggerModificationHandler,
+})
+
+export class CreateTriggerDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.actions.triggers)
+			.filter(([name]) => !originalSchema.actions.triggers[name])
+			.map(([, trigger]) => createTriggerModification.createModification({ trigger }))
+	}
+}

package/src/modifications/actions/RemoveTargetModification.ts

@@ -0,0 +1,46 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class RemoveTargetModificationHandler implements ModificationHandler<RemoveTargetModificationData> {
+	constructor(private readonly data: RemoveTargetModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			const { [this.data.name]: _, ...targets } = schema.actions.targets
+			return ({
+				...schema,
+				actions: {
+					...schema.actions,
+					targets,
+				},
+			})
+		}
+	}
+
+	describe() {
+		return { message: `Remove target ${this.data.name}` }
+	}
+}
+
+export interface RemoveTargetModificationData {
+	name: string
+}
+
+export const removeTargetModification = createModificationType({
+	id: 'removeTarget',
+	handler: RemoveTargetModificationHandler,
+})
+
+export class RemoveTargetDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(originalSchema.actions.targets)
+			.filter(([name]) => !updatedSchema.actions.targets[name])
+			.map(([name]) => removeTargetModification.createModification({ name }))
+	}
+}

package/src/modifications/actions/RemoveTriggerModification.ts

@@ -0,0 +1,46 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class RemoveTriggerModificationHandler implements ModificationHandler<RemoveTriggerModificationData> {
+	constructor(private readonly data: RemoveTriggerModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			const { [this.data.name]: _, ...triggers } = schema.actions.triggers
+			return ({
+				...schema,
+				actions: {
+					...schema.actions,
+					triggers,
+				},
+			})
+		}
+	}
+
+	describe() {
+		return { message: `Remove trigger ${this.data.name}` }
+	}
+}
+
+export interface RemoveTriggerModificationData {
+	name: string
+}
+
+export const removeTriggerModification = createModificationType({
+	id: 'removeTrigger',
+	handler: RemoveTriggerModificationHandler,
+})
+
+export class RemoveTriggerDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(originalSchema.actions.triggers)
+			.filter(([name]) => !updatedSchema.actions.triggers[name])
+			.map(([name]) => removeTriggerModification.createModification({ name }))
+	}
+}

package/src/modifications/actions/UpdateTargetModification.ts

@@ -0,0 +1,51 @@
+
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Actions, Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import deepEqual from 'fast-deep-equal'
+
+export class UpdateTargetModificationHandler implements ModificationHandler<UpdateTargetModificationData> {
+	constructor(private readonly data: UpdateTargetModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			return ({
+				...schema,
+				actions: {
+					...schema.actions,
+					targets: {
+						...schema.actions.targets,
+						[this.data.name]: this.data.target,
+					},
+				},
+			})
+		}
+	}
+
+	describe() {
+		return { message: `Update target ${this.data.name}` }
+	}
+}
+
+export interface UpdateTargetModificationData {
+	name: string
+	target: Actions.AnyTarget
+}
+
+export const updateTargetModification = createModificationType({
+	id: 'updateTarget',
+	handler: UpdateTargetModificationHandler,
+})
+
+export class UpdateTargetDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.actions.targets)
+			.filter(([name, target]) => originalSchema.actions.targets[name] && !deepEqual(target, originalSchema.actions.targets[name]))
+			.map(([name, target]) => updateTargetModification.createModification({ name, target }))
+	}
+}

package/src/modifications/actions/UpdateTriggerModification.ts

@@ -0,0 +1,49 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Actions, Schema } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import deepEqual from 'fast-deep-equal'
+
+export class UpdateTriggerModificationHandler implements ModificationHandler<UpdateTriggerModificationData> {
+	constructor(private readonly data: UpdateTriggerModificationData) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			return ({
+				...schema,
+				actions: {
+					...schema.actions,
+					triggers: {
+						...schema.actions.triggers,
+						[this.data.trigger.name]: this.data.trigger,
+					},
+				},
+			})
+		}
+	}
+
+	describe() {
+		return { message: `Update trigger ${this.data.trigger.name}` }
+	}
+}
+
+export interface UpdateTriggerModificationData {
+	trigger: Actions.AnyTrigger
+}
+
+export const updateTriggerModification = createModificationType({
+	id: 'updateTrigger',
+	handler: UpdateTriggerModificationHandler,
+})
+
+export class UpdateTriggerDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.entries(updatedSchema.actions.triggers)
+			.filter(([name, trigger]) => originalSchema.actions.triggers[name] && !deepEqual(trigger, originalSchema.actions.triggers[name]))
+			.map(([, trigger]) => updateTriggerModification.createModification({ trigger }))
+	}
+}

package/src/modifications/actions/index.ts

@@ -0,0 +1,3 @@
+export * from './CreateTriggerModification'
+export * from './RemoveTriggerModification'
+export * from './UpdateTriggerModification'