@contember/engine-system-api 1.3.0-alpha.7 → 1.3.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-system-api",
-  "version": "1.3.0-alpha.7",
+  "version": "1.3.0-beta.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,25 +10,25 @@
   },
   "scripts": {
     "generate": "gql-gen --config graphql.codegen.yml",
-    "test": "vitest"
+    "test": "vitest --dir ./tests/cases"
   },
   "dependencies": {
-    "@contember/authorization": "^1.3.0-alpha.7",
-    "@contember/database": "^1.3.0-alpha.7",
-    "@contember/database-migrations": "^1.3.0-alpha.7",
-    "@contember/dic": "^1.3.0-alpha.7",
-    "@contember/graphql-utils": "^1.3.0-alpha.7",
-    "@contember/logger": "^1.3.0-alpha.7",
-    "@contember/queryable": "^1.3.0-alpha.7",
-    "@contember/schema": "^1.3.0-alpha.7",
-    "@contember/schema-migrations": "^1.3.0-alpha.7",
-    "@contember/schema-utils": "^1.3.0-alpha.7",
+    "@contember/authorization": "1.3.0-beta.1",
+    "@contember/database": "1.3.0-beta.1",
+    "@contember/database-migrations": "1.3.0-beta.1",
+    "@contember/dic": "1.3.0-beta.1",
+    "@contember/graphql-utils": "1.3.0-beta.1",
+    "@contember/logger": "1.3.0-beta.1",
+    "@contember/queryable": "1.3.0-beta.1",
+    "@contember/schema": "1.3.0-beta.1",
+    "@contember/schema-migrations": "1.3.0-beta.1",
+    "@contember/schema-utils": "1.3.0-beta.1",
     "@graphql-tools/utils": "^8.6.13",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "^1.3.0-alpha.7",
-    "@contember/schema-definition": "^1.3.0-alpha.7",
+    "@contember/engine-api-tester": "1.3.0-beta.1",
+    "@contember/schema-definition": "1.3.0-beta.1",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",
@@ -41,4 +41,4 @@
     "graphql": ">= 14.6.0",
     "pg": "^8.9.0"
   }
-}
+}

package/src/SystemContainer.ts

@@ -11,9 +11,10 @@ import {
 	ExecutedMigrationsResolver,
 	IdentityFetcher,
 	MigrationAlterer,
+	MigrationsDatabaseMetadataResolverStoreFactory,
 	PermissionsFactory,
 	ProjectMigrator,
-	ProjectTruncateExecutor,
+	ProjectTruncateExecutor, SchemaDatabaseMetadataResolver,
 	SchemaVersionBuilder,
 } from './model'
 import { UuidProvider } from './utils'
@@ -79,8 +80,12 @@ export class SystemContainerFactory {
 				new SchemaDiffer(schemaMigrator))
 			.addService('migrationDescriber', ({ modificationHandlerFactory }) =>
 				new MigrationDescriber(modificationHandlerFactory))
-			.addService('projectMigrator', ({ migrationDescriber, schemaVersionBuilder, executedMigrationsResolver }) =>
-				new ProjectMigrator(migrationDescriber, schemaVersionBuilder, executedMigrationsResolver))
+			.addService('databaseMetadataResolver', () =>
+				new SchemaDatabaseMetadataResolver())
+			.addService('migrationsDatabaseMetadataResolverStoreFactory', ({ databaseMetadataResolver }) =>
+				new MigrationsDatabaseMetadataResolverStoreFactory(databaseMetadataResolver))
+			.addService('projectMigrator', ({ migrationDescriber, schemaVersionBuilder, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory }) =>
+				new ProjectMigrator(migrationDescriber, schemaVersionBuilder, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory))
 			.addService('projectTruncateExecutor', () =>
 				new ProjectTruncateExecutor())
 			.addService('migrationAlterer', () =>

package/src/bin/runMigrations.ts

@@ -3,7 +3,11 @@ import { DatabaseContextFactory, emptyVersionedSchema, SchemaVersionBuilder } fr
 import { Connection } from '@contember/database'
 import { createLogger, PrettyPrintLoggerHandler } from '@contember/logger'
 
-;(async () => {
+
+import { SchemaDatabaseMetadataResolver } from '../model/metadata/SchemaDatabaseMetadataResolver'
+import { dummySchemaDatabaseMetadata } from '@contember/schema-utils';
+
+(async () => {
 	const dbConfig = {
 		database: process.env.PGDATABASE as string,
 		host: process.env.PGHOST as string,
@@ -25,6 +29,9 @@ import { createLogger, PrettyPrintLoggerHandler } from '@contember/logger'
 			buildSchema: () => Promise.resolve(emptyVersionedSchema),
 		} as unknown as SchemaVersionBuilder,
 		{},
+		{
+			resolveMetadata: () => Promise.resolve(dummySchemaDatabaseMetadata),
+		} as unknown as SchemaDatabaseMetadataResolver,
 	)
 	// eslint-disable-next-line no-console
 	await migrationsRunner.run(createLogger(new PrettyPrintLoggerHandler(process.stderr)))

package/src/index.ts

@@ -12,6 +12,7 @@ export {
 	LatestTransactionIdByStageQuery,
 	ProjectInitializer,
 	ProjectMigrator,
+	SchemaDatabaseMetadataResolver,
 	SchemaVersionBuilder,
 	Stage,
 	StageBySlugQuery,

package/src/migrations/2022-10-03-110000-table-on-delete.ts

@@ -1,12 +1,14 @@
 import { MigrationArgs, MigrationBuilder } from '@contember/database-migrations'
 import { wrapIdentifier } from '@contember/database'
 import { SystemMigrationArgs } from './types'
-import { acceptFieldVisitor, NamingHelper } from '@contember/schema-utils'
+import { acceptFieldVisitor, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
 	const schema = await args.schemaResolver(args.connection)
-	const stages = (await args.connection.query('SELECT schema FROM stage')).rows
+	const stages = (await args.connection.query<{schema: string}>('SELECT schema FROM stage')).rows
+	const metadataByStage: Record<string, SchemaDatabaseMetadata> = {}
+
 	for (const entity of Object.values(schema.model.entities)) {
 		for (const field of Object.values(entity.fields)) {
 			const result = acceptFieldVisitor<null | {
@@ -36,30 +38,27 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs<Sy
 				continue
 			}
 			for (const stage of stages) {
-				const fkName = NamingHelper.createForeignKeyName(
-					entity.tableName,
-					relation.joiningColumn.columnName,
-					targetEntity.tableName,
-					targetEntity.primaryColumn,
-				)
-				const tableName = { name: entity.tableName, schema: stage.schema }
+				const databaseMetadata = metadataByStage[stage.schema] ??= await args.databaseMetadataResolver(args.connection, stage.schema)
 
-				builder.dropConstraint(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(stage.schema)}.${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
+				}
 
 				const onDelete = ({
 					[Model.OnDelete.setNull]: 'SET NULL',
 					[Model.OnDelete.cascade]: 'CASCADE',
 				} as const)[relation.joiningColumn.onDelete]
 
-				builder.addConstraint(tableName, fkName, {
-					foreignKeys: {
-						columns: relation.joiningColumn.columnName,
-						references: `${wrapIdentifier(stage.schema)}.${wrapIdentifier(targetEntity.tableName)}(${wrapIdentifier(targetEntity.primaryColumn)})`,
-						onDelete: onDelete,
-					},
-					deferrable: true,
-					deferred: false,
-				})
+				builder.sql(`ALTER TABLE ${wrapIdentifier(stage.schema)}.${wrapIdentifier(entity.tableName)}
+					ADD FOREIGN KEY (${wrapIdentifier(relation.joiningColumn.columnName)}) 
+					REFERENCES ${wrapIdentifier(stage.schema)}.${wrapIdentifier(targetEntity.tableName)} (${wrapIdentifier(targetEntity.primaryColumn)}) ON DELETE ${onDelete} DEFERRABLE INITIALLY IMMEDIATE
+				`)
 			}
 		}
 	}

package/src/migrations/runner.ts

@@ -25,6 +25,7 @@ import { ProjectConfig } from '../types'
 import { Logger } from '@contember/logger'
 import { GroupMigrationsResolver } from '@contember/database-migrations'
 import { SnapshotMigrationResolver } from '@contember/database-migrations'
+import { SchemaDatabaseMetadataResolver } from '../model/metadata/SchemaDatabaseMetadataResolver'
 
 const migrations = {
 	'2018-08-04-102200-init': _20180804102200init,
@@ -55,6 +56,7 @@ export class SystemMigrationsRunner {
 		private readonly schema: string,
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 		private readonly migrationGroups: Record<string, MigrationGroup<unknown>>,
+		private readonly databaseMetadataResolver: SchemaDatabaseMetadataResolver,
 	) {
 	}
 	async run(logger: Logger) {
@@ -70,10 +72,14 @@ export class SystemMigrationsRunner {
 				Object.fromEntries(Object.entries(this.migrationGroups).map(([group, it]) => [group, new SnapshotMigrationResolver(it.snapshot, it.migrations, group.replace(/[^-_\w]+/g, '-'))])),
 			)
 			const migrationsRunner = new DbMigrationsRunner(connection, this.schema, migrationResolver)
-
 			await migrationsRunner.migrate(message => logger.warn(message), {
 				project: this.project,
 				schemaResolver,
+				databaseMetadataResolver: (connection: Connection.ConnectionLike, schema: string) => {
+					const dbContextMigrations = this.databaseContextFactory.create(connection)
+					return this.databaseMetadataResolver.resolveMetadata(dbContextMigrations, schema)
+				},
+
 			})
 		})
 		await singleConnection.end()

package/src/migrations/types.ts

@@ -1,8 +1,10 @@
 import { Schema } from '@contember/schema'
 import { ProjectConfig } from '../types'
 import { Connection } from '@contember/database'
+import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 export interface SystemMigrationArgs {
 	schemaResolver: (connection: Connection.ConnectionLike) => Promise<Schema>
+	databaseMetadataResolver: (connection: Connection.ConnectionLike, schema: string) => Promise<SchemaDatabaseMetadata>
 	project: ProjectConfig
 }

package/src/model/index.ts

@@ -5,6 +5,7 @@ export * from './dependencies'
 export * from './dtos'
 export * from './events'
 export * from './helpers'
+export * from './metadata'
 export * from './migrations'
 export * from './queries'
 export * from './stages'

package/src/model/metadata/ResolvedDatabaseMetadata.ts

@@ -0,0 +1,54 @@
+import {
+	ForeignKeyConstraintMetadata,
+	GetForeignKeyConstraintNameArgs,
+	GetIndexNameArgs,
+	GetUniqueConstraintNameArgs,
+	IndexMetadata,
+	SchemaDatabaseMetadata,
+	UniqueConstraintMetadata,
+} from '@contember/schema-utils'
+
+const stringArrayEquals = (colA: string[], colB: string[]) => {
+	return colA.length === colB.length
+		&& colA.every((it, index) => it === colB[index])
+}
+
+export class ResolvedDatabaseMetadata implements SchemaDatabaseMetadata {
+	constructor(
+		private readonly foreignKeys: ForeignKeyConstraintMetadata[],
+		private readonly uniqueConstraints: UniqueConstraintMetadata[],
+		private readonly indexes: IndexMetadata[],
+	) {
+	}
+
+	getUniqueConstraint(tableName: string, constraintName: string): UniqueConstraintMetadata | null {
+		return this.uniqueConstraints.find(it => it.tableName === tableName && it.constraintName === constraintName) ?? null
+	}
+
+	getForeignKeyConstraint(tableName: string, constraintName: string): ForeignKeyConstraintMetadata | null {
+		return this.foreignKeys.find(it => it.fromTable === tableName && it.constraintName === constraintName) ?? null
+	}
+
+	getForeignKeyConstraintNames({ fromTable, fromColumn, toTable, toColumn }: GetForeignKeyConstraintNameArgs): string[] {
+		return this.foreignKeys
+			.filter(it =>
+				it.fromTable === fromTable
+				&& it.toTable === toTable
+				&& it.fromColumn === fromColumn
+				&& it.toColumn === toColumn,
+			)
+			.map(it => it.constraintName)
+	}
+
+	getUniqueConstraintNames({ tableName, columnNames }: GetUniqueConstraintNameArgs): string[] {
+		return this.uniqueConstraints
+			.filter(it => it.tableName === tableName && stringArrayEquals(columnNames, it.columnNames))
+			.map(it => it.constraintName)
+	}
+
+	getIndexNames({ tableName, columnNames }: GetIndexNameArgs): string[] {
+		return this.indexes
+			.filter(it => it.tableName === tableName && stringArrayEquals(columnNames, it.columnNames))
+			.map(it => it.indexName)
+	}
+}

package/src/model/metadata/SchemaDatabaseMetadataResolver.ts

@@ -0,0 +1,136 @@
+import {
+	ForeignKeyConstraintMetadata,
+	IndexMetadata,
+	SchemaDatabaseMetadata,
+	UniqueConstraintMetadata,
+} from '@contember/schema-utils'
+import { DatabaseContext } from '../database'
+import { Connection } from '@contember/database'
+import { ResolvedDatabaseMetadata } from './ResolvedDatabaseMetadata'
+
+export class SchemaDatabaseMetadataResolver {
+	async resolveMetadata(db: DatabaseContext, contentSchema: string): Promise<SchemaDatabaseMetadata> {
+		const constraintRows = await this.fetchConstraints(db.client, contentSchema)
+		const indexRows = await this.fetchIndexes(db.client, contentSchema)
+
+		const fkConstraints = constraintRows
+			.filter((it): it is ForeignKeyConstraintsRow => it.type === ConstraintTypes.foreignKey)
+			.map((it): ForeignKeyConstraintMetadata => ({
+				constraintName: it.constraint_name,
+				fromColumn: it.columns[0],
+				toColumn: it.target_columns[0],
+				fromTable: it.table_name,
+				toTable: it.target_table,
+			}))
+		const uniqueConstraints = constraintRows
+			.filter((it): it is UniqueConstraintsRow => it.type === ConstraintTypes.unique)
+			.map((it): UniqueConstraintMetadata => ({
+				constraintName: it.constraint_name,
+				tableName: it.table_name,
+				columnNames: it.columns,
+			}))
+		const indexes = indexRows
+			.map((it): IndexMetadata => ({
+				indexName: it.index_name,
+				tableName: it.table_name,
+				columnNames: it.columns,
+			}))
+
+		return new ResolvedDatabaseMetadata(
+			fkConstraints,
+			uniqueConstraints,
+			indexes,
+		)
+	}
+
+	private async fetchConstraints(connection: Connection.Queryable, schema: string): Promise<ConstraintsRow[]> {
+		return (await connection.query<ConstraintsRow>(`
+            SELECT
+                MAX(pg_constraint.conname) AS constraint_name,
+                MAX(pg_class.relname) AS table_name,
+                JSONB_AGG(DISTINCT pg_attribute.attname) AS columns,
+                MAX(pg_constraint.contype) AS type,
+                MAX(pg_constraint_table.relname) AS target_table,
+                JSONB_AGG(DISTINCT pg_attribute_target.attname)
+                FILTER ( WHERE pg_attribute_target.attname IS NOT NULL) AS target_columns,
+                BOOL_OR(condeferrable),
+                BOOL_OR(condeferred)
+            FROM pg_constraint
+            JOIN pg_class
+                ON pg_constraint.conrelid = pg_class.oid
+            JOIN pg_namespace
+                ON pg_class.relnamespace = pg_namespace.oid
+            JOIN pg_attribute
+                ON pg_attribute.attrelid = pg_class.oid AND pg_attribute.attnum = ANY (pg_constraint.conkey)
+            LEFT JOIN pg_attribute pg_attribute_target
+                ON pg_constraint.confrelid = pg_attribute_target.attrelid AND
+                   pg_attribute_target.attnum = ANY (pg_constraint.confkey)
+            LEFT JOIN pg_class pg_constraint_table
+                ON pg_constraint_table.oid = pg_constraint.confrelid
+            WHERE pg_namespace.nspname = ?
+              AND pg_constraint.contype = ANY (ARRAY ['f', 'u'])
+            GROUP BY pg_constraint.oid
+		`, [schema]))
+			.rows
+	}
+
+	private async fetchIndexes(connection: Connection.Queryable, schema: string): Promise<IndexRow[]> {
+		return (await connection.query<IndexRow>(`
+            SELECT
+                MAX(idx_class.relname) AS index_name,
+                MAX(table_class.relname) AS table_name,
+                JSONB_AGG(DISTINCT pg_attribute.attname) AS columns
+            FROM pg_index
+            JOIN pg_class AS table_class
+                ON pg_index.indrelid = table_class.oid
+            JOIN pg_class AS idx_class
+                ON pg_index.indexrelid = idx_class.oid
+            JOIN pg_namespace
+                ON table_class.relnamespace = pg_namespace.oid
+            JOIN pg_attribute
+                ON pg_attribute.attrelid = table_class.oid AND pg_attribute.attnum = ANY (pg_index.indkey)
+            WHERE pg_namespace.nspname = ?
+              AND indisprimary = FALSE
+              AND indisunique = FALSE
+            GROUP BY pg_index.indexrelid
+		`, [schema]))
+			.rows
+	}
+}
+
+enum ConstraintTypes {
+	foreignKey = 'f',
+	unique = 'u',
+}
+
+type ConstraintsRow =
+	| ForeignKeyConstraintsRow
+	| UniqueConstraintsRow
+
+type ForeignKeyConstraintsRow = {
+	constraint_name: string
+	table_name: string
+	columns: string[]
+	target_table: string
+	target_columns: string[]
+	type: ConstraintTypes.foreignKey
+	deferrable: boolean
+	deferred: boolean
+}
+type UniqueConstraintsRow = {
+	constraint_name: string
+	table_name: string
+	columns: string[]
+	target_table: null
+	target_columns: null
+	type: ConstraintTypes.unique
+	deferrable: boolean
+	deferred: boolean
+}
+
+type IndexRow = {
+	index_name: string
+	table_name: string
+	columns: string[]
+}
+

package/src/model/metadata/SchemaDatabaseMetadataResolverStore.ts

@@ -0,0 +1,41 @@
+import { SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { SchemaDatabaseMetadataResolver } from './SchemaDatabaseMetadataResolver'
+import { DatabaseContext } from '../database'
+
+export class SchemaDatabaseMetadataResolverStore {
+
+	private cache: Map<string, SchemaDatabaseMetadata> = new Map()
+
+	constructor(
+		private resolver: SchemaDatabaseMetadataResolver,
+		private db: DatabaseContext,
+	) {
+	}
+
+	public async getMetadata(schema: string): Promise<SchemaDatabaseMetadata> {
+		const cached = this.cache.get(schema)
+		if (cached) {
+			return cached
+		}
+
+		const newValue = await this.resolver.resolveMetadata(this.db, schema)
+		this.cache.set(schema, newValue)
+		return newValue
+	}
+
+	public invalidate(schema: string): void {
+		this.cache.delete(schema)
+	}
+}
+
+
+export class MigrationsDatabaseMetadataResolverStoreFactory {
+	constructor(
+		private resolver: SchemaDatabaseMetadataResolver,
+	) {
+	}
+
+	public create(db: DatabaseContext) {
+		return new SchemaDatabaseMetadataResolverStore(this.resolver, db)
+	}
+}

package/src/model/metadata/index.ts

@@ -0,0 +1,3 @@
+export * from './SchemaDatabaseMetadataResolver'
+export * from './SchemaDatabaseMetadataResolverStore'
+export { ResolvedDatabaseMetadata } from './ResolvedDatabaseMetadata'

package/src/model/migrations/ProjectMigrator.ts

@@ -1,4 +1,4 @@
-import { calculateMigrationChecksum, Migration, MigrationDescriber } from '@contember/schema-migrations'
+import { calculateMigrationChecksum, Migration, MigrationDescriber, MigrationVersionHelper } from '@contember/schema-migrations'
 import { Client, QueryError, wrapIdentifier } from '@contember/database'
 import { Schema } from '@contember/schema'
 import { SaveMigrationCommand } from '../commands'
@@ -7,14 +7,19 @@ import { DatabaseContext } from '../database'
 import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
 import { MigrateErrorCode } from '../../schema'
 import { SchemaVersionBuilder } from './SchemaVersionBuilder'
-import { SchemaValidator } from '@contember/schema-utils'
+import { SchemaValidator, SchemaValidatorSkippedErrors } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
+import {
+	SchemaDatabaseMetadataResolverStore,
+	MigrationsDatabaseMetadataResolverStoreFactory,
+} from '../metadata/SchemaDatabaseMetadataResolverStore'
 
 export class ProjectMigrator {
 	constructor(
 		private readonly migrationDescriber: MigrationDescriber,
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 		private readonly executedMigrationsResolver: ExecutedMigrationsResolver,
+		private readonly migrationsDatabaseMetadataResolverStoreFactory: MigrationsDatabaseMetadataResolverStoreFactory,
 	) {}
 
 	public async migrate(
@@ -34,6 +39,8 @@ export class ProjectMigrator {
 
 		const sorted = [...validated].sort((a, b) => a.version.localeCompare(b.version))
 
+		const metadataStore = this.migrationsDatabaseMetadataResolverStoreFactory.create(db)
+
 		for (const migration of sorted) {
 			const formatVersion = migration.formatVersion
 
@@ -46,6 +53,7 @@ export class ProjectMigrator {
 					formatVersion,
 					migration.version,
 					db.client.schema,
+					metadataStore,
 				)
 			}
 			await db.commandBus.execute(new SaveMigrationCommand(migration))
@@ -64,6 +72,7 @@ export class ProjectMigrator {
 	): Promise<readonly Migration[]> {
 		const executedMigrations = await this.executedMigrationsResolver.getMigrations(db)
 		const toExecute = []
+		let skippedErrors: SchemaValidatorSkippedErrors[] = []
 		for (const migration of migrationsToExecute) {
 			const executedMigration = executedMigrations.find(it => it.version === migration.version)
 			if (executedMigration) {
@@ -76,13 +85,17 @@ export class ProjectMigrator {
 			if (migration.version < version && !ignoreOrder) {
 				throw new MustFollowLatestMigrationError(migration.version, `Must follow latest executed migration ${version}`)
 			}
-			const described = await this.migrationDescriber.describeModifications(schema, migration, 'system') // system schema name not important here
+			const described = this.migrationDescriber.describeModifications(schema, migration)
 			if (described.length === 0) {
 				continue
 			}
 			const latestModification = described[described.length - 1]
 			schema = latestModification.schema
-			const errors = SchemaValidator.validate(schema, migration.skippedErrors)
+			skippedErrors = [
+				...skippedErrors.filter(it => it.skipUntil && MigrationVersionHelper.extractVersion(it.skipUntil) >= migration.version),
+				...migration.skippedErrors ?? [],
+			]
+			const errors = SchemaValidator.validate(schema, skippedErrors)
 			if (errors.length > 0) {
 				throw new InvalidSchemaError(
 					migration.version,
@@ -112,13 +125,19 @@ export class ProjectMigrator {
 		formatVersion: number,
 		migrationVersion: string,
 		systemSchema: string,
+		metadataStore: SchemaDatabaseMetadataResolverStore,
 	): Promise<[Schema]> {
 		const {
-			sql,
+			getSql,
 			schema: newSchema,
-			handler,
-		} = await this.migrationDescriber.describeModification(schema, modification, { systemSchema, formatVersion })
+		} = this.migrationDescriber.describeModification(schema, modification, { formatVersion })
 		for (const stage of stages) {
+			const databaseMetadata = await metadataStore.getMetadata(stage.schema)
+			const sql = getSql({
+				systemSchema,
+				databaseMetadata,
+				invalidateDatabaseMetadata: () => metadataStore.invalidate(stage.schema),
+			})
 			await this.executeOnStage(db, stage, sql, migrationVersion)
 		}
 		return [newSchema]

package/tests/cases/migrations/2020-05-06-150000-composed-primary.test.ts

@@ -2,12 +2,14 @@ import migration from '../../../src/migrations/2020-05-06-150000-composed-primar
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { sampleProject } from '@contember/engine-api-tester'
 import { test, assert } from 'vitest'
+import { dummySchemaDatabaseMetadata } from '@contember/schema-utils'
 
 test('many-has-many-primary migration sql', async () => {
 	const builder = createMigrationBuilder()
 	await migration(builder, {
 		connection: undefined as any,
 		schemaResolver: () => Promise.resolve(sampleProject),
+		databaseMetadataResolver: () => Promise.resolve(dummySchemaDatabaseMetadata),
 		project: {
 			slug: 'test',
 			stages: [

package/tests/cases/migrations/2020-06-01-103000-event-trigger-perf.test.ts

@@ -2,6 +2,7 @@ import migration from '../../../src/migrations/2020-06-01-103000-event-trigger-p
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { sampleProject } from '@contember/engine-api-tester'
 import { test, assert } from 'vitest'
+import { dummySchemaDatabaseMetadata } from '@contember/schema-utils'
 
 
 test('event-trigger-performance sql', async () => {
@@ -9,6 +10,7 @@ test('event-trigger-performance sql', async () => {
 	await migration(builder, {
 		connection: undefined as any,
 		schemaResolver: () => Promise.resolve(sampleProject),
+		databaseMetadataResolver: () => Promise.resolve(dummySchemaDatabaseMetadata),
 		project: {
 			slug: 'test',
 			stages: [

package/tests/cases/migrations/2022-10-03-110000-table-on-delete.test.ts

@@ -2,7 +2,7 @@ import migration from '../../../src/migrations/2022-10-03-110000-table-on-delete
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { assert, test } from 'vitest'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { emptySchema } from '@contember/schema-utils'
+import { dummySchemaDatabaseMetadata, emptySchema } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
 import { createConnectionMock } from '@contember/database-tester'
 
@@ -15,6 +15,7 @@ test('table-on-delete test', async () => {
 	}])
 	await migration(builder, {
 		connection: connection,
+		databaseMetadataResolver: () => Promise.resolve(dummySchemaDatabaseMetadata),
 		schemaResolver: () => Promise.resolve(({ ...emptySchema, model: new SchemaBuilder()
 			.entity('Post', entity =>
 				entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
@@ -33,9 +34,11 @@ test('table-on-delete test', async () => {
 	})
 	assert.equal(
 		builder.getSql(),
-		`ALTER TABLE "stage_live"."post" DROP CONSTRAINT "fk_post_author_id_87ef9a";
+		`ALTER TABLE "stage_live"."post" DROP CONSTRAINT "fk_post_author_id_author_id";
 ALTER TABLE "stage_live"."post"
-  ADD CONSTRAINT "fk_post_author_id_87ef9a" FOREIGN KEY ("author_id") REFERENCES "stage_live"."author"("id") ON DELETE SET NULL DEFERRABLE INITIALLY IMMEDIATE;
+					ADD FOREIGN KEY ("author_id") 
+					REFERENCES "stage_live"."author" ("id") ON DELETE SET NULL DEFERRABLE INITIALLY IMMEDIATE
+				;
 `,
 	)
 })