@contember/schema-migrations 0.12.0-beta.1 → 1.0.0-alpha.2

package/src/modifications/fields/RemoveFieldModification.ts

@@ -1,30 +1,8 @@
-import {
-	acceptFieldVisitor,
-	isInverseRelation,
-	isOwningRelation,
-	isRelation,
-	NamingHelper,
-	PredicateDefinitionProcessor,
-	tryGetColumnName,
-} from '@contember/schema-utils'
+import { acceptFieldVisitor, isInverseRelation, isRelation, NamingHelper } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Model, Schema } from '@contember/schema'
-import { ContentEvent, EventType } from '@contember/engine-common'
-import {
-	removeField,
-	SchemaUpdater,
-	updateAcl,
-	updateAclEveryEntity,
-	updateAclEveryPredicate,
-	updateAclEveryRole,
-	updateAclFieldPermissions,
-	updateEntity,
-	updateField,
-	updateModel,
-	updateSchema,
-} from '../utils/schemaUpdateUtils'
+import { Schema } from '@contember/schema'
+import { removeField, SchemaUpdater } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
-import { VERSION_ACL_PATCH, VERSION_REMOVE_RELATION_INVERSE_SIDE } from '../ModificationVersions'
 import { isDefined } from '../../utils/isDefined'
 
 export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModificationData> = class {
@@ -64,27 +42,6 @@ export const RemoveFieldModification: ModificationHandlerStatic<RemoveFieldModif
 		return removeField(this.data.entityName, this.data.fieldName, this.formatVersion)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		const entity = this.schema.model.entities[this.data.entityName]
-		const tableName = entity.tableName
-		const columnName = tryGetColumnName(this.schema.model, entity, this.data.fieldName)
-		if (!columnName) {
-			return events
-		}
-		return events.map(it => {
-			if (
-				it.tableName !== tableName ||
-				(it.type !== EventType.create && it.type !== EventType.update) ||
-				!it.values.hasOwnProperty(columnName)
-			) {
-				return it
-			}
-
-			const { [columnName]: value, ...values } = it.values
-			return { ...it, values }
-		})
-	}
-
 	describe() {
 		return { message: `Remove field ${this.data.entityName}.${this.data.fieldName}`, isDestructive: true }
 	}

package/src/modifications/fields/UpdateFieldNameModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Input, Model, Schema, Value } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import {
 	SchemaUpdater,
 	updateAcl,
@@ -158,10 +157,6 @@ export const UpdateFieldNameModification: ModificationHandlerStatic<UpdateFieldN
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	private getNewConstraintName(constraint: Model.UniqueConstraint): string | null {
 		const generatedName = NamingHelper.createUniqueConstraintName(this.data.entityName, constraint.fields)
 		const isGenerated = constraint.name === generatedName

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -0,0 +1,115 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Model, Schema } from '@contember/schema'
+import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import { ModificationHandler, ModificationHandlerStatic } from '../ModificationHandler'
+import { isOwningRelation, NamingHelper } from '@contember/schema-utils'
+import { updateRelations } from '../utils/diffUtils'
+import { UpdateFieldNameModification } from '../fields'
+import { NoopModification } from '../NoopModification'
+
+export const ConvertOneToManyRelationModification: ModificationHandlerStatic<ConvertOneToManyRelationModificationData> = class {
+	static id = 'convertOneToManyRelation'
+	private subModification: ModificationHandler<any>
+
+	constructor(private readonly data: ConvertOneToManyRelationModificationData, private readonly schema: Schema, private readonly formatVersion: number) {
+		const { relation } = this.getRelation()
+		this.subModification = data.newInverseSideFieldName && relation.inversedBy ?
+			new UpdateFieldNameModification(
+				{
+					entityName: relation.target,
+					fieldName: relation.inversedBy,
+					newFieldName: data.newInverseSideFieldName,
+				},
+				schema,
+				formatVersion,
+			)
+			: new NoopModification()
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+		const { entity, relation } = this.getRelation()
+		builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
+		const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
+		builder.dropConstraint(entity.tableName, uniqueConstraintName)
+		this.subModification.createSql(builder)
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		const { relation } = this.getRelation()
+		const { entityName, fieldName } = this.data
+		return updateSchema(
+			updateModel(
+				updateEntity(
+					entityName,
+					updateField<Model.OneHasOneOwningRelation, Model.ManyHasOneRelation>(
+						fieldName,
+						({ field: { type, orphanRemoval, ...field } }) => ({
+							type: Model.RelationType.ManyHasOne,
+							...field,
+						}),
+					),
+				),
+			),
+			this.subModification.getSchemaUpdater(),
+			this.data.newInverseSideFieldName ?
+				updateModel(
+					updateEntity(
+						relation.target,
+						updateField<Model.OneHasOneInverseRelation, Model.OneHasManyRelation>(
+							this.data.newInverseSideFieldName,
+							({ field: { type,  nullable, ...field } }) => ({
+								type: Model.RelationType.OneHasMany,
+								...field,
+							}),
+						),
+					),
+				) : undefined,
+		)
+	}
+
+	describe() {
+		return {
+			message: `Converts OneHasOne relation to ManyHasOne on ${this.data.entityName}.${this.data.fieldName}`,
+		}
+	}
+
+	static createModification(data: ConvertOneToManyRelationModificationData) {
+		return { modification: this.id, ...data }
+	}
+
+	static 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
+			) {
+				const isInverseSideRenamed = originalRelation.inversedBy && updatedRelation.inversedBy && originalRelation.inversedBy !== updatedRelation.inversedBy
+				return ConvertOneToManyRelationModification.createModification({
+					entityName: updatedEntity.name,
+					fieldName: updatedRelation.name,
+					...(isInverseSideRenamed ? {
+						newInverseSideFieldName: updatedRelation.inversedBy,
+					} : {}),
+				})
+			}
+			return undefined
+		})
+	}
+
+	private getRelation() {
+		const entity = this.schema.model.entities[this.data.entityName]
+		const relation = entity.fields[this.data.fieldName]
+		if (relation.type !== Model.RelationType.OneHasOne || !isOwningRelation(relation)) {
+			throw new Error()
+		}
+		return { entity, relation }
+	}
+}
+
+export interface ConvertOneToManyRelationModificationData {
+	entityName: string
+	fieldName: string
+	newInverseSideFieldName?: string
+}

package/src/modifications/relations/CreateRelationInverseSideModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { addField, SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { createFields } from '../utils/diffUtils'
@@ -25,10 +24,6 @@ export const CreateRelationInverseSideModification: ModificationHandlerStatic<Cr
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: `Add relation ${this.data.entityName}.${this.data.relation.name}` }
 	}

package/src/modifications/relations/CreateRelationModification.ts

@@ -7,7 +7,6 @@ import {
 	NamingHelper,
 } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { ContentEvent } from '@contember/engine-common'
 import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { createEventTrigger, createEventTrxTrigger } from '../utils/sqlUpdateUtils'
@@ -30,58 +29,39 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 			return
 		}
 		const targetEntity = this.schema.model.entities[this.data.owningSide.target]
+		const createOwningSide = (relation: Model.OneHasOneOwningRelation | Model.ManyHasOneRelation) => {
+			builder.addColumn(entity.tableName, {
+				[relation.joiningColumn.columnName]: {
+					type: getPrimaryType(targetEntity),
+					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,
+			})
+		}
 		acceptRelationTypeVisitor(this.schema.model, entity, this.data.owningSide, {
 			visitManyHasOne: ({}, relation, {}, _) => {
-				builder.addColumn(entity.tableName, {
-					[relation.joiningColumn.columnName]: {
-						type: getPrimaryType(targetEntity),
-						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,
-				})
+				createOwningSide(relation)
 				builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
 			},
 			visitOneHasMany: () => {},
 			visitOneHasOneOwning: ({}, relation, {}, _) => {
-				builder.addColumn(entity.tableName, {
-					[relation.joiningColumn.columnName]: {
-						type: getPrimaryType(targetEntity),
-						notNull: !relation.nullable,
-					},
-				})
+				createOwningSide(relation)
 				const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
-
 				builder.addConstraint(entity.tableName, uniqueConstraintName, { unique: [relation.joiningColumn.columnName] })
-
-				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,
-				})
 			},
 			visitOneHasOneInverse: () => {},
 			visitManyHasManyOwning: ({}, relation, {}, _) => {
@@ -127,10 +107,6 @@ export const CreateRelationModification: ModificationHandlerStatic<CreateRelatio
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events //todo fill
-	}
-
 	describe({ createdEntities }: { createdEntities: string[] }) {
 		const notNull = isIt<Model.NullableRelation>(this.data.owningSide, 'nullable') && !this.data.owningSide.nullable
 		const failureWarning =

package/src/modifications/relations/DisableOrphanRemovalModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { isOwningRelation } from '@contember/schema-utils'
@@ -23,10 +22,6 @@ export const DisableOrphanRemovalModification: ModificationHandlerStatic<Disable
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return {
 			message: `Disable orphan removal on ${this.data.entityName}.${this.data.fieldName}`,

package/src/modifications/relations/EnableOrphanRemovalModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { isOwningRelation } from '@contember/schema-utils'
@@ -25,10 +24,6 @@ export const EnableOrphanRemovalModification: ModificationHandlerStatic<EnableOr
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return {
 			message: `Enable orphan removal on ${this.data.entityName}.${this.data.fieldName}`,

package/src/modifications/relations/MakeRelationNotNullModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { getEntity, tryGetColumnName } from '@contember/schema-utils'
@@ -38,10 +37,6 @@ export const MakeRelationNotNullModification: ModificationHandlerStatic<MakeRela
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return {
 			message: `Make relation ${this.data.entityName}.${this.data.fieldName} not-nullable`,

package/src/modifications/relations/MakeRelationNullableModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { getEntity, tryGetColumnName } from '@contember/schema-utils'
@@ -38,10 +37,6 @@ export const MakeRelationNullableModification: ModificationHandlerStatic<MakeRel
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return {
 			message: `Make relation ${this.data.entityName}.${this.data.fieldName} nullable`,

package/src/modifications/relations/UpdateRelationOnDeleteModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
@@ -25,10 +24,6 @@ export const UpdateRelationOnDeleteModification: ModificationHandlerStatic<Updat
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: `Change on-delete policy of relation ${this.data.entityName}.${this.data.fieldName}` }
 	}

package/src/modifications/relations/UpdateRelationOrderByModification.ts

@@ -1,6 +1,5 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
@@ -25,10 +24,6 @@ export const UpdateRelationOrderByModification: ModificationHandlerStatic<Update
 		)
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: `Update order-by of relation ${this.data.entityName}.${this.data.fieldName}` }
 	}

package/src/modifications/relations/index.ts

@@ -1,3 +1,4 @@
+export * from './ConvertOneToManyRelationModification'
 export * from './CreateRelationInverseSideModification'
 export * from './CreateRelationModification'
 export * from './DisableOrphanRemovalModification'

package/src/modifications/utils/schemaUpdateUtils.ts

@@ -7,12 +7,12 @@ import { VERSION_ACL_PATCH, VERSION_REMOVE_RELATION_INVERSE_SIDE } from '../Modi
 export type SchemaUpdater = (args: { schema: Schema }) => Schema
 export type ModelUpdater = (args: { schema: Schema; model: Model.Schema }) => Model.Schema
 export type EntityUpdater = (args: { schema: Schema; model: Model.Schema; entity: Model.Entity }) => Model.Entity
-export type FieldUpdater<T extends Model.AnyField> = (args: {
+export type FieldUpdater<In extends Model.AnyField, Out extends Model.AnyField> = (args: {
 	schema: Schema
 	model: Model.Schema
 	entity: Model.Entity
-	field: T
-}) => T | undefined
+	field: In
+}) => Out | undefined
 export type AclUpdater = (args: { schema: Schema; acl: Acl.Schema }) => Acl.Schema
 export type AclRoleUpdater = (args: {
 	schema: Schema
@@ -183,13 +183,13 @@ export const updateEveryEntity =
 		})
 
 export const updateField =
-	<T extends Model.AnyField = Model.AnyField>(name: string, fieldUpdater: FieldUpdater<T>): EntityUpdater =>
+	<In extends Model.AnyField = Model.AnyField, Out extends Model.AnyField = In>(name: string, fieldUpdater: FieldUpdater<In, Out>): EntityUpdater =>
 		args => {
 			const { [name]: field, ...otherFields } = args.entity.fields
 			if (!args.entity.fields[name]) {
 				throw new SchemaUpdateError(`Field ${args.entity.name}::${name} not found`)
 			}
-			const updatedField = fieldUpdater({ ...args, field: args.entity.fields[name] as T })
+			const updatedField = fieldUpdater({ ...args, field: args.entity.fields[name] as In })
 
 			return {
 				...args.entity,
@@ -201,7 +201,7 @@ export const updateField =
 		}
 
 export const updateEveryField =
-	(fieldUpdater: FieldUpdater<Model.AnyField>): EntityUpdater =>
+	(fieldUpdater: FieldUpdater<Model.AnyField, Model.AnyField>): EntityUpdater =>
 		args => ({
 			...args.entity,
 			fields: Object.fromEntries(

package/src/modifications/utils/viewDependencies.ts

@@ -0,0 +1,20 @@
+import { Model } from '@contember/schema'
+
+type ViewDependants = Map<string, Set<Model.Entity>>
+export const getViewDirectDependants = (model: Model.Schema): ViewDependants => {
+	const dependants: ViewDependants = new Map(Object.values(model.entities).filter(it => it.view).map(it => [it.name, new Set()]))
+	for (const entity of Object.values(model.entities)) {
+		if (!entity.view?.dependencies?.length) {
+			continue
+		}
+		for (const dependency of entity.view.dependencies) {
+			const entityDependants = dependants.get(dependency)
+			if (!entityDependants) {
+				// not a view
+				continue
+			}
+			entityDependants.add(entity)
+		}
+	}
+	return dependants
+}

package/src/modifications/validation/PatchValidationSchemaModification.ts

@@ -1,5 +1,4 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import { applyPatch, Operation } from 'rfc6902'
@@ -26,10 +25,6 @@ export const PatchValidationSchemaModification: ModificationHandlerStatic<PatchV
 		}
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: 'Update validation schema' }
 	}

package/src/modifications/validation/UpdateValidationSchemaModification.ts

@@ -1,11 +1,9 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Schema, Validation } from '@contember/schema'
-import { ContentEvent } from '@contember/engine-common'
 import { SchemaUpdater } from '../utils/schemaUpdateUtils'
 import { ModificationHandlerStatic } from '../ModificationHandler'
 import deepEqual from 'fast-deep-equal'
 import { createPatch } from 'rfc6902'
-import { PatchAclSchemaModification } from '../acl'
 import { PatchValidationSchemaModification } from './PatchValidationSchemaModification'
 
 export const UpdateValidationSchemaModification: ModificationHandlerStatic<UpdateValidationSchemaModificationData> = class {
@@ -21,10 +19,6 @@ export const UpdateValidationSchemaModification: ModificationHandlerStatic<Updat
 		})
 	}
 
-	public transformEvents(events: ContentEvent[]): ContentEvent[] {
-		return events
-	}
-
 	describe() {
 		return { message: 'Update validation schema' }
 	}

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

@@ -0,0 +1,59 @@
+import { testMigrations } from '../../src/tests'
+import { SchemaBuilder } from '@contember/schema-definition'
+import { Model } from '@contember/schema'
+import { SQL } from '../../src/tags'
+
+testMigrations('convert one has one to many has one relation without inverse side', {
+	originalSchema: new SchemaBuilder()
+		.entity('Post', entity =>
+			entity.oneHasOne('image', rel => rel.target('Image')),
+		)
+		.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+		.buildSchema(),
+	updatedSchema: new SchemaBuilder()
+		.entity('Post', entity =>
+			entity.manyHasOne('image', rel => rel.target('Image')),
+		)
+		.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+		.buildSchema(),
+	diff: [
+		{
+			modification: 'convertOneToManyRelation',
+			entityName: 'Post',
+			fieldName: 'image',
+		},
+	],
+	sql: SQL`
+		CREATE INDEX "post_image_id_index" ON "post" ("image_id");
+		ALTER TABLE "post" DROP CONSTRAINT "unique_Post_image_a85d6d";
+	`,
+})
+
+
+testMigrations('convert one has one to many has one relation with inverse side', {
+	originalSchema: new SchemaBuilder()
+		.entity('Post', entity =>
+			entity.oneHasOne('image', rel => rel.target('Image').inversedBy('post')),
+		)
+		.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+		.buildSchema(),
+	updatedSchema: new SchemaBuilder()
+		.entity('Post', entity =>
+			entity.manyHasOne('image', rel => rel.target('Image').inversedBy('posts')),
+		)
+		.entity('Image', e => e.column('url', c => c.type(Model.ColumnType.String)))
+		.buildSchema(),
+	diff: [
+		{
+			modification: 'convertOneToManyRelation',
+			entityName: 'Post',
+			fieldName: 'image',
+			newInverseSideFieldName: 'posts',
+		},
+	],
+	sql: SQL`
+		CREATE INDEX "post_image_id_index" ON "post" ("image_id");
+		ALTER TABLE "post" DROP CONSTRAINT "unique_Post_image_a85d6d";
+	`,
+})
+

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

@@ -111,7 +111,7 @@ testMigrations('create a view', {
 	updatedSchema: def.createModel(ViewEntityUpdatedSchema),
 	diff: [
 		{
-			modification: 'createEntity',
+			modification: 'createView',
 			entity: {
 				fields: {
 					id: {
@@ -121,6 +121,13 @@ testMigrations('create a view', {
 						type: Model.ColumnType.Uuid,
 						columnType: 'uuid',
 					},
+					name: {
+						columnName: 'name',
+						name: 'name',
+						nullable: true,
+						type: Model.ColumnType.String,
+						columnType: 'text',
+					},
 				},
 				name: 'Author',
 				primary: 'id',
@@ -130,17 +137,6 @@ testMigrations('create a view', {
 				view: { sql: "SELECT null as id, 'John' AS name" },
 			},
 		},
-		{
-			modification: 'createColumn',
-			entityName: 'Author',
-			field: {
-				columnName: 'name',
-				name: 'name',
-				nullable: true,
-				type: Model.ColumnType.String,
-				columnType: 'text',
-			},
-		},
 	],
 	sql: SQL`CREATE VIEW "author" AS SELECT null as id, 'John' AS name;`,
 })

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

@@ -132,7 +132,8 @@ testMigrations('create one has one relation (site with settings)', {
 	ALTER TABLE "site"
 		ADD "setting_id" uuid;
 	ALTER TABLE "site"
-		ADD CONSTRAINT "unique_Site_setting_8653a0" UNIQUE ("setting_id");
+		ADD CONSTRAINT "fk_site_setting_id_6a4aa6" FOREIGN KEY ("setting_id") REFERENCES "site_setting"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE;
 	ALTER TABLE "site"
-		ADD CONSTRAINT "fk_site_setting_id_6a4aa6" FOREIGN KEY ("setting_id") REFERENCES "site_setting"("id") ON DELETE NO ACTION DEFERRABLE INITIALLY IMMEDIATE;`,
+		ADD CONSTRAINT "unique_Site_setting_8653a0" UNIQUE ("setting_id");
+		`,
 })

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

@@ -22,7 +22,7 @@ testMigrations('remove an entity', {
 			entityName: 'Author',
 		},
 	],
-	sql: SQL`DROP TABLE "author" CASCADE;`,
+	sql: SQL`ALTER TABLE "post" DROP "author_id"; DROP TABLE "author";`,
 })
 
 testMigrations('remove entity with acl', {
@@ -90,7 +90,7 @@ testMigrations('remove entity with acl', {
 			entityName: 'Site',
 		},
 	],
-	sql: SQL`DROP TABLE "site" CASCADE;`,
+	sql: SQL`ALTER TABLE "post" DROP "site_id"; DROP TABLE "site";`,
 })
 
 namespace ViewEntityOriginalSchema {