@contember/schema-migrations 1.2.0-alpha.9 → 1.2.0-beta.2

package/src/modifications/indexes/CreateIndexModification.ts

@@ -15,13 +15,13 @@ export class CreateIndexModificationHandler implements ModificationHandler<Creat
 		const fields = this.data.index.fields
 		const columns = fields.map(fieldName => {
 			return acceptFieldVisitor(this.schema.model, entity, fieldName, {
-				visitColumn: ({}, column) => {
+				visitColumn: ({ column }) => {
 					return column.columnName
 				},
-				visitManyHasOne: ({}, relation) => {
+				visitManyHasOne: ({ relation }) => {
 					return relation.joiningColumn.columnName
 				},
-				visitOneHasOneOwning: ({}, relation) => {
+				visitOneHasOneOwning: ({ relation }) => {
 					return relation.joiningColumn.columnName
 				},
 				visitOneHasMany: () => {

package/src/modifications/relations/ConvertOneHasManyToManyHasManyRelationModification.ts

@@ -1,25 +1,33 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import {
+	addField,
+	addTakenIndexName,
+	SchemaUpdater,
+	updateEntity,
+	updateModel,
+	updateSchema,
+} from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
 	ModificationHandler,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
-import { isInverseRelation, isOwningRelation } from '@contember/schema-utils'
+import { isInverseRelation, isOwningRelation, NamingHelper } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
 import { wrapIdentifier } from '@contember/database'
 import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
 import { updateFieldNameModification } from '../fields'
+import { SchemaWithMeta } from '../utils/schemaMeta'
 
 export class ConvertOneHasManyToManyHasManyRelationModificationHandler implements ModificationHandler<ConvertOneHasManyToManyHasManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: ConvertOneHasManyToManyHasManyRelationModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		this.subModification = updateFieldNameModification.createHandler(
@@ -38,7 +46,7 @@ export class ConvertOneHasManyToManyHasManyRelationModificationHandler implement
 		const { relation: oldRelation } = this.getRelation()
 		const entity = this.schema.model.entities[this.data.entityName]
 
-		createJunctionTableSql(builder, this.options.systemSchema, entity, targetEntity, normalizeManyHasManyRelation(this.data.owningSide))
+		createJunctionTableSql(builder, this.options.systemSchema, this.schema, entity, targetEntity, normalizeManyHasManyRelation(this.data.owningSide))
 		const joiningTable = this.data.owningSide.joiningTable
 		builder.sql(`
 			INSERT INTO ${wrapIdentifier(joiningTable.tableName)} (
@@ -58,6 +66,7 @@ export class ConvertOneHasManyToManyHasManyRelationModificationHandler implement
 			this.subModification.getSchemaUpdater(),
 			updateModel(updateEntity(entityName, addField(normalizeManyHasManyRelation(this.data.owningSide)))),
 			this.data.inverseSide ? updateModel(updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))) : undefined,
+			addTakenIndexName(NamingHelper.createJunctionTablePrimaryConstraintName(this.data.owningSide.joiningTable.tableName)),
 		)
 	}
 

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -1,6 +1,13 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
+import {
+	addTakenIndexName,
+	SchemaUpdater,
+	updateEntity,
+	updateField,
+	updateModel,
+	updateSchema,
+} from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
@@ -11,13 +18,14 @@ import { isOwningRelation, NamingHelper } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 import { NoopModification } from '../NoopModification'
 import { updateFieldNameModification } from '../fields'
+import { resolveIndexName, SchemaWithMeta } from '../utils/schemaMeta'
 
 export class ConvertOneToManyRelationModificationHandler implements ModificationHandler<ConvertOneToManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: ConvertOneToManyRelationModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		const { relation } = this.getRelation()
@@ -36,7 +44,12 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 
 	public createSql(builder: MigrationBuilder): void {
 		const { entity, relation } = this.getRelation()
-		builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
+		const columnName = relation.joiningColumn.columnName
+		const proposedIndexName = NamingHelper.createForeignKeyIndexName(entity.tableName, columnName)
+		const indexName = resolveIndexName(this.schema, proposedIndexName)
+		builder.addIndex(entity.tableName, columnName, {
+			name: indexName,
+		})
 		const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
 		builder.dropConstraint(entity.tableName, uniqueConstraintName)
 		this.subModification.createSql(builder)
@@ -45,6 +58,8 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 	public getSchemaUpdater(): SchemaUpdater {
 		const { relation } = this.getRelation()
 		const { entityName, fieldName } = this.data
+		const entity = this.schema.model.entities[this.data.entityName]
+		const field = entity.fields[fieldName] as Model.OneHasOneOwningRelation
 		return updateSchema(
 			updateModel(
 				updateEntity(
@@ -72,6 +87,7 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 						),
 					),
 				) : undefined,
+			addTakenIndexName(NamingHelper.createForeignKeyIndexName(entity.tableName, field.joiningColumn.columnName)),
 		)
 	}
 

package/src/modifications/relations/CreateRelationModification.ts

@@ -7,7 +7,14 @@ import {
 	NamingHelper,
 } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { addField, SchemaUpdater, updateEntity, updateModel } from '../utils/schemaUpdateUtils'
+import {
+	addField,
+	addTakenIndexName,
+	SchemaUpdater,
+	updateEntity,
+	updateModel,
+	updateSchema,
+} from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
@@ -19,13 +26,14 @@ import { createFields } from '../utils/diffUtils'
 import { getPrimaryColumnType } from '../utils/getPrimaryColumnType'
 import { createJunctionTableSql } from '../utils/createJunctionTable'
 import { normalizeManyHasManyRelation, PartialManyHasManyRelation } from './normalization'
+import { resolveIndexName, SchemaWithMeta } from '../utils/schemaMeta'
 
 
 export class CreateRelationModificationHandler implements ModificationHandler<CreateRelationModificationData> {
 
 	constructor(
 		private readonly data: CreateRelationModificationData,
-		private readonly schema: Schema,
+		private readonly schema: SchemaWithMeta,
 		private readonly options: ModificationHandlerOptions,
 	) {}
 
@@ -59,29 +67,43 @@ export class CreateRelationModificationHandler implements ModificationHandler<Cr
 			})
 		}
 		acceptRelationTypeVisitor(this.schema.model, entity, this.getNormalizedOwningSide(), {
-			visitManyHasOne: ({}, relation, {}, _) => {
+			visitManyHasOne: ({ relation }) => {
 				createOwningSide(relation)
-				builder.addIndex(entity.tableName, relation.joiningColumn.columnName)
+				const columnName = relation.joiningColumn.columnName
+				const proposedIndexName = NamingHelper.createForeignKeyIndexName(entity.tableName, columnName)
+				const indexName = resolveIndexName(this.schema, proposedIndexName)
+				builder.addIndex(entity.tableName, columnName, {
+					name: indexName,
+				})
 			},
 			visitOneHasMany: () => {},
-			visitOneHasOneOwning: ({}, relation, {}, _) => {
+			visitOneHasOneOwning: ({ relation }) => {
 				createOwningSide(relation)
 				const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
 				builder.addConstraint(entity.tableName, uniqueConstraintName, { unique: [relation.joiningColumn.columnName] })
 			},
 			visitOneHasOneInverse: () => {},
-			visitManyHasManyOwning: ({}, relation, {}, _) => {
-				createJunctionTableSql(builder, this.options.systemSchema,  entity, targetEntity, relation)
+			visitManyHasManyOwning: ({ relation }) => {
+				createJunctionTableSql(builder, this.options.systemSchema, this.schema, entity, targetEntity, relation)
 			},
 			visitManyHasManyInverse: () => {},
 		})
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
-		return updateModel(
-			updateEntity(this.data.entityName, addField(this.getNormalizedOwningSide())),
-			this.data.inverseSide !== undefined
-				? updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))
+		const entity = this.schema.model.entities[this.data.entityName]
+		return updateSchema(
+			updateModel(
+				updateEntity(this.data.entityName, addField(this.getNormalizedOwningSide())),
+				this.data.inverseSide !== undefined
+					? updateEntity(this.data.owningSide.target, addField(this.data.inverseSide))
+					: undefined,
+			),
+			this.data.owningSide.type === Model.RelationType.ManyHasOne
+				? addTakenIndexName(NamingHelper.createForeignKeyIndexName(entity.tableName, this.data.owningSide.joiningColumn.columnName))
+				: undefined,
+			this.data.owningSide.type === Model.RelationType.ManyHasMany && isOwningRelation(this.data.owningSide)
+				? addTakenIndexName(NamingHelper.createJunctionTablePrimaryConstraintName(this.data.owningSide.joiningTable.tableName))
 				: undefined,
 		)
 	}

package/src/modifications/settings/UpdateSettingsModification.ts

@@ -0,0 +1,87 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+import { Schema, Settings } from '@contember/schema'
+import { SchemaUpdater } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import deepEqual from 'fast-deep-equal'
+
+export class UpdateSettingsModificationHandler implements ModificationHandler<UpdateSettingsModificationData> {
+	constructor(
+		private readonly data: UpdateSettingsModificationData,
+	) {
+	}
+
+	public createSql(builder: MigrationBuilder): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return ({ schema }) => {
+			const { [this.data.key]: _, ...settings } = schema.settings
+			if (this.data.op === 'unset') {
+				return {
+					...schema,
+					settings,
+				}
+			}
+			return {
+				...schema,
+				settings: { ...settings, [this.data.key]: this.data.value },
+			}
+		}
+	}
+
+
+	describe() {
+		return { message: `Change settings of ${this.data.key}` }
+	}
+
+}
+
+export const updateSettingsModification = createModificationType({
+	id: 'updateSettings',
+	handler: UpdateSettingsModificationHandler,
+})
+
+export class UpdateSettingsDiffer implements Differ {
+	createDiff(originalSchema: Schema, updatedSchema: Schema) {
+		const allKeys = Array.from(new Set([
+			...Object.keys(originalSchema.settings),
+			...Object.keys(updatedSchema.settings),
+		] as (keyof Settings.Schema)[]))
+
+		return allKeys
+			.filter(key => !deepEqual(originalSchema.settings[key], updatedSchema.settings[key]))
+			.map(key => {
+				const value = updatedSchema.settings[key]
+				if (value === undefined) {
+					return updateSettingsModification.createModification({
+						op: 'unset',
+						key,
+					})
+				}
+				return updateSettingsModification.createModification({
+					op: 'set',
+					key,
+					value,
+				})
+			})
+	}
+}
+
+
+
+export interface SetSettingsModificationData<K extends keyof Settings.Schema = keyof Settings.Schema> {
+	op: 'set'
+	key: K
+	value: Settings.Schema[K]
+}
+
+
+export interface UnsetSettingsModificationData<K extends keyof Settings.Schema = keyof Settings.Schema> {
+	op: 'unset'
+	key: K
+}
+
+
+export type UpdateSettingsModificationData =
+	| SetSettingsModificationData
+	| UnsetSettingsModificationData

package/src/modifications/settings/index.ts

@@ -0,0 +1 @@
+export * from './UpdateSettingsModification'

package/src/modifications/utils/columnUtils.ts

@@ -0,0 +1,5 @@
+import { Model } from '@contember/schema'
+
+export const getColumnSqlType = (column: Pick<Model.AnyColumn, 'type' | 'columnType'>) => column.type === Model.ColumnType.Enum
+	? `"${column.columnType}"`
+	: column.columnType

package/src/modifications/utils/createJunctionTable.ts

@@ -2,10 +2,12 @@ import { createEventTrigger, createEventTrxTrigger } from './sqlUpdateUtils'
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model } from '@contember/schema'
 import { getPrimaryColumnType } from './getPrimaryColumnType'
+import { resolveIndexName, SchemaWithMeta } from './schemaMeta'
 
 export const createJunctionTableSql = (
 	builder: MigrationBuilder,
 	systemSchema: string,
+	schema: SchemaWithMeta,
 	entity: Model.Entity,
 	targetEntity: Model.Entity,
 	relation: Model.ManyHasManyOwningRelation,
@@ -30,12 +32,12 @@ export const createJunctionTableSql = (
 				onDelete: 'CASCADE',
 			},
 		},
-		{
-			constraints: {
-				primaryKey: primaryColumns,
-			},
-		},
 	)
+	const proposedIndexName = `${relation.joiningTable.tableName}_pkey`
+	const indexName = resolveIndexName(schema, proposedIndexName)
+	builder.addConstraint(relation.joiningTable.tableName, indexName, {
+		primaryKey: primaryColumns,
+	})
 	if (relation.joiningTable.eventLog.enabled) {
 		createEventTrigger(builder, systemSchema, relation.joiningTable.tableName, primaryColumns)
 		createEventTrxTrigger(builder, systemSchema, relation.joiningTable.tableName)

package/src/modifications/utils/diffUtils.ts

@@ -4,7 +4,7 @@ import { isColumn, isRelation } from '@contember/schema-utils'
 import { isDefined } from '../../utils/isDefined'
 import deepEqual from 'fast-deep-equal'
 
-export const updateFields = (
+export const updateFields = <Data = { [field: string]: any }>(
 	originalSchema: Schema,
 	updatedSchema: Schema,
 	modificationGenerator: (args: {
@@ -12,8 +12,8 @@ export const updateFields = (
 		updatedEntity: Model.Entity
 		originalField: Model.AnyField
 		updatedField: Model.AnyField
-	}) => Migration.Modification | Migration.Modification[] | undefined,
-): Migration.Modification[] => {
+	}) => Migration.Modification<Data> | Migration.Modification<Data>[] | undefined,
+): Migration.Modification<Data>[] => {
 	return Object.values(updatedSchema.model.entities)
 		.filter(({ name }) => originalSchema.model.entities[name])
 		.flatMap(updatedEntity => {
@@ -43,7 +43,7 @@ export const updateFields = (
 		})
 }
 
-export const updateColumns = (
+export const updateColumns = <Data = { [field: string]: any }>(
 	originalSchema: Schema,
 	updatedSchema: Schema,
 	modificationGenerator: (args: {
@@ -51,8 +51,8 @@ export const updateColumns = (
 		originalColumn: Model.AnyColumn
 		updatedEntity: Model.Entity
 		updatedColumn: Model.AnyColumn
-	}) => Migration.Modification | undefined,
-) => {
+	}) => Migration.Modification<Data> | undefined,
+): Migration.Modification<Data>[] => {
 	return updateFields(
 		originalSchema,
 		updatedSchema,
@@ -70,7 +70,7 @@ export const updateColumns = (
 	)
 }
 
-export const updateRelations = (
+export const updateRelations = <Data = { [field: string]: any }>(
 	originalSchema: Schema,
 	updatedSchema: Schema,
 	modificationGenerator: (args: {
@@ -78,8 +78,8 @@ export const updateRelations = (
 		originalRelation: Model.AnyRelation
 		updatedEntity: Model.Entity
 		updatedRelation: Model.AnyRelation
-	}) => Migration.Modification | undefined,
-) => {
+	}) => Migration.Modification<Data> | undefined,
+): Migration.Modification<Data>[] => {
 	return updateFields(
 		originalSchema,
 		updatedSchema,
@@ -97,15 +97,15 @@ export const updateRelations = (
 	)
 }
 
-export const createFields = (
+export const createFields = <Data = { [field: string]: any }>(
 	originalSchema: Schema,
 	updatedSchema: Schema,
 	modificationGenerator: (args: {
 		originalEntity: Model.Entity
 		updatedEntity: Model.Entity
 		newField: Model.AnyField
-	}) => Migration.Modification | undefined,
-) => {
+	}) => Migration.Modification<Data> | undefined,
+): Migration.Modification<Data>[] => {
 	return Object.values(updatedSchema.model.entities)
 		.filter(({ name }) => originalSchema.model.entities[name])
 		.flatMap(updatedEntity => {

package/src/modifications/utils/schemaMeta.ts

@@ -0,0 +1,18 @@
+import { Schema } from '@contember/schema'
+
+export type SchemaWithMeta =
+	& Schema
+	& {
+		meta?: {
+			takenIndexNames: Record<string, true>
+		}
+	}
+
+export const resolveIndexName = (schema: SchemaWithMeta, indexName: string): string => {
+	for (let i = 0; ; i++) {
+		const name = indexName + (i === 0 ? '' : `${i}`)
+		if (!schema.meta || !(name in schema.meta.takenIndexNames)) {
+			return name
+		}
+	}
+}

package/src/modifications/utils/schemaUpdateUtils.ts

@@ -3,8 +3,10 @@ import { SchemaUpdateError } from '../exceptions'
 import { isDefined } from '../../utils/isDefined'
 import { isInverseRelation, isOwningRelation, isRelation, PredicateDefinitionProcessor } from '@contember/schema-utils'
 import { VERSION_ACL_PATCH, VERSION_REMOVE_RELATION_INVERSE_SIDE } from '../ModificationVersions'
+import { resolveIndexName, SchemaWithMeta } from './schemaMeta'
 
-export type SchemaUpdater = (args: { schema: Schema }) => Schema
+
+export type SchemaUpdater = (args: { schema: SchemaWithMeta }) => SchemaWithMeta
 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<In extends Model.AnyField, Out extends Model.AnyField> = (args: {
@@ -269,7 +271,14 @@ export const removeField = (entityName: string, fieldName: string, version: numb
 			updateModel(
 				updateEntity(entity.name, ({ entity }) => {
 					const { [field.name]: removed, ...fields } = entity.fields
-					return { ...entity, fields }
+					const indexes = Object.entries(entity.indexes).filter(([, index]) => !index.fields.includes(field.name))
+					const unique = Object.entries(entity.unique).filter(([, index]) => !index.fields.includes(field.name))
+					return {
+						...entity,
+						fields,
+						indexes: Object.fromEntries(indexes),
+						unique: Object.fromEntries(unique),
+					}
 				}),
 				isRelation(field) && isInverseRelation(field)
 					? updateEntity(
@@ -281,3 +290,14 @@ export const removeField = (entityName: string, fieldName: string, version: numb
 		)({ schema })
 	}
 }
+
+export const addTakenIndexName = (indexName: string): SchemaUpdater => ({ schema }) => ({
+	...schema,
+	meta: {
+		...schema.meta,
+		takenIndexNames: {
+			...schema.meta?.takenIndexNames,
+			[resolveIndexName(schema, indexName)]: true,
+		},
+	},
+})

package/src/modifications/utils/viewDependencies.ts

@@ -1,8 +1,10 @@
 import { Model } from '@contember/schema'
+import { Migration } from '../../Migration'
+import { removeEntityModification } from '../entities'
 
-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()]))
+type EntityDependantViews = Map<string, Set<Model.Entity>>
+export const getEntityDependantViews = (model: Model.Schema): EntityDependantViews => {
+	const dependants: EntityDependantViews = new Map(Object.values(model.entities).map(it => [it.name, new Set()]))
 	for (const entity of Object.values(model.entities)) {
 		if (!entity.view?.dependencies?.length) {
 			continue
@@ -10,11 +12,32 @@ export const getViewDirectDependants = (model: Model.Schema): ViewDependants =>
 		for (const dependency of entity.view.dependencies) {
 			const entityDependants = dependants.get(dependency)
 			if (!entityDependants) {
-				// not a view
-				continue
+				throw new Error()
 			}
 			entityDependants.add(entity)
 		}
 	}
 	return dependants
 }
+
+export const cascadeRemoveDependantViews = (model: Model.Schema, entities: Model.Entity[]): Migration.Modification[] => {
+	const removed = new Set<string>()
+	const dependants = getEntityDependantViews(model)
+	const modifications: Migration.Modification[] = []
+	const removeCascade = (entity: Model.Entity) => {
+		if (removed.has(entity.name)) {
+			return
+		}
+		removed.add(entity.name)
+		for (const dependant of dependants.get(entity.name) ?? []) {
+			removeCascade(dependant)
+		}
+		if (entity.view) {
+			modifications.push(removeEntityModification.createModification({ entityName: entity.name }))
+		}
+	}
+	for (const entity of entities) {
+		removeCascade(entity)
+	}
+	return modifications
+}

package/src/tsconfig.json

@@ -7,10 +7,10 @@
 	},
 	"references": [
 		{
-			"path": "../../database-migrations/src"
+			"path": "../../database/src"
 		},
 		{
-			"path": "../../engine-common/src"
+			"path": "../../database-migrations/src"
 		},
 		{
 			"path": "../../schema/src"

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

@@ -64,9 +64,10 @@ testMigrations('convert one has many to many has many', {
 	sql: SQL`
 	CREATE TABLE "article_categories" (
 		"article_id" uuid NOT NULL REFERENCES "article"("id") ON DELETE CASCADE,
-		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE, CONSTRAINT
-		"article_categories_pkey" PRIMARY KEY ("article_id", "category_id")
+		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE
 	);
+	ALTER TABLE "article_categories"
+		ADD CONSTRAINT "article_categories_pkey" PRIMARY KEY ("article_id", "category_id");
 
 	CREATE TRIGGER "log_event" AFTER INSERT OR UPDATE OR DELETE
 	    ON "article_categories" FOR EACH ROW

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

@@ -35,3 +35,36 @@ UPDATE "author" SET "name" = $pga$unnamed author$pga$;
 SET CONSTRAINTS ALL IMMEDIATE; SET CONSTRAINTS ALL DEFERRED;
 ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
 })
+
+testMigrations('create a column with copy value', {
+	originalSchema: def.createModel({
+		Author: class Author {
+			email = def.stringColumn().unique()
+		},
+	}),
+	updatedSchema: def.createModel({
+		Author: class Author {
+			name = def.stringColumn().notNull()
+			email = def.stringColumn().unique()
+		},
+	}),
+	diff: [
+		{
+			modification: 'createColumn',
+			entityName: 'Author',
+			field: {
+				columnName: 'name',
+				name: 'name',
+				nullable: false,
+				type: Model.ColumnType.String,
+				columnType: 'text',
+			},
+			copyValue: 'email',
+		},
+	],
+	noDiff: true,
+	sql: SQL`ALTER TABLE "author" ADD "name" text;
+UPDATE "author" SET "name" = "email"::text;
+SET CONSTRAINTS ALL IMMEDIATE; SET CONSTRAINTS ALL DEFERRED;
+ALTER TABLE "author" ALTER "name" SET NOT NULL;`,
+})

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

@@ -90,9 +90,10 @@ testMigrations('create many has many relation (post with categories)', {
 		ADD "title" text;
 	CREATE TABLE "post_categories" (
 		"post_id"     uuid NOT NULL REFERENCES "post"("id") ON DELETE CASCADE,
-		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE,
-		CONSTRAINT "post_categories_pkey" PRIMARY KEY ("post_id", "category_id")
+		"category_id" uuid NOT NULL REFERENCES "category"("id") ON DELETE CASCADE
 	);
+	ALTER TABLE "post_categories"
+		ADD CONSTRAINT "post_categories_pkey" PRIMARY KEY ("post_id", "category_id");
 	CREATE TRIGGER "log_event"
 		AFTER INSERT OR UPDATE OR DELETE
 		ON "post_categories"