@contember/engine-system-api 1.2.0 → 1.3.0-alpha.13

package/src/migrations/snapshot.ts

@@ -0,0 +1,169 @@
+import { snapshotMigration } from './snapshot-factory'
+export default snapshotMigration(({ randomUuidFn }) => `
+CREATE DOMAIN "event_data_type" AS "text"
+	CONSTRAINT "event_data_type_check" CHECK ((VALUE = ANY (ARRAY['create'::"text", 'update'::"text", 'delete'::"text"])));
+CREATE DOMAIN "event_type" AS "text"
+	CONSTRAINT "event_type_check" CHECK ((VALUE = ANY (ARRAY['init'::"text", 'create'::"text", 'update'::"text", 'delete'::"text", 'run_migration'::"text"])));
+CREATE FUNCTION "trigger_event"() RETURNS "trigger"
+    LANGUAGE "plpgsql"
+    AS $$
+		DECLARE new_event_type TEXT;
+		DECLARE table_name TEXT;
+		DECLARE values JSONB;
+		DECLARE update_diff JSONB;
+		DECLARE primary_values JSONB;
+		DECLARE old_row JSONB;
+		DECLARE new_row JSONB;
+		BEGIN
+			old_row := CASE WHEN TG_OP = 'DELETE' OR TG_OP = 'UPDATE' THEN TO_JSONB(old) ELSE NULL END;
+			new_row := CASE WHEN TG_OP = 'INSERT' OR TG_OP = 'UPDATE' THEN TO_JSONB(new) ELSE NULL END;
+			primary_values := (
+				SELECT JSONB_AGG(value ORDER BY array_position(TG_ARGV, key))
+				FROM JSONB_EACH(COALESCE(old_row, new_row))
+				WHERE key = ANY (TG_ARGV)
+			);
+			table_name := tg_table_name;
+			CASE TG_OP
+				WHEN 'INSERT' THEN BEGIN
+					new_event_type := 'create';
+					values := COALESCE(
+						(
+							SELECT JSONB_OBJECT_AGG(key, value)
+ 						    FROM JSONB_EACH(new_row)
+ 						    WHERE NOT (key = ANY (TG_ARGV))
+ 						),
+ 						JSONB_BUILD_OBJECT()
+ 					);
+				END;
+				WHEN 'UPDATE' THEN BEGIN
+					update_diff := (
+						SELECT JSONB_OBJECT_AGG(COALESCE(n.key, o.key), n.value)
+						FROM JSONB_EACH(old_row) o
+ 						FULL OUTER JOIN JSONB_EACH(new_row) n ON n.key = o.key
+						WHERE n.value IS DISTINCT FROM o.value
+					);
+					IF (SELECT COUNT(*) FROM JSONB_OBJECT_KEYS(update_diff)) = 0 THEN
+						RETURN NULL;
+					END IF;
+					new_event_type := 'update';
+					values := update_diff;
+				END;
+				WHEN 'DELETE' THEN BEGIN
+					new_event_type := 'delete';
+				END;
+				ELSE RAISE
+					EXCEPTION 'Unknown TG_OP value %', TG_OP;
+			END CASE;
+			CASE WHEN NULLIF(CURRENT_SETTING('system.schema_id', true), '') IS NULL THEN
+				PERFORM SET_CONFIG('system.schema_id', (select MAX("id")::TEXT from schema_migration), TRUE);
+			ELSE
+				-- do nothing
+			END CASE;
+			INSERT INTO "event_data" ("id", "type", "table_name", "row_ids", "values", "created_at", schema_id, identity_id)
+			VALUES (
+				"${randomUuidFn}"(),
+				new_event_type,
+				table_name,
+				primary_values,
+				values,
+				CLOCK_TIMESTAMP(),
+				CURRENT_SETTING('system.schema_id')::INT,
+				COALESCE(
+					CURRENT_SETTING('tenant.identity_id'::TEXT, TRUE)::UUID,
+ 					'00000000-0000-0000-0000-000000000000'::UUID)
+ 				);
+			RETURN NULL;
+		END;
+		$$;
+CREATE FUNCTION "trigger_event_commit"() RETURNS "trigger"
+    LANGUAGE "plpgsql"
+    AS $$
+BEGIN
+	PERFORM PG_ADVISORY_XACT_LOCK(5218230332970456493); -- well-known random number
+	CASE WHEN
+			NULLIF(CURRENT_SETTING('system.transaction_id', TRUE), '') IS NOT NULL
+			AND NULLIF(CURRENT_SETTING('system.transaction_inserted', TRUE), '') IS NULL
+		THEN
+			INSERT INTO stage_transaction(transaction_id, stage_id, applied_at)
+			VALUES (CURRENT_SETTING('system.transaction_id')::UUID,
+					(
+						SELECT id
+						FROM stage
+						WHERE schema = TG_TABLE_SCHEMA
+					),
+					CLOCK_TIMESTAMP())
+			ON CONFLICT DO NOTHING;
+			PERFORM SET_CONFIG('system.transaction_inserted', '1', TRUE);
+		ELSE
+		-- do nothing
+		END CASE;
+	RETURN NULL;
+END
+$$;
+CREATE TABLE "event_data" (
+    "id" "uuid" NOT NULL,
+    "type" "event_data_type" NOT NULL,
+    "table_name" "text" NOT NULL,
+    "row_ids" "jsonb" NOT NULL,
+    "values" "jsonb",
+    "created_at" timestamp with time zone DEFAULT "clock_timestamp"() NOT NULL,
+    "schema_id" integer NOT NULL,
+    "identity_id" "uuid" NOT NULL,
+    "transaction_id" "uuid" DEFAULT COALESCE((NULLIF("current_setting"('system.transaction_id'::"text", true), ''::"text"))::"uuid", ("set_config"('system.transaction_id'::"text", ("${randomUuidFn}"())::"text", true))::"uuid") NOT NULL
+);
+CREATE TABLE "schema_migration" (
+    "id" integer NOT NULL,
+    "version" character varying(20) NOT NULL,
+    "name" character varying(255) NOT NULL,
+    "migration" "json" NOT NULL,
+    "checksum" character(32) NOT NULL,
+    "executed_at" timestamp with time zone DEFAULT "now"() NOT NULL
+);
+CREATE SEQUENCE "schema_migration_id_seq"
+    AS integer
+    START WITH 1
+    INCREMENT BY 1
+    NO MINVALUE
+    NO MAXVALUE
+    CACHE 1;
+ALTER SEQUENCE "schema_migration_id_seq" OWNED BY "schema_migration"."id";
+CREATE TABLE "stage" (
+    "id" "uuid" NOT NULL,
+    "name" "text" NOT NULL,
+    "slug" "text" NOT NULL,
+    "schema" "text" NOT NULL
+);
+CREATE TABLE "stage_transaction" (
+    "transaction_id" "uuid" NOT NULL,
+    "stage_id" "uuid" NOT NULL,
+    "applied_at" timestamp with time zone NOT NULL
+);
+ALTER TABLE ONLY "schema_migration" ALTER COLUMN "id" SET DEFAULT "nextval"('"schema_migration_id_seq"'::"regclass");
+ALTER TABLE ONLY "event_data"
+    ADD CONSTRAINT "event_data_pkey" PRIMARY KEY ("id");
+ALTER TABLE ONLY "schema_migration"
+    ADD CONSTRAINT "schema_migration_name_key" UNIQUE ("name");
+ALTER TABLE ONLY "schema_migration"
+    ADD CONSTRAINT "schema_migration_pkey" PRIMARY KEY ("id");
+ALTER TABLE ONLY "schema_migration"
+    ADD CONSTRAINT "schema_migration_version_key" UNIQUE ("version");
+ALTER TABLE ONLY "stage"
+    ADD CONSTRAINT "stage_pkey" PRIMARY KEY ("id");
+ALTER TABLE ONLY "stage"
+    ADD CONSTRAINT "stage_schema_key" UNIQUE ("schema");
+ALTER TABLE ONLY "stage"
+    ADD CONSTRAINT "stage_slug_key" UNIQUE ("slug");
+ALTER TABLE ONLY "stage_transaction"
+    ADD CONSTRAINT "stage_transaction_pkey" PRIMARY KEY ("transaction_id", "stage_id");
+CREATE INDEX "event_data_created" ON "event_data" USING "btree" ("created_at");
+CREATE INDEX "system_event2_table_name" ON "event_data" USING "btree" ("table_name");
+CREATE INDEX "system_event2_transaction" ON "event_data" USING "btree" ("transaction_id");
+CREATE INDEX "system_event2_type" ON "event_data" USING "btree" ("type");
+CREATE INDEX "system_event_row_id" ON "event_data" USING "btree" ("row_ids");
+CREATE INDEX "system_schema_migration_version" ON "schema_migration" USING "btree" ("version");
+CREATE INDEX "transaction_applied" ON "stage_transaction" USING "btree" ("applied_at");
+ALTER TABLE ONLY "event_data"
+    ADD CONSTRAINT "event_data_schema_id_fkey" FOREIGN KEY ("schema_id") REFERENCES "schema_migration"("id");
+ALTER TABLE ONLY "stage_transaction"
+    ADD CONSTRAINT "stage_transaction_stage_id_fkey" FOREIGN KEY ("stage_id") REFERENCES "stage"("id") ON DELETE CASCADE;
+`)

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/ProjectInitializer.ts

@@ -1,63 +1,28 @@
 import { ProjectConfig } from '../types'
-import { ProjectMigrator, SchemaVersionBuilder } from './migrations'
 import { StageCreator } from './stages'
 import { DatabaseContext, DatabaseContextFactory } from './database'
-import { SystemDbMigrationsRunnerFactory } from '../SystemContainer'
-import {
-	Client,
-	Connection,
-	createDatabaseIfNotExists,
-	DatabaseConfig,
-	EventManager,
-	retryTransaction,
-} from '@contember/database'
+import { Connection, retryTransaction } from '@contember/database'
 import { FingerCrossedLoggerHandler, Logger } from '@contember/logger'
+import { SystemMigrationsRunner } from '../migrations'
 
 export class ProjectInitializer {
 	constructor(
-		private readonly projectMigrator: ProjectMigrator,
 		private readonly stageCreator: StageCreator,
-		private readonly systemDbMigrationsRunnerFactory: SystemDbMigrationsRunnerFactory,
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly migrationsRunner: SystemMigrationsRunner,
+		private readonly databaseContextFactory: DatabaseContextFactory,
+		private readonly project: ProjectConfig,
 	) {}
 
-	public async initialize(
-		databaseContextFactory: DatabaseContextFactory,
-		project: ProjectConfig & { db?: DatabaseConfig },
-		logger: Logger,
-	) {
-		const dbContext = databaseContextFactory.create()
+	public async initialize(logger: Logger) {
 		return await logger.scope(async initLogger => {
-			if (project.db) {
-				// todo: use dbContext
-				initLogger.debug('Executing system schema migrations')
-				await createDatabaseIfNotExists(project.db, message => typeof message === 'string' ? initLogger.warn(message) : initLogger.error(message))
-				const singleConnection = Connection.createSingle(project.db, err => initLogger.error(err, { message: 'Database client error' }))
-
-				await singleConnection.scope(async connection => {
-					const systemSchema = dbContext.client.schema
-
-					const schemaResolver = (connection: Connection.ConnectionLike) => {
-						const dbContextMigrations = databaseContextFactory
-							.withClient(new Client(connection, systemSchema, { module: 'system' }))
-							.create()
-						return this.schemaVersionBuilder.buildSchema(dbContextMigrations)
-					}
-					await this.systemDbMigrationsRunnerFactory(connection, systemSchema).migrate(
-						message => initLogger.warn(message),
-						{
-							schemaResolver,
-							project,
-						},
-					)
-				})
-				await singleConnection.end()
-			}
-			await retryTransaction(() =>
-				dbContext.transaction(async trx => {
-					await this.initStages(trx, project, initLogger)
+			initLogger.debug('Executing system schema migrations')
+			await this.migrationsRunner.run(initLogger)
+			const dbContext = this.databaseContextFactory.create()
+			await retryTransaction(
+				() => dbContext.transaction(async trx => {
+					await this.initStages(trx, logger)
 				}),
-			message => initLogger.warn(message),
+				message => initLogger.warn(message),
 			)
 			if (dbContext.client.connection instanceof Connection) {
 				await dbContext.client.connection.clearPool()
@@ -65,9 +30,9 @@ export class ProjectInitializer {
 		}, {}, { handler: FingerCrossedLoggerHandler.factory() })
 	}
 
-	private async initStages(db: DatabaseContext<Connection.TransactionLike>, project: ProjectConfig, logger: Logger) {
+	private async initStages(db: DatabaseContext<Connection.TransactionLike>, logger: Logger) {
 		logger.debug(`Creating stages`)
-		for (const stage of project.stages) {
+		for (const stage of this.project.stages) {
 			const created = await this.stageCreator.createStage(db, stage)
 			if (created) {
 				logger.warn(`Created stage ${stage.slug}`, { stage: stage.slug })

package/src/model/commands/Command.ts

@@ -3,7 +3,7 @@ import { CommandBus } from './CommandBus'
 import { Providers } from '../../utils'
 
 interface Command<Result> {
-	execute(args: { db: Client; providers: Providers; bus: CommandBus }): Promise<Result>
+	execute(args: Command.Args): Promise<Result>
 }
 
 namespace Command {

package/src/model/database/DatabaseContext.ts

@@ -1,4 +1,4 @@
-import { Client, Connection, DatabaseQueryable, withDatabaseAdvisoryLock } from '@contember/database'
+import { Client, Connection, DatabaseQueryable } from '@contember/database'
 import { QueryHandler } from '@contember/queryable'
 import { UuidProvider } from '../../utils'
 import { CommandBus } from '../commands'
@@ -7,19 +7,21 @@ export interface DatabaseContext<ConnectionType extends Connection.ConnectionLik
 	client: Client<ConnectionType>
 	queryHandler: QueryHandler<DatabaseQueryable>
 	transaction: <T>(cb: (db: DatabaseContext<Connection.TransactionLike>) => Promise<T> | T) => Promise<T>
+	scope: <T>(cb: (db: DatabaseContext<ConnectionType & Connection.AcquiredConnectionLike>) => Promise<T> | T) => Promise<T>
 	locked: <T>(lock: number, cb: (db: DatabaseContext<Connection.ConnectionLike>) => Promise<T> | T) => Promise<T>
 	commandBus: CommandBus
 }
 
 export class DatabaseContextFactory {
-	constructor(private readonly client: Client, private readonly providers: UuidProvider) {}
+	constructor(
+		public readonly schemaName: string,
+		private readonly connection: Connection,
+		private readonly providers: UuidProvider,
+	) {}
 
-	public create(): DatabaseContext {
-		return createDatabaseContext(this.client, this.providers)
-	}
-
-	public withClient(client: Client) {
-		return new DatabaseContextFactory(client, this.providers)
+	public create(connection?: Connection.ConnectionLike): DatabaseContext {
+		const client = new Client(connection ?? this.connection, this.schemaName, { module: 'system' })
+		return createDatabaseContext(client, this.providers)
 	}
 }
 
@@ -34,6 +36,8 @@ const createDatabaseContext = <ConnectionType extends Connection.ConnectionLike
 			await client.query(Connection.REPEATABLE_READ)
 			return cb(createDatabaseContext(client, providers))
 		}),
+	scope: cb =>
+		client.scope(client => cb(createDatabaseContext(client, providers))),
 	commandBus: new CommandBus(client, providers),
 	locked: (lock, cb) => client.locked(lock, client => cb(createDatabaseContext(client, providers))),
 })

package/src/model/dtos/ExecutedMigration.ts

@@ -4,6 +4,7 @@ export class ExecutedMigration implements Migration {
 	public readonly version: string
 
 	constructor(
+		public readonly id: number,
 		public readonly name: string,
 		public readonly formatVersion: number,
 		public readonly modifications: Migration.Modification[],

package/src/model/events/EventResponseBuilder.ts

@@ -1,4 +1,4 @@
-import { AnyEvent, EventType } from '@contember/engine-common'
+import { ContentEvent, EventType } from './types'
 import { CreateEvent, DeleteEvent, EventType as ApiEventType, UpdateEvent } from '../../schema'
 import { assertNever } from '../../utils'
 import { IdentityFetcher } from '../dependencies'
@@ -8,7 +8,7 @@ import { appendCreateSpecificData, appendDeleteSpecificData, appendUpdateSpecifi
 export class EventResponseBuilder {
 	constructor(private readonly identityFetcher: IdentityFetcher) {}
 
-	public async buildResponse(events: AnyEvent[]): Promise<(CreateEvent | DeleteEvent | UpdateEvent)[]> {
+	public async buildResponse(events: ContentEvent[]): Promise<(CreateEvent | DeleteEvent | UpdateEvent)[]> {
 		const apiEventTypeMapping = {
 			[EventType.create]: ApiEventType.Create,
 			[EventType.update]: ApiEventType.Update,
@@ -41,7 +41,7 @@ export class EventResponseBuilder {
 		})
 	}
 
-	private formatDescription(event: AnyEvent): string {
+	private formatDescription(event: ContentEvent): string {
 		switch (event.type) {
 			case EventType.create:
 				return `Creating ${event.tableName}#${event.rowId.join(';')}`

package/src/model/events/EventResponseHelper.ts

@@ -1,4 +1,4 @@
-import { AnyEvent, ContentEvent, CreateEvent, DeleteEvent, UpdateEvent } from '@contember/engine-common'
+import { CreateEvent, DeleteEvent, UpdateEvent } from './types'
 
 export const appendUpdateSpecificData = <T>(commonData: T, event: UpdateEvent) => ({
 	...commonData,

package/src/model/events/index.ts

@@ -1 +1,2 @@
 export * from './EventResponseBuilder'
+export * from './types'

package/src/model/events/types.ts

@@ -0,0 +1,63 @@
+export enum EventType {
+	delete = 'delete',
+	update = 'update',
+	create = 'create',
+}
+
+export type ContentEvent = UpdateEvent | CreateEvent | DeleteEvent
+
+export interface Event {
+	readonly type: EventType
+	readonly id: string
+	readonly createdAt: Date
+	readonly transactionId: string
+	// readonly errors?: string[]
+}
+
+export class UpdateEvent implements Event {
+	public readonly type = EventType.update
+
+	constructor(
+		public readonly id: string,
+		public readonly createdAt: Date,
+		public readonly appliedAt: Date,
+		public readonly identityId: string,
+		public readonly transactionId: string,
+		public readonly rowId: string[],
+		public readonly tableName: string,
+		public readonly values: { [column: string]: any },
+	) {
+	}
+}
+
+export class CreateEvent implements Event {
+	public readonly type = EventType.create
+
+	constructor(
+		public readonly id: string,
+		public readonly createdAt: Date,
+		public readonly appliedAt: Date,
+		public readonly identityId: string,
+		public readonly transactionId: string,
+		public readonly rowId: string[],
+		public readonly tableName: string,
+		public readonly values: { [column: string]: any },
+	) {
+	}
+}
+
+export class DeleteEvent implements Event {
+	public readonly type = EventType.delete
+
+	constructor(
+		public readonly id: string,
+		public readonly createdAt: Date,
+		public readonly appliedAt: Date,
+		public readonly identityId: string,
+		public readonly transactionId: string,
+		public readonly rowId: string[],
+		public readonly tableName: string,
+	) {
+	}
+}
+

package/src/model/helpers/index.ts

@@ -1,3 +1,2 @@
 export * from './stageHelpers'
-export * from './SystemVariablesSetupHelper'
 export * from './modelHelpers'

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)
+	}
+}