@contember/schema-migrations 1.3.0-alpha.7 → 1.3.0-alpha.8

package/src/modifications/relations/ConvertOneToManyRelationModification.ts

@@ -1,31 +1,25 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
-import {
-	addTakenIndexName,
-	SchemaUpdater,
-	updateEntity,
-	updateField,
-	updateModel,
-	updateSchema,
-} from '../utils/schemaUpdateUtils'
+import { SchemaUpdater, updateEntity, updateField, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
 	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
-import { isOwningRelation, NamingHelper } from '@contember/schema-utils'
+import { isOwningRelation } from '@contember/schema-utils'
 import { updateRelations } from '../utils/diffUtils'
 import { NoopModification } from '../NoopModification'
 import { updateFieldNameModification } from '../fields'
-import { resolveIndexName, SchemaWithMeta } from '../utils/schemaMeta'
+import { wrapIdentifier } from '../../utils/dbHelpers'
 
 export class ConvertOneToManyRelationModificationHandler implements ModificationHandler<ConvertOneToManyRelationModificationData> {
 	private subModification: ModificationHandler<any>
 
 	constructor(
 		private readonly data: ConvertOneToManyRelationModificationData,
-		private readonly schema: SchemaWithMeta,
+		private readonly schema: Schema,
 		private readonly options: ModificationHandlerOptions,
 	) {
 		const { relation } = this.getRelation()
@@ -42,24 +36,30 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 			: new NoopModification()
 	}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, options: ModificationHandlerCreateSqlOptions): void {
 		const { entity, relation } = this.getRelation()
 		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 tableNameId = wrapIdentifier(entity.tableName)
+		const columnNameId = wrapIdentifier(columnName)
+		builder.sql(`CREATE INDEX ON ${tableNameId} (${columnNameId})`)
+
+		const uniqueConstraintNames = options.databaseMetadata.getUniqueConstraintNames({
+			tableName: entity.tableName,
+			columnNames: [relation.joiningColumn.columnName],
 		})
-		const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
-		builder.dropConstraint(entity.tableName, uniqueConstraintName)
-		this.subModification.createSql(builder)
+		for (const name of uniqueConstraintNames) {
+			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
+		}
+		options.invalidateDatabaseMetadata()
+
+		this.subModification.createSql(builder, options)
 	}
 
 	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(
@@ -87,7 +87,6 @@ export class ConvertOneToManyRelationModificationHandler implements Modification
 						),
 					),
 				) : undefined,
-			addTakenIndexName(NamingHelper.createForeignKeyIndexName(entity.tableName, field.joiningColumn.columnName)),
 		)
 	}
 

package/src/modifications/relations/CreateRelationModification.ts

@@ -1,24 +1,11 @@
 import { Model, Schema } from '@contember/schema'
-import {
-	acceptRelationTypeVisitor,
-	isInverseRelation,
-	isOwningRelation,
-	isRelation,
-	NamingHelper,
-} from '@contember/schema-utils'
+import { acceptRelationTypeVisitor, isInverseRelation, isOwningRelation, isRelation } from '@contember/schema-utils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import {
-	addField,
-	addTakenIndexName,
-	SchemaUpdater,
-	updateEntity,
-	updateModel,
-	updateSchema,
-} from '../utils/schemaUpdateUtils'
+import { addField, SchemaUpdater, updateEntity, updateModel, updateSchema } from '../utils/schemaUpdateUtils'
 import {
 	createModificationType,
 	Differ,
-	ModificationHandler,
+	ModificationHandler, ModificationHandlerCreateSqlOptions,
 	ModificationHandlerOptions,
 } from '../ModificationHandler'
 import { isIt } from '../../utils/isIt'
@@ -26,19 +13,23 @@ 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'
 import { addForeignKeyConstraint } from './helpers'
+import { wrapIdentifier } from '../../utils/dbHelpers'
 
 
 export class CreateRelationModificationHandler implements ModificationHandler<CreateRelationModificationData> {
 
 	constructor(
 		private readonly data: CreateRelationModificationData,
-		private readonly schema: SchemaWithMeta,
+		private readonly schema: Schema,
 		private readonly options: ModificationHandlerOptions,
 	) {}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, {
+		databaseMetadata,
+		systemSchema,
+		invalidateDatabaseMetadata,
+	}: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.schema.model.entities[this.data.entityName]
 		if (entity.view) {
 			return
@@ -51,34 +42,34 @@ export class CreateRelationModificationHandler implements ModificationHandler<Cr
 					notNull: !relation.nullable,
 				},
 			})
-			addForeignKeyConstraint({ builder, entity, targetEntity, relation })
+			addForeignKeyConstraint({ builder, entity, targetEntity, relation, databaseMetadata, invalidateDatabaseMetadata })
 		}
 		acceptRelationTypeVisitor(this.schema.model, entity, this.getNormalizedOwningSide(), {
 			visitManyHasOne: ({ relation }) => {
 				createOwningSide(relation)
 				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 tableNameId = wrapIdentifier(entity.tableName)
+				const columnNameId = wrapIdentifier(columnName)
+				builder.sql(`CREATE INDEX ON ${tableNameId} (${columnNameId})`)
+				invalidateDatabaseMetadata()
 			},
 			visitOneHasMany: () => {},
 			visitOneHasOneOwning: ({ relation }) => {
 				createOwningSide(relation)
-				const uniqueConstraintName = NamingHelper.createUniqueConstraintName(entity.name, [relation.name])
-				builder.addConstraint(entity.tableName, uniqueConstraintName, { unique: [relation.joiningColumn.columnName] })
+				const tableNameId = wrapIdentifier(entity.tableName)
+				const columnNameId = wrapIdentifier(relation.joiningColumn.columnName)
+				builder.sql(`ALTER TABLE ${tableNameId} ADD UNIQUE (${columnNameId})`)
+				invalidateDatabaseMetadata()
 			},
 			visitOneHasOneInverse: () => {},
 			visitManyHasManyOwning: ({ relation }) => {
-				createJunctionTableSql(builder, this.options.systemSchema, this.schema, entity, targetEntity, relation)
+				createJunctionTableSql(builder, systemSchema, this.schema, entity, targetEntity, relation)
 			},
 			visitManyHasManyInverse: () => {},
 		})
 	}
 
 	public getSchemaUpdater(): SchemaUpdater {
-		const entity = this.schema.model.entities[this.data.entityName]
 		return updateSchema(
 			updateModel(
 				updateEntity(this.data.entityName, addField(this.getNormalizedOwningSide())),
@@ -86,12 +77,6 @@ export class CreateRelationModificationHandler implements ModificationHandler<Cr
 					? 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/relations/ToggleJunctionEventLogModification.ts

@@ -5,7 +5,7 @@ import {
 	createModificationType,
 	Differ,
 	ModificationHandler,
-	ModificationHandlerOptions,
+	ModificationHandlerCreateSqlOptions,
 } from '../ModificationHandler'
 import {
 	createEventTrigger,
@@ -22,11 +22,10 @@ export class ToggleJunctionEventLogModificationHandler implements ModificationHa
 	constructor(
 		private readonly data: ToggleJunctionEventLogModificationData,
 		private readonly schema: Schema,
-		private readonly options: ModificationHandlerOptions,
 	) {
 	}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, { systemSchema }: ModificationHandlerCreateSqlOptions): void {
 		const entity = this.schema.model.entities[this.data.entityName]
 		const relation = entity.fields[this.data.fieldName]
 		if (!isRelation(relation) || relation.type !== Model.RelationType.ManyHasMany || !isOwningRelation(relation)) {
@@ -38,8 +37,8 @@ export class ToggleJunctionEventLogModificationHandler implements ModificationHa
 				relation.joiningTable.joiningColumn.columnName,
 				relation.joiningTable.inverseJoiningColumn.columnName,
 			]
-			createEventTrigger(builder, this.options.systemSchema, tableName, primaryColumns)
-			createEventTrxTrigger(builder, this.options.systemSchema, tableName)
+			createEventTrigger(builder, systemSchema, tableName, primaryColumns)
+			createEventTrxTrigger(builder, systemSchema, tableName)
 		} else {
 			dropEventTrigger(builder, tableName)
 			dropEventTrxTrigger(builder, tableName)

package/src/modifications/relations/UpdateRelationOnDeleteModification.ts

@@ -1,26 +1,34 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 import { Model, Schema } from '@contember/schema'
 import { SchemaUpdater, updateEntity, updateField, updateModel } from '../utils/schemaUpdateUtils'
-import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+import {
+	createModificationType,
+	Differ,
+	ModificationHandler,
+	ModificationHandlerCreateSqlOptions,
+} 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) {}
+	constructor(
+		private readonly data: UpdateRelationOnDeleteModificationData,
+		private readonly schema: Schema,
+	) {}
 
-	public createSql(builder: MigrationBuilder): void {
+	public createSql(builder: MigrationBuilder, { databaseMetadata, invalidateDatabaseMetadata }: ModificationHandlerCreateSqlOptions): 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 })
+				addForeignKeyConstraint({ builder, entity, targetEntity, relation, recreate: true, databaseMetadata, invalidateDatabaseMetadata })
 			},
 			visitOneHasOneOwning: ({ entity, relation, targetEntity }) => {
-				addForeignKeyConstraint({ builder, entity, targetEntity, relation, recreate: true })
+				addForeignKeyConstraint({ builder, entity, targetEntity, relation, recreate: true, databaseMetadata, invalidateDatabaseMetadata })
 			},
 			visitOneHasMany: () => {},
 			visitOneHasOneInverse: () => {},

package/src/modifications/relations/helpers.ts

@@ -1,34 +1,39 @@
 import { MigrationBuilder } from '@contember/database-migrations'
-import { NamingHelper } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
+import { wrapIdentifier } from '../../utils/dbHelpers'
+import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
-export const addForeignKeyConstraint = ({ builder, entity, relation, targetEntity, recreate = false }: {
+export const addForeignKeyConstraint = ({ builder, entity, relation, targetEntity, recreate = false, databaseMetadata, invalidateDatabaseMetadata }: {
 	recreate?: boolean
 	builder: MigrationBuilder
 	entity: Model.Entity
 	targetEntity: Model.Entity
 	relation: Model.OneHasOneOwningRelation | Model.ManyHasOneRelation
+	databaseMetadata: SchemaDatabaseMetadata
+	invalidateDatabaseMetadata: () => void
 }) => {
-	const fkName = NamingHelper.createForeignKeyName(
-		entity.tableName,
-		relation.joiningColumn.columnName,
-		targetEntity.tableName,
-		targetEntity.primaryColumn,
-	)
 	if (recreate) {
-		builder.dropConstraint(entity.tableName, fkName)
+		const fkNames = databaseMetadata.getForeignKeyConstraintNames(
+			{
+				fromTable: entity.tableName,
+				fromColumn: relation.joiningColumn.columnName,
+				toTable: targetEntity.tableName,
+				toColumn: targetEntity.primaryColumn,
+			},
+		)
+		for (const name of fkNames) {
+			builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
+		}
 	}
-	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,
-	})
+
+	const onDelete = ({
+		[Model.OnDelete.setNull]: 'SET NULL',
+		[Model.OnDelete.cascade]: 'CASCADE',
+		[Model.OnDelete.restrict]: 'NO ACTION',
+	} as const)[relation.joiningColumn.onDelete]
+	builder.sql(`ALTER TABLE ${wrapIdentifier(entity.tableName)}
+		ADD FOREIGN KEY (${wrapIdentifier(relation.joiningColumn.columnName)}) 
+		REFERENCES ${wrapIdentifier(targetEntity.tableName)}(${wrapIdentifier(targetEntity.primaryColumn)}) ON DELETE ${onDelete} DEFERRABLE INITIALLY IMMEDIATE`)
+
+	invalidateDatabaseMetadata()
 }

package/src/modifications/upgrade/RemoveIndexNamesModification.ts

@@ -0,0 +1,46 @@
+import { Schema } from '@contember/schema'
+import { SchemaUpdater, updateEveryEntity, updateModel } from '../utils/schemaUpdateUtils'
+import { createModificationType, Differ, ModificationHandler } from '../ModificationHandler'
+
+export class RemoveIndexNamesModificationHandler implements ModificationHandler<RemoveIndexNamesModificationData>  {
+	constructor() {}
+
+	public createSql(): void {
+	}
+
+	public getSchemaUpdater(): SchemaUpdater {
+		return updateModel(
+			updateEveryEntity(({ entity }) => {
+				return {
+					...entity,
+					indexes: entity.indexes.map(({ name, ...other }) => other),
+					unique: entity.unique.map(({ name, ...other }) => other),
+				}
+			}),
+		)
+	}
+
+	describe() {
+		return { message: `Schema upgrade: remove names of indexes and unique constraints` }
+	}
+}
+
+export const removeIndexNamesModification = createModificationType({
+	id: 'removeIndexNames',
+	handler: RemoveIndexNamesModificationHandler,
+})
+
+
+export type RemoveIndexNamesModificationData = {}
+
+export class RemoveIndexNamesDiffer implements Differ {
+	createDiff(originalSchema: Schema) {
+		const hasNames = !!Object.values(originalSchema.model.entities).find(it => {
+			return it.indexes.find(it => !!it.name) || it.unique.find(it => !!it.name)
+		})
+		if (hasNames) {
+			return [removeIndexNamesModification.createModification({})]
+		}
+		return []
+	}
+}

package/src/modifications/utils/createJunctionTable.ts

@@ -1,13 +1,13 @@
 import { createEventTrigger, createEventTrxTrigger } from './sqlUpdateUtils'
 import { MigrationBuilder } from '@contember/database-migrations'
-import { Model } from '@contember/schema'
+import { Model, Schema } from '@contember/schema'
 import { getPrimaryColumnType } from './getPrimaryColumnType'
-import { resolveIndexName, SchemaWithMeta } from './schemaMeta'
+import { wrapIdentifier } from '../../utils/dbHelpers'
 
 export const createJunctionTableSql = (
 	builder: MigrationBuilder,
 	systemSchema: string,
-	schema: SchemaWithMeta,
+	schema: Schema,
 	entity: Model.Entity,
 	targetEntity: Model.Entity,
 	relation: Model.ManyHasManyOwningRelation,
@@ -33,11 +33,11 @@ export const createJunctionTableSql = (
 			},
 		},
 	)
-	const proposedIndexName = `${relation.joiningTable.tableName}_pkey`
-	const indexName = resolveIndexName(schema, proposedIndexName)
-	builder.addConstraint(relation.joiningTable.tableName, indexName, {
-		primaryKey: primaryColumns,
-	})
+
+	const tableNameId = wrapIdentifier(relation.joiningTable.tableName)
+	const columnNameId = primaryColumns.map(wrapIdentifier)
+	builder.sql(`ALTER TABLE ${tableNameId} ADD PRIMARY KEY (${columnNameId.join(', ')})`)
+
 	if (relation.joiningTable.eventLog.enabled) {
 		createEventTrigger(builder, systemSchema, relation.joiningTable.tableName, primaryColumns)
 		createEventTrxTrigger(builder, systemSchema, relation.joiningTable.tableName)

package/src/modifications/utils/schemaUpdateUtils.ts

@@ -3,10 +3,9 @@ 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: SchemaWithMeta }) => SchemaWithMeta
+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<In extends Model.AnyField, Out extends Model.AnyField> = (args: {
@@ -271,13 +270,13 @@ export const removeField = (entityName: string, fieldName: string, version: numb
 			updateModel(
 				updateEntity(entity.name, ({ entity }) => {
 					const { [field.name]: removed, ...fields } = 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))
+					const indexes = entity.indexes.filter(index => !index.fields.includes(field.name))
+					const unique = entity.unique.filter(index => !index.fields.includes(field.name))
 					return {
 						...entity,
 						fields,
-						indexes: Object.fromEntries(indexes),
-						unique: Object.fromEntries(unique),
+						indexes,
+						unique,
 					}
 				}),
 				isRelation(field) && isInverseRelation(field)
@@ -290,14 +289,3 @@ 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/stringArrayEquals.ts

@@ -0,0 +1,4 @@
+export const stringArrayEquals = (colA: string[], colB: string[]) => {
+	return colA.length === colB.length
+		&& colA.every((it, index) => it === colB[index])
+}

package/src/tsconfig.json

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

package/src/utils/PartialEntity.ts

@@ -2,4 +2,10 @@ import { Model } from '@contember/schema'
 
 type SomePartial<E, K extends keyof E> = Omit<E, K> & Partial<Pick<E, K>>
 
-export type PartialEntity = SomePartial<Model.Entity, 'eventLog' | 'indexes'>
+export type PossibleEntityShapeInMigrations =
+	& Omit<Model.Entity, 'eventLog' | 'indexes' | 'unique'>
+	& {
+		eventLog?: Model.Entity['eventLog']
+		indexes?: (readonly  Model.Index[]) | Readonly<Record<string, Model.Index>>
+		unique: (readonly  Model.UniqueConstraint[]) | Readonly<Record<string, Model.UniqueConstraint>>
+	}

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

@@ -67,7 +67,7 @@ testMigrations('convert one has many to many has many', {
 		"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");
+		ADD 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/convertOneToManyRelation.test.ts

@@ -24,8 +24,8 @@ testMigrations('convert one has one to many has one relation without inverse sid
 		},
 	],
 	sql: SQL`
-		CREATE INDEX "post_image_id_index" ON "post" ("image_id");
-		ALTER TABLE "post" DROP CONSTRAINT "unique_Post_image_a85d6d";
+		CREATE INDEX ON "post" ("image_id");
+		ALTER TABLE "post" DROP CONSTRAINT "uniq_post_image_id";
 	`,
 })
 
@@ -52,8 +52,8 @@ testMigrations('convert one has one to many has one relation with inverse side',
 		},
 	],
 	sql: SQL`
-		CREATE INDEX "post_image_id_index" ON "post" ("image_id");
-		ALTER TABLE "post" DROP CONSTRAINT "unique_Post_image_a85d6d";
-	`,
+	CREATE INDEX ON "post" ("image_id"); 
+	ALTER TABLE "post" DROP CONSTRAINT "uniq_post_image_id";
+`,
 })
 

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

@@ -23,10 +23,10 @@ testMigrations('create index', {
 		{
 			modification: 'createIndex',
 			entityName: 'Article',
-			index: { name: 'idx_Article_title_2dc66a', fields: ['title'] },
+			index: { fields: ['title'] },
 		},
 	],
-	sql: SQL`CREATE INDEX "idx_Article_title_2dc66a" ON "article" ("title");`,
+	sql: SQL`CREATE INDEX ON "article" ("title");`,
 })
 
 
@@ -37,8 +37,8 @@ testMigrations('drop index', {
 		{
 			modification: 'removeIndex',
 			entityName: 'Article',
-			indexName: 'idx_Article_title_2dc66a',
+			fields: ['title'],
 		},
 	],
-	sql: SQL`DROP INDEX "idx_Article_title_2dc66a";`,
+	sql: SQL`DROP INDEX "idx_article_title";`,
 })

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

@@ -31,11 +31,11 @@ testMigrations('create a table (no relations, unique on column)', {
 				primary: 'id',
 				primaryColumn: 'id',
 				tableName: 'author',
-				unique: {},
+				unique: [],
 				eventLog: {
 					enabled: true,
 				},
-				indexes: {},
+				indexes: [],
 			},
 		},
 		{
@@ -74,10 +74,7 @@ testMigrations('create a table (no relations, unique on column)', {
 		{
 			modification: 'createUniqueConstraint',
 			entityName: 'Author',
-			unique: {
-				name: 'unique_Author_email_a3e587',
-				fields: ['email'],
-			},
+			unique: { fields: ['email'] },
 		},
 	],
 	sql: SQL`CREATE TABLE "author" (
@@ -101,7 +98,7 @@ testMigrations('create a table (no relations, unique on column)', {
 	ALTER TABLE "author"
 		ADD "registered_at" date;
 	ALTER TABLE "author"
-		ADD CONSTRAINT "unique_Author_email_a3e587" UNIQUE ("email");`,
+		ADD UNIQUE ("email");`,
 })
 
 namespace ViewEntityUpdatedSchema {
@@ -137,12 +134,12 @@ testMigrations('create a view', {
 				primary: 'id',
 				primaryColumn: 'id',
 				tableName: 'author',
-				unique: {},
+				unique: [],
 				view: { sql: "SELECT null as id, 'John' AS name" },
 				eventLog: {
 					enabled: true,
 				},
-				indexes: {},
+				indexes: [],
 			},
 		},
 	],

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

@@ -30,11 +30,11 @@ testMigrations('create many has many relation (post with categories)', {
 				primary: 'id',
 				primaryColumn: 'id',
 				tableName: 'category',
-				unique: {},
+				unique: [],
 				eventLog: {
 					enabled: true,
 				},
-				indexes: {},
+				indexes: [],
 			},
 		},
 		{
@@ -93,7 +93,7 @@ testMigrations('create many has many relation (post with categories)', {
 		"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");
+		ADD PRIMARY KEY ("post_id", "category_id");
 	CREATE TRIGGER "log_event"
 		AFTER INSERT OR UPDATE OR DELETE
 		ON "post_categories"

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

@@ -32,11 +32,11 @@ testMigrations('create many has one relation (post with author)', {
 				primary: 'id',
 				primaryColumn: 'id',
 				tableName: 'post',
-				unique: {},
+				unique: [],
 				eventLog: {
 					enabled: true,
 				},
-				indexes: {},
+				indexes: [],
 			},
 		},
 		{
@@ -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 CASCADE DEFERRABLE INITIALLY IMMEDIATE;
-	CREATE INDEX "post_author_id_index" ON "post" ("author_id");`,
+		ADD FOREIGN KEY ("author_id") REFERENCES "author"("id") ON DELETE CASCADE DEFERRABLE INITIALLY IMMEDIATE;
+	CREATE INDEX ON "post" ("author_id");`,
 })