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

package/src/SchemaDiffer.ts

@@ -38,12 +38,17 @@ import {
 	UpdateEnumDiffer,
 	UpdateRelationOnDeleteDiffer,
 	UpdateRelationOrderByDiffer,
+	UpdateEntityOrderByDiffer,
 	UpdateValidationSchemaDiffer,
 	VERSION_LATEST,
 } from './modifications'
 import { ChangeViewNonViewDiffer, RemoveChangedFieldDiffer, RemoveChangedViewDiffer } from './modifications/differs'
 import { CreateIndexDiffer, RemoveIndexDiffer } from './modifications/indexes'
 import { SchemaWithMeta } from './modifications/utils/schemaMeta'
+import { CreateTriggerDiffer, RemoveTriggerDiffer, UpdateTriggerDiffer } from './modifications/actions'
+import { UpdateTargetDiffer } from './modifications/actions/UpdateTargetModification'
+import { CreateTargetDiffer } from './modifications/actions/CreateTargetModification'
+import { RemoveTargetDiffer } from './modifications/actions/RemoveTargetModification'
 import { UpdateSettingsDiffer } from './modifications/settings'
 
 type DiffOptions = { skipRecreateValidation?: boolean; skipInitialSchemaValidation?: boolean }
@@ -101,6 +106,13 @@ export class SchemaDiffer {
 			new RemoveEnumDiffer(),
 			new UpdateAclSchemaDiffer(),
 			new UpdateValidationSchemaDiffer(),
+			new UpdateEntityOrderByDiffer(),
+			new UpdateTargetDiffer(),
+			new CreateTargetDiffer(),
+			new UpdateTriggerDiffer(),
+			new CreateTriggerDiffer(),
+			new RemoveTriggerDiffer(),
+			new RemoveTargetDiffer(),
 		]
 
 		const diffs: Migration.Modification[] = []

package/src/index.ts

@@ -8,4 +8,4 @@ export * from './MigrationCreator'
 export * from './MigrationDescriber'
 export * from './modifications'
 export * from './MigrationFilesManager'
-export * from './MigrationVersionHelper'
+export { MigrationVersionHelper } from '@contember/engine-common'

package/src/modifications/ModificationHandlerFactory.ts

@@ -31,6 +31,11 @@ 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'
 
 
 class ModificationHandlerFactory {
@@ -83,6 +88,13 @@ namespace ModificationHandlerFactory {
 		toggleEventLogModification,
 		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/ModificationVersions.ts

@@ -1,7 +1,8 @@
 export const VERSION_INITIAL = 1
-export const VERSION_LATEST = 3
+export const VERSION_LATEST = 4
 
 export const VERSION_ACL_PATCH = 2
 export const VERSION_UPDATE_CONSTRAINT_NAME = 2
 export const VERSION_REMOVE_RELATION_INVERSE_SIDE = 3
 export const VERSION_REMOVE_REFERENCING_RELATIONS = 3
+export const VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE = 4

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'

package/src/modifications/entities/UpdateEntityNameModification.ts

@@ -13,8 +13,12 @@ import {
 } from '../utils/schemaUpdateUtils'
 import { createModificationType, ModificationHandler, ModificationHandlerOptions } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
-import { VERSION_ACL_PATCH, VERSION_UPDATE_CONSTRAINT_NAME } from '../ModificationVersions'
-import { NamingHelper } from '@contember/schema-utils'
+import {
+	VERSION_ACL_PATCH,
+	VERSION_UPDATE_CONSTRAINT_NAME,
+	VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE,
+} from '../ModificationVersions'
+import { acceptEveryFieldVisitor, NamingHelper } from '@contember/schema-utils'
 import { NoopModification } from '../NoopModification'
 import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../utils/renameConstraintsHelper'
 import { changeValue } from '../utils/valueUtils'
@@ -43,6 +47,23 @@ export class UpdateEntityNameModificationHandler implements ModificationHandler<
 		if (!entity.view && this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
 			renameConstraintsSqlBuilder(builder, entity, this.getNewConstraintName.bind(this))
 		}
+
+		if (this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE) {
+			acceptEveryFieldVisitor(this.schema.model, this.data.entityName, {
+				visitColumn: () => {},
+				visitManyHasManyOwning: () => {},
+				visitManyHasManyInverse: () => {},
+				visitOneHasOneInverse: () => {},
+				visitManyHasOne: () => {},
+				visitOneHasMany: () => {},
+				visitOneHasOneOwning: ({ relation }) => {
+					const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
+					const newUniqueConstraintName = NamingHelper.createUniqueConstraintName(this.data.newEntityName, [relation.name])
+					builder.renameConstraint(entity.tableName, uniqueConstraintName, newUniqueConstraintName)
+				},
+			})
+		}
+
 		this.subModification.createSql(builder)
 	}
 

package/src/modifications/entities/UpdateEntityOrderByModification.ts

@@ -0,0 +1,68 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model, Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import deepEqual from 'fast-deep-equal'
+
+export class UpdateEntityOrderByModificationHandler implements ModificationHandler<UpdateEntityOrderByModificationData> {
+
+	constructor(private readonly data: UpdateEntityOrderByModificationData, private readonly schema: Schema) { }
+
+	public createSql(builder: MigrationBuilder): void { }
+
+	public getSchemaUpdater(): SchemaUpdater {
+		const { entityName, orderBy } = this.data
+		return updateModel(
+			updateEntity(entityName, ({ entity }) => {
+				if (orderBy) {
+					return {
+						...entity,
+						orderBy,
+					}
+				}
+				const { orderBy: _, ...rest } = entity
+				return rest
+			}),
+		)
+	}
+
+	describe() {
+		return { message: `Update order-by of entity ${this.data.entityName}` }
+	}
+}
+
+export interface UpdateEntityOrderByModificationData {
+	entityName: string
+	orderBy?: readonly Model.OrderBy[]
+}
+
+export const updateEntityOrderByModification = createModificationType({
+	id: 'updateEntityOrderBy',
+	handler: UpdateEntityOrderByModificationHandler,
+})
+
+export class UpdateEntityOrderByDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		return Object.values(updatedSchema.model.entities)
+			.flatMap(updatedEntity => {
+				const origEntity = originalSchema.model.entities[updatedEntity.name]
+				if (!origEntity) {
+					return []
+				}
+
+				if (!deepEqual(updatedEntity.orderBy ?? [], origEntity.orderBy ?? [])) {
+					if (updatedEntity.orderBy) {
+						return [updateEntityOrderByModification.createModification({
+							entityName: updatedEntity.name,
+							orderBy: updatedEntity.orderBy,
+						})]
+					}
+					return [updateEntityOrderByModification.createModification({
+						entityName: updatedEntity.name,
+					})]
+				}
+				return []
+			})
+
+	}
+}

package/src/modifications/entities/index.ts

@@ -4,3 +4,4 @@ export * from './RemoveEntityModification'
 export * from './ToggleEventLogModification'
 export * from './UpdateEntityNameModification'
 export * from './UpdateEntityTableNameModification'
+export * from './UpdateEntityOrderByModification'

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -15,7 +15,11 @@ import {
 } from '../utils/schemaUpdateUtils'
 import { createModificationType, ModificationHandler, ModificationHandlerOptions } from '../ModificationHandler'
 import { acceptFieldVisitor, NamingHelper, PredicateDefinitionProcessor } from '@contember/schema-utils'
-import { VERSION_ACL_PATCH, VERSION_UPDATE_CONSTRAINT_NAME } from '../ModificationVersions'
+import {
+	VERSION_ACL_PATCH,
+	VERSION_UPDATE_CONSTRAINT_NAME,
+	VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE,
+} from '../ModificationVersions'
 import { renameConstraintSchemaUpdater, renameConstraintsSqlBuilder } from '../utils/renameConstraintsHelper'
 import { changeValue } from '../utils/valueUtils'
 import { updateColumnNameModification } from '../columns'
@@ -47,6 +51,23 @@ export class UpdateFieldNameModificationHandler implements ModificationHandler<U
 		if (this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME) {
 			renameConstraintsSqlBuilder(builder, entity, this.getNewConstraintName.bind(this))
 		}
+
+		if (this.options.formatVersion >= VERSION_UPDATE_CONSTRAINT_NAME_ONE_HAS_ONE) {
+			acceptFieldVisitor(this.schema.model, this.data.entityName,  this.data.fieldName, {
+				visitColumn: () => {},
+				visitManyHasManyOwning: () => {},
+				visitManyHasManyInverse: () => {},
+				visitOneHasOneInverse: () => {},
+				visitManyHasOne: () => {},
+				visitOneHasMany: () => {},
+				visitOneHasOneOwning: ({ relation }) => {
+					const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
+					const newUniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [this.data.newFieldName])
+					builder.renameConstraint(entity.tableName, uniqueConstraintName, newUniqueConstraintName)
+				},
+			})
+		}
+
 		this.renameColumnSubModification.createSql(builder)
 	}
 

package/src/modifications/relations/CreateRelationModification.ts

@@ -27,6 +27,7 @@ import { getPrimaryColumnType } from '../utils/getPrimaryColumnType'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
 import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
 import { resolveIndexName, SchemaWithMeta } from '../utils/schemaMeta'
+import { addForeignKeyConstraint } from './helpers'
 
 
 export class CreateRelationModificationHandler implements ModificationHandler<CreateRelationModificationData> {
@@ -50,21 +51,7 @@ export class CreateRelationModificationHandler implements ModificationHandler<Cr
 					notNull: !relation.nullable,
 				},
 			})
-			const fkName = NamingHelper.createForeignKeyName(
-				entity.tableName,
-				relation.joiningColumn.columnName,
-				targetEntity.tableName,
-				targetEntity.primaryColumn,
-			)
-			builder.addConstraint(entity.tableName, fkName, {
-				foreignKeys: {
-					columns: relation.joiningColumn.columnName,
-					references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
-					onDelete: 'NO ACTION',
-				},
-				deferrable: true,
-				deferred: false,
-			})
+			addForeignKeyConstraint({ builder, entity, targetEntity, relation })
 		}
 		acceptRelationTypeVisitor(this.schema.model, entity, this.getNormalizedOwningSide(), {
 			visitManyHasOne: ({ relation }) => {

package/src/modifications/relations/UpdateRelationOnDeleteModification.ts

@@ -4,11 +4,30 @@ import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/
 import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
 import { updateRelations } from '../utils/diffUtils'
+import { acceptRelationTypeVisitor } from '@contember/schema-utils'
+import { addForeignKeyConstraint } from './helpers'
 
 export class UpdateRelationOnDeleteModificationHandler implements ModificationHandler<UpdateRelationOnDeleteModificationData> {
 	constructor(private readonly data: UpdateRelationOnDeleteModificationData, private readonly schema: Schema) {}
 
-	public createSql(builder: MigrationBuilder): void {}
+	public createSql(builder: MigrationBuilder): void {
+		const entity = this.schema.model.entities[this.data.entityName]
+		if (entity.view) {
+			return
+		}
+		acceptRelationTypeVisitor(this.schema.model, entity, this.data.fieldName, {
+			visitManyHasOne: ({ entity, relation, targetEntity }) => {
+				addForeignKeyConstraint({ builder, entity, targetEntity, relation, recreate: true })
+			},
+			visitOneHasOneOwning: ({ entity, relation, targetEntity }) => {
+				addForeignKeyConstraint({ builder, entity, targetEntity, relation, recreate: true })
+			},
+			visitOneHasMany: () => {},
+			visitOneHasOneInverse: () => {},
+			visitManyHasManyOwning: () => {},
+			visitManyHasManyInverse: () => {},
+		})
+	}
 
 	public getSchemaUpdater(): SchemaUpdater {
 		const { entityName, fieldName, onDelete } = this.data

package/src/modifications/relations/helpers.ts

@@ -0,0 +1,34 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { NamingHelper } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+
+export const addForeignKeyConstraint = ({ builder, entity, relation, targetEntity, recreate = false }: {
+	recreate?: boolean
+	builder: MigrationBuilder
+	entity: Model.Entity
+	targetEntity: Model.Entity
+	relation: Model.OneHasOneOwningRelation | Model.ManyHasOneRelation
+}) => {
+	const fkName = NamingHelper.createForeignKeyName(
+		entity.tableName,
+		relation.joiningColumn.columnName,
+		targetEntity.tableName,
+		targetEntity.primaryColumn,
+	)
+	if (recreate) {
+		builder.dropConstraint(entity.tableName, fkName)
+	}
+	builder.addConstraint(entity.tableName, fkName, {
+		foreignKeys: {
+			columns: relation.joiningColumn.columnName,
+			references: `"${targetEntity.tableName}"("${targetEntity.primaryColumn}")`,
+			onDelete: ({
+				[Model.OnDelete.setNull]: 'SET NULL',
+				[Model.OnDelete.cascade]: 'CASCADE',
+				[Model.OnDelete.restrict]: 'NO ACTION',
+			} as const)[relation.joiningColumn.onDelete],
+		},
+		deferrable: true,
+		deferred: false,
+	})
+}

package/src/tsconfig.json

@@ -6,17 +6,10 @@
 		"downlevelIteration": true
 	},
 	"references": [
-		{
-			"path": "../../database/src"
-		},
-		{
-			"path": "../../database-migrations/src"
-		},
-		{
-			"path": "../../schema/src"
-		},
-		{
-			"path": "../../schema-utils/src"
-		}
+		{ "path": "../../database/src" },
+		{ "path": "../../database-migrations/src" },
+		{ "path": "../../engine-common/src" },
+		{ "path": "../../schema/src" },
+		{ "path": "../../schema-utils/src" }
 	]
 }

package/tests/cases/integration/createManyHasOne.test.ts

@@ -84,6 +84,6 @@ testMigrations('create many has one relation (post with author)', {
 	ALTER TABLE "post"
 		ADD "author_id" uuid;
 	ALTER TABLE "post"
-		ADD CONSTRAINT "fk_post_author_id_87ef9a" FOREIGN KEY ("author_id") REFERENCES "author"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE;
+		ADD CONSTRAINT "fk_post_author_id_87ef9a" FOREIGN KEY ("author_id") REFERENCES "author"("id") ON DELETE CASCADE DEFERRABLE INITIALLY IMMEDIATE;
 	CREATE INDEX "post_author_id_index" ON "post" ("author_id");`,
 })

package/tests/cases/integration/createRelationInverseSide.test.ts

@@ -56,5 +56,5 @@ testMigrations('create inverse side relation together with changing onDelete beh
 			},
 		},
 	],
-	sql: SQL``,
+	sql: SQL`ALTER TABLE "post_locale" DROP CONSTRAINT "fk_post_locale_post_id_f3d2e5"; ALTER TABLE "post_locale" ADD CONSTRAINT "fk_post_locale_post_id_f3d2e5" FOREIGN KEY ("post_id") REFERENCES "post"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE;`,
 })