@contember/engine-system-api 1.3.4 → 1.4.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-system-api",
-  "version": "1.3.4",
+  "version": "1.4.0-alpha.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -13,22 +13,22 @@
     "test": "vitest --dir ./tests/cases"
   },
   "dependencies": {
-    "@contember/authorization": "1.3.4",
-    "@contember/database": "1.3.4",
-    "@contember/database-migrations": "1.3.4",
-    "@contember/dic": "1.3.4",
-    "@contember/graphql-utils": "1.3.4",
-    "@contember/logger": "1.3.4",
-    "@contember/queryable": "1.3.4",
-    "@contember/schema": "1.3.4",
-    "@contember/schema-migrations": "1.3.4",
-    "@contember/schema-utils": "1.3.4",
-    "@graphql-tools/utils": "^8.6.13",
+    "@contember/authorization": "1.4.0-alpha.1",
+    "@contember/database": "1.4.0-alpha.1",
+    "@contember/database-migrations": "1.4.0-alpha.1",
+    "@contember/dic": "1.4.0-alpha.1",
+    "@contember/graphql-utils": "1.4.0-alpha.1",
+    "@contember/logger": "1.4.0-alpha.1",
+    "@contember/queryable": "1.4.0-alpha.1",
+    "@contember/schema": "1.4.0-alpha.1",
+    "@contember/schema-migrations": "1.4.0-alpha.1",
+    "@contember/schema-utils": "1.4.0-alpha.1",
+    "@graphql-tools/utils": "^10.0.7",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "1.3.4",
-    "@contember/schema-definition": "1.3.4",
+    "@contember/engine-api-tester": "1.4.0-alpha.1",
+    "@contember/schema-definition": "1.4.0-alpha.1",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/SystemContainer.ts

@@ -14,7 +14,7 @@ import {
 	MigrationsDatabaseMetadataResolverStoreFactory,
 	PermissionsFactory,
 	ProjectMigrator,
-	ProjectTruncateExecutor, SchemaDatabaseMetadataResolver,
+	ProjectTruncateExecutor,
 	SchemaVersionBuilder,
 } from './model'
 import { UuidProvider } from './utils'
@@ -29,6 +29,7 @@ import {
 	TruncateMutationResolver,
 } from './resolvers'
 import { EventOldValuesResolver } from './resolvers/types'
+import { DatabaseMetadataResolver } from '@contember/database'
 
 export interface SystemContainer {
 	systemResolversFactory: ResolverFactory
@@ -81,7 +82,7 @@ export class SystemContainerFactory {
 			.addService('migrationDescriber', ({ modificationHandlerFactory }) =>
 				new MigrationDescriber(modificationHandlerFactory))
 			.addService('databaseMetadataResolver', () =>
-				new SchemaDatabaseMetadataResolver())
+				new DatabaseMetadataResolver())
 			.addService('migrationsDatabaseMetadataResolverStoreFactory', ({ databaseMetadataResolver }) =>
 				new MigrationsDatabaseMetadataResolverStoreFactory(databaseMetadataResolver))
 			.addService('projectMigrator', ({ migrationDescriber, schemaVersionBuilder, executedMigrationsResolver, migrationsDatabaseMetadataResolverStoreFactory }) =>

package/src/bin/runMigrations.ts

@@ -1,12 +1,9 @@
 import { SystemMigrationsRunner } from '../migrations'
 import { DatabaseContextFactory, emptyVersionedSchema, SchemaVersionBuilder } from '../model'
-import { Connection } from '@contember/database'
+import { Connection, DatabaseMetadataResolver, emptyDatabaseMetadata } from '@contember/database'
 import { createLogger, PrettyPrintLoggerHandler } from '@contember/logger'
 
 
-import { SchemaDatabaseMetadataResolver } from '../model/metadata/SchemaDatabaseMetadataResolver'
-import { dummySchemaDatabaseMetadata } from '@contember/schema-utils';
-
 (async () => {
 	const dbConfig = {
 		database: process.env.PGDATABASE as string,
@@ -15,10 +12,8 @@ import { dummySchemaDatabaseMetadata } from '@contember/schema-utils';
 		user: process.env.PGUSER as string,
 		port: process.env.PGPORT ? Number(process.env.PGPORT) : 5432,
 	}
-	// eslint-disable-next-line no-console
-	const connection = Connection.createSingle(dbConfig, err => console.error(err))
 	const migrationsRunner = new SystemMigrationsRunner(
-		new DatabaseContextFactory('system', connection, {
+		new DatabaseContextFactory('system', {
 			uuid: () => {
 				throw new Error()
 			},
@@ -30,8 +25,8 @@ import { dummySchemaDatabaseMetadata } from '@contember/schema-utils';
 		} as unknown as SchemaVersionBuilder,
 		{},
 		{
-			resolveMetadata: () => Promise.resolve(dummySchemaDatabaseMetadata),
-		} as unknown as SchemaDatabaseMetadataResolver,
+			resolveMetadata: () => Promise.resolve(emptyDatabaseMetadata),
+		} as unknown as DatabaseMetadataResolver,
 	)
 	// eslint-disable-next-line no-console
 	await migrationsRunner.run(createLogger(new PrettyPrintLoggerHandler(process.stderr)))

package/src/index.ts

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

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

@@ -1,13 +1,13 @@
 import { MigrationArgs, MigrationBuilder } from '@contember/database-migrations'
-import { wrapIdentifier } from '@contember/database'
+import { DatabaseMetadata, wrapIdentifier } from '@contember/database'
 import { SystemMigrationArgs } from './types'
-import { acceptFieldVisitor, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { acceptFieldVisitor } 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<{schema: string}>('SELECT schema FROM stage')).rows
-	const metadataByStage: Record<string, SchemaDatabaseMetadata> = {}
+	const metadataByStage: Record<string, DatabaseMetadata> = {}
 
 	for (const entity of Object.values(schema.model.entities)) {
 		for (const field of Object.values(entity.fields)) {
@@ -40,12 +40,12 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs<Sy
 			for (const stage of stages) {
 				const databaseMetadata = metadataByStage[stage.schema] ??= await args.databaseMetadataResolver(args.connection, stage.schema)
 
-				const fkNames = databaseMetadata.getForeignKeyConstraintNames({
+				const fkNames = databaseMetadata.foreignKeys.filter({
 					fromTable: entity.tableName,
 					fromColumn: relation.joiningColumn.columnName,
 					toTable: targetEntity.tableName,
 					toColumn: targetEntity.primaryColumn,
-				})
+				}).getNames()
 				for (const name of fkNames) {
 					builder.sql(`ALTER TABLE ${wrapIdentifier(stage.schema)}.${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
 				}

package/src/migrations/2023-09-11-174000-fix-on-delete.ts

@@ -1,13 +1,13 @@
 import { MigrationArgs, MigrationBuilder } from '@contember/database-migrations'
-import { wrapIdentifier } from '@contember/database'
+import { DatabaseMetadata, ForeignKeyDeleteAction, wrapIdentifier } from '@contember/database'
 import { SystemMigrationArgs } from './types'
-import { acceptFieldVisitor, ForeignKeyDeleteAction, SchemaDatabaseMetadata } from '@contember/schema-utils'
+import { acceptFieldVisitor } 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<{schema: string}>('SELECT schema FROM stage')).rows
-	const metadataByStage: Record<string, SchemaDatabaseMetadata> = {}
+	const metadataByStage: Record<string, DatabaseMetadata> = {}
 
 	for (const entity of Object.values(schema.model.entities)) {
 		for (const field of Object.values(entity.fields)) {
@@ -37,28 +37,25 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs<Sy
 			for (const stage of stages) {
 				const databaseMetadata = metadataByStage[stage.schema] ??= await args.databaseMetadataResolver(args.connection, stage.schema)
 
-				const fkNames = databaseMetadata.getForeignKeyConstraintNames({
+				const fks = databaseMetadata.foreignKeys.filter({
 					fromTable: entity.tableName,
 					fromColumn: relation.joiningColumn.columnName,
 					toTable: targetEntity.tableName,
 					toColumn: targetEntity.primaryColumn,
-				})
+				}).toArray()
 
-				if (fkNames.every(it => {
-					const constraint = databaseMetadata.getForeignKeyConstraint(entity.tableName, it)
-					const dbConstraintFlag = ({
-						[Model.OnDelete.setNull]: ForeignKeyDeleteAction.setnull,
-						[Model.OnDelete.cascade]: ForeignKeyDeleteAction.cascade,
-						[Model.OnDelete.restrict]: ForeignKeyDeleteAction.restrict,
-					} as const)[relation.joiningColumn.onDelete]
+				const dbConstraintFlag = ({
+					[Model.OnDelete.setNull]: ForeignKeyDeleteAction.setnull,
+					[Model.OnDelete.cascade]: ForeignKeyDeleteAction.cascade,
+					[Model.OnDelete.restrict]: ForeignKeyDeleteAction.restrict,
+				} as const)[relation.joiningColumn.onDelete]
 
-					return constraint && constraint.deleteAction === dbConstraintFlag
-				})) {
+				if (fks.every(it => it.deleteAction === dbConstraintFlag)) {
 					continue
 				}
 
-				for (const name of fkNames) {
-					builder.sql(`ALTER TABLE ${wrapIdentifier(stage.schema)}.${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(name)}`)
+				for (const fk of fks) {
+					builder.sql(`ALTER TABLE ${wrapIdentifier(stage.schema)}.${wrapIdentifier(entity.tableName)} DROP CONSTRAINT ${wrapIdentifier(fk.constraintName)}`)
 				}
 
 				const onDelete = ({

package/src/migrations/2023-10-19-173000-fix-unique.ts

@@ -1,13 +1,12 @@
 import { MigrationArgs, MigrationBuilder } from '@contember/database-migrations'
-import { wrapIdentifier } from '@contember/database'
+import { DatabaseMetadata, wrapIdentifier } from '@contember/database'
 import { SystemMigrationArgs } from './types'
-import { acceptEveryFieldVisitor, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import { getUniqueConstraintColumns } from '@contember/schema-migrations'
 
 export default async function (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) {
 	const schema = await args.schemaResolver(args.connection)
 	const stages = (await args.connection.query<{schema: string}>('SELECT schema FROM stage')).rows
-	const metadataByStage: Record<string, SchemaDatabaseMetadata> = {}
+	const metadataByStage: Record<string, DatabaseMetadata> = {}
 
 	for (const entity of Object.values(schema.model.entities)) {
 		if (entity.view) {
@@ -29,7 +28,7 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs<Sy
 		for (const stage of stages) {
 			const databaseMetadata = metadataByStage[stage.schema] ??= await args.databaseMetadataResolver(args.connection, stage.schema)
 
-			const existingUniqueConstraints = databaseMetadata.getAllUniqueConstraints().filter(it => it.tableName === entity.tableName)
+			const existingUniqueConstraints = databaseMetadata.uniqueConstraints.filter({ tableName: entity.tableName }).toArray()
 			for (const constraint of existingUniqueConstraints) {
 				if (constraint.columnNames.length === 1 || expectedUnique.some(it => stringArrayEquals(it, constraint.columnNames))) {
 					continue

package/src/migrations/runner.ts

@@ -21,13 +21,12 @@ import _20230911174000fixondelete from './2023-09-11-174000-fix-on-delete'
 import _20231019173000fixunique from './2023-10-19-173000-fix-unique'
 import snapshot from './snapshot'
 
-import { Client, Connection, createDatabaseIfNotExists, DatabaseConfig } from '@contember/database'
+import { Client, Connection, createDatabaseIfNotExists, DatabaseConfig, DatabaseMetadataResolver } from '@contember/database'
 import { DatabaseContextFactory, SchemaVersionBuilder } from '../model'
 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,
@@ -60,7 +59,7 @@ export class SystemMigrationsRunner {
 		private readonly schema: string,
 		private readonly schemaVersionBuilder: SchemaVersionBuilder,
 		private readonly migrationGroups: Record<string, MigrationGroup<unknown>>,
-		private readonly databaseMetadataResolver: SchemaDatabaseMetadataResolver,
+		private readonly databaseMetadataResolver: DatabaseMetadataResolver,
 	) {
 	}
 	async run(logger: Logger) {
@@ -91,7 +90,7 @@ export class SystemMigrationsRunner {
 				schemaResolver,
 				databaseMetadataResolver: (connection: Connection.ConnectionLike, schema: string) => {
 					const dbContextMigrations = this.databaseContextFactory.create(connection)
-					return this.databaseMetadataResolver.resolveMetadata(dbContextMigrations, schema)
+					return this.databaseMetadataResolver.resolveMetadata(dbContextMigrations.client, schema)
 				},
 
 			})

package/src/migrations/types.ts

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

package/src/model/ProjectInitializer.ts

@@ -1,6 +1,6 @@
 import { ProjectConfig } from '../types'
 import { StageCreator } from './stages'
-import { DatabaseContext, DatabaseContextFactory } from './database'
+import { DatabaseContext } from './database'
 import { Connection, retryTransaction } from '@contember/database'
 import { FingerCrossedLoggerHandler, Logger } from '@contember/logger'
 import { SystemMigrationsRunner } from '../migrations'
@@ -9,7 +9,7 @@ export class ProjectInitializer {
 	constructor(
 		private readonly stageCreator: StageCreator,
 		private readonly migrationsRunner: SystemMigrationsRunner,
-		private readonly databaseContextFactory: DatabaseContextFactory,
+		private readonly databaseContext: DatabaseContext,
 		private readonly project: ProjectConfig,
 	) {}
 
@@ -17,7 +17,7 @@ export class ProjectInitializer {
 		return await logger.scope(async initLogger => {
 			initLogger.debug('Executing system schema migrations')
 			await this.migrationsRunner.run(initLogger)
-			const dbContext = this.databaseContextFactory.create()
+			const dbContext = this.databaseContext
 			await retryTransaction(
 				() => dbContext.transaction(async trx => {
 					await this.initStages(trx, logger)

package/src/model/database/DatabaseContext.ts

@@ -15,12 +15,11 @@ export interface DatabaseContext<ConnectionType extends Connection.ConnectionLik
 export class DatabaseContextFactory {
 	constructor(
 		public readonly schemaName: string,
-		private readonly connection: Connection,
 		private readonly providers: UuidProvider,
 	) {}
 
-	public create(connection?: Connection.ConnectionLike): DatabaseContext {
-		const client = new Client(connection ?? this.connection, this.schemaName, { module: 'system' })
+	public create(connection: Connection.ConnectionLike): DatabaseContext {
+		const client = new Client(connection, this.schemaName, { module: 'system' })
 		return createDatabaseContext(client, this.providers)
 	}
 }

package/src/model/metadata/SchemaDatabaseMetadataResolverStore.ts

@@ -1,24 +1,23 @@
-import { SchemaDatabaseMetadata } from '@contember/schema-utils'
-import { SchemaDatabaseMetadataResolver } from './SchemaDatabaseMetadataResolver'
 import { DatabaseContext } from '../database'
+import { DatabaseMetadata, DatabaseMetadataResolver } from '@contember/database'
 
 export class SchemaDatabaseMetadataResolverStore {
 
-	private cache: Map<string, SchemaDatabaseMetadata> = new Map()
+	private cache: Map<string, DatabaseMetadata> = new Map()
 
 	constructor(
-		private resolver: SchemaDatabaseMetadataResolver,
+		private resolver: DatabaseMetadataResolver,
 		private db: DatabaseContext,
 	) {
 	}
 
-	public async getMetadata(schema: string): Promise<SchemaDatabaseMetadata> {
+	public async getMetadata(schema: string): Promise<DatabaseMetadata> {
 		const cached = this.cache.get(schema)
 		if (cached) {
 			return cached
 		}
 
-		const newValue = await this.resolver.resolveMetadata(this.db, schema)
+		const newValue = await this.resolver.resolveMetadata(this.db.client, schema)
 		this.cache.set(schema, newValue)
 		return newValue
 	}
@@ -31,7 +30,7 @@ export class SchemaDatabaseMetadataResolverStore {
 
 export class MigrationsDatabaseMetadataResolverStoreFactory {
 	constructor(
-		private resolver: SchemaDatabaseMetadataResolver,
+		private resolver: DatabaseMetadataResolver,
 	) {
 	}
 

package/src/model/metadata/index.ts

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

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

@@ -1,15 +1,15 @@
+import { emptyDatabaseMetadata } from '@contember/database'
 import migration from '../../../src/migrations/2020-05-06-150000-composed-primary'
 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),
+		databaseMetadataResolver: () => Promise.resolve(emptyDatabaseMetadata),
 		project: {
 			slug: 'test',
 			stages: [

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

@@ -2,7 +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'
+import { emptyDatabaseMetadata } from '@contember/database'
 
 
 test('event-trigger-performance sql', async () => {
@@ -10,7 +10,7 @@ test('event-trigger-performance sql', async () => {
 	await migration(builder, {
 		connection: undefined as any,
 		schemaResolver: () => Promise.resolve(sampleProject),
-		databaseMetadataResolver: () => Promise.resolve(dummySchemaDatabaseMetadata),
+		databaseMetadataResolver: () => Promise.resolve(emptyDatabaseMetadata),
 		project: {
 			slug: 'test',
 			stages: [

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

@@ -2,9 +2,10 @@ 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 { dummySchemaDatabaseMetadata, emptySchema } from '@contember/schema-utils'
+import { emptySchema } from '@contember/schema-utils'
 import { Model } from '@contember/schema'
 import { createConnectionMock } from '@contember/database-tester'
+import { ForeignKeyDeleteAction, createDatabaseMetadata, emptyDatabaseMetadata } from '@contember/database'
 
 
 test('table-on-delete test', async () => {
@@ -15,7 +16,20 @@ test('table-on-delete test', async () => {
 	}])
 	await migration(builder, {
 		connection: connection,
-		databaseMetadataResolver: () => Promise.resolve(dummySchemaDatabaseMetadata),
+		databaseMetadataResolver: () => Promise.resolve(createDatabaseMetadata({
+			indexes: [],
+			uniqueConstraints: [],
+			foreignKeys: [{
+				constraintName: 'fk_post_author_id_author_id',
+				fromColumn: 'author_id',
+				fromTable: 'post',
+				toColumn: 'id',
+				toTable: 'author',
+				deleteAction: ForeignKeyDeleteAction.restrict,
+				deferrable: false,
+				deferred: false,
+			}],
+		})),
 		schemaResolver: () => Promise.resolve(({ ...emptySchema, model: new SchemaBuilder()
 			.entity('Post', entity =>
 				entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),

package/tests/cases/migrations/2023-09-11-174000-fix-on-delete.test.ts

@@ -0,0 +1,106 @@
+import migration from '../../../src/migrations/2023-09-11-174000-fix-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 { Model } from '@contember/schema'
+import { createConnectionMock } from '@contember/database-tester'
+import { ForeignKeyDeleteAction, createDatabaseMetadata, emptyDatabaseMetadata } from '@contember/database'
+
+
+test('table-on-delete test', async () => {
+	const builder = createMigrationBuilder()
+	const connection = createConnectionMock([{
+		sql: 'select schema from stage',
+		response: { rows: [{ schema: 'stage_live' }] },
+	}])
+	await migration(builder, {
+		connection: connection,
+		databaseMetadataResolver: () => Promise.resolve(createDatabaseMetadata({
+			indexes: [],
+			uniqueConstraints: [],
+			foreignKeys: [{
+				constraintName: 'fk_post_author_id_author_id',
+				fromColumn: 'author_id',
+				fromTable: 'post',
+				toColumn: 'id',
+				toTable: 'author',
+				deleteAction: ForeignKeyDeleteAction.cascade,
+				deferrable: false,
+				deferred: false,
+			}],
+		})),
+		schemaResolver: () => Promise.resolve(({ ...emptySchema, model: new SchemaBuilder()
+			.entity('Post', entity =>
+				entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
+			)
+			.entity('Author', entity => entity)
+			.buildSchema() })),
+		project: {
+			slug: 'test',
+			stages: [
+				{
+					slug: 'prod',
+					name: 'prod',
+				},
+			],
+		},
+	})
+	assert.equal(
+		builder.getSql(),
+		`ALTER TABLE "stage_live"."post" DROP CONSTRAINT "fk_post_author_id_author_id";
+ALTER TABLE "stage_live"."post"
+					ADD FOREIGN KEY ("author_id") 
+					REFERENCES "stage_live"."author" ("id") ON DELETE SET NULL DEFERRABLE INITIALLY IMMEDIATE
+				;
+`,
+	)
+})
+
+
+test('table-on-delete test valid', async () => {
+	const builder = createMigrationBuilder()
+	const connection = createConnectionMock([{
+		sql: 'select schema from stage',
+		response: { rows: [{ schema: 'stage_live' }] },
+	}])
+	await migration(builder, {
+		connection: connection,
+		databaseMetadataResolver: () => Promise.resolve(createDatabaseMetadata({
+			indexes: [],
+			uniqueConstraints: [],
+			foreignKeys: [{
+				constraintName: 'fk_post_author_id_author_id',
+				fromColumn: 'author_id',
+				fromTable: 'post',
+				toColumn: 'id',
+				toTable: 'author',
+				deleteAction: ForeignKeyDeleteAction.setnull,
+				deferred: false,
+				deferrable: false,
+			}],
+		})),
+		schemaResolver: () => Promise.resolve(({
+			...emptySchema, model: new SchemaBuilder()
+				.entity('Post', entity =>
+					entity.manyHasOne('author', relation => relation.target('Author').onDelete(Model.OnDelete.setNull)),
+				)
+				.entity('Author', entity => entity)
+				.buildSchema(),
+		})),
+		project: {
+			slug: 'test',
+			stages: [
+				{
+					slug: 'prod',
+					name: 'prod',
+				},
+			],
+		},
+	})
+	assert.equal(
+		builder.getSql(),
+		`\n`,
+	)
+})
+

package/tests/cases/migrations/2023-10-19-173000-fix-unique.test.ts

@@ -2,8 +2,8 @@ import migration from '../../../src/migrations/2023-10-19-173000-fix-unique'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { assert, test } from 'vitest'
 import { c, createSchema } from '@contember/schema-definition'
-import { dummySchemaDatabaseMetadata } from '@contember/schema-utils'
 import { createConnectionMock } from '@contember/database-tester'
+import { createDatabaseMetadata } from '@contember/database'
 
 namespace UniqueModel {
 
@@ -32,19 +32,19 @@ test('unique fix test', async () => {
 	}])
 	await migration(builder, {
 		connection: connection,
-		databaseMetadataResolver: () => Promise.resolve({
-			...dummySchemaDatabaseMetadata,
-			getAllUniqueConstraints: () => [
-				{ constraintName: 'valid1', tableName: 'foo', columnNames: ['col_a', 'col_b'] },
-				{ constraintName: 'valid2', tableName: 'foo', columnNames: ['col_b', 'many_has_one_bar_id'] },
-				{ constraintName: 'valid3', tableName: 'foo', columnNames: ['single_col_unique'] },
-				{ constraintName: 'valid4', tableName: 'foo', columnNames: ['has_one_bar_id'] },
-
-				{ constraintName: 'invalid1', tableName: 'foo', columnNames: ['col_a', 'col_c'] },
-				{ constraintName: 'invalid2', tableName: 'foo', columnNames: ['col_c', 'many_has_one_bar_id'] },
+		databaseMetadataResolver: () => Promise.resolve(createDatabaseMetadata({
+			foreignKeys: [],
+			indexes: [],
+			uniqueConstraints: [
+				{ constraintName: 'valid1', tableName: 'foo', columnNames: ['col_a', 'col_b'], deferrable: false, deferred: false },
+				{ constraintName: 'valid2', tableName: 'foo', columnNames: ['col_b', 'many_has_one_bar_id'], deferrable: false, deferred: false },
+				{ constraintName: 'valid3', tableName: 'foo', columnNames: ['single_col_unique'], deferrable: false, deferred: false },
+				{ constraintName: 'valid4', tableName: 'foo', columnNames: ['has_one_bar_id'], deferrable: false, deferred: false },
+				{ constraintName: 'invalid1', tableName: 'foo', columnNames: ['col_a', 'col_c'], deferrable: false, deferred: false },
+				{ constraintName: 'invalid2', tableName: 'foo', columnNames: ['col_c', 'many_has_one_bar_id'], deferrable: false, deferred: false },
 
 			],
-		}),
+		})),
 		schemaResolver: () => Promise.resolve(createSchema(UniqueModel)),
 		project: {
 			slug: 'test',

package/dist/src/model/metadata/ResolvedDatabaseMetadata.d.ts

@@ -1,14 +0,0 @@
-import { ForeignKeyConstraintMetadata, GetForeignKeyConstraintNameArgs, GetIndexNameArgs, GetUniqueConstraintNameArgs, IndexMetadata, SchemaDatabaseMetadata, UniqueConstraintMetadata } from '@contember/schema-utils';
-export declare class ResolvedDatabaseMetadata implements SchemaDatabaseMetadata {
-    private readonly foreignKeys;
-    private readonly uniqueConstraints;
-    private readonly indexes;
-    constructor(foreignKeys: ForeignKeyConstraintMetadata[], uniqueConstraints: UniqueConstraintMetadata[], indexes: IndexMetadata[]);
-    getAllUniqueConstraints(): UniqueConstraintMetadata[];
-    getUniqueConstraint(tableName: string, constraintName: string): UniqueConstraintMetadata | null;
-    getForeignKeyConstraint(tableName: string, constraintName: string): ForeignKeyConstraintMetadata | null;
-    getForeignKeyConstraintNames({ fromTable, fromColumn, toTable, toColumn }: GetForeignKeyConstraintNameArgs): string[];
-    getUniqueConstraintNames({ tableName, columnNames }: GetUniqueConstraintNameArgs): string[];
-    getIndexNames({ tableName, columnNames }: GetIndexNameArgs): string[];
-}
-//# sourceMappingURL=ResolvedDatabaseMetadata.d.ts.map

package/dist/src/model/metadata/ResolvedDatabaseMetadata.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ResolvedDatabaseMetadata.d.ts","sourceRoot":"","sources":["../../../../src/model/metadata/ResolvedDatabaseMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,4BAA4B,EAC5B,+BAA+B,EAC/B,gBAAgB,EAChB,2BAA2B,EAC3B,aAAa,EACb,sBAAsB,EACtB,wBAAwB,EACxB,MAAM,yBAAyB,CAAA;AAWhC,qBAAa,wBAAyB,YAAW,sBAAsB;IAErE,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFP,WAAW,EAAE,4BAA4B,EAAE,EAC3C,iBAAiB,EAAE,wBAAwB,EAAE,EAC7C,OAAO,EAAE,aAAa,EAAE;IAI1C,uBAAuB,IAAI,wBAAwB,EAAE;IAIrD,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,wBAAwB,GAAG,IAAI;IAI/F,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,4BAA4B,GAAG,IAAI;IAIvG,4BAA4B,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,+BAA+B,GAAG,MAAM,EAAE;IAWrH,wBAAwB,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,EAAE,2BAA2B,GAAG,MAAM,EAAE;IAM3F,aAAa,CAAC,EAAE,SAAS,EAAE,WAAW,EAAE,EAAE,gBAAgB,GAAG,MAAM,EAAE;CAKrE"}