@contember/engine-system-api 1.1.0-alpha.0 → 1.1.0-alpha.3

package/{migrations → src/migrations}/2021-05-07-155800-event-log-rework.ts

@@ -1,5 +1,6 @@
 import { MigrationBuilder, Name } from '@contember/database-migrations'
-import { formatSchemaName, getJunctionTables, MigrationArgs } from '..'
+import { SystemMigrationArgs } from './types'
+import { getJunctionTables } from '../model'
 
 const createTrxEvent = (builder: MigrationBuilder, tableName: Name) => {
 	builder.createTrigger(tableName, 'log_event_trx', {
@@ -15,13 +16,13 @@ const createTrxEvent = (builder: MigrationBuilder, tableName: Name) => {
 	})
 }
 
-export default async function (builder: MigrationBuilder, args: MigrationArgs) {
+export default async function (builder: MigrationBuilder, args: SystemMigrationArgs) {
 	const schema = await args.schemaResolver()
 	const junctionTables = getJunctionTables(schema.model)
-	const schemas = args.project.stages.map(formatSchemaName)
-	builder.sql(`LOCK TABLE system.event`)
+	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
+	builder.sql(`LOCK TABLE event`)
 	builder.sql(`
-		ALTER TABLE system.schema_migration
+		ALTER TABLE schema_migration
 		ADD PRIMARY KEY (id)
 	`)
 	builder.sql(`
@@ -29,40 +30,40 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs) {
 		CONSTRAINT event_data_type_check CHECK (VALUE = ANY (ARRAY ['create', 'update', 'delete']));
 	`)
 	builder.sql(`
-		CREATE TABLE system.event_data (
+		CREATE TABLE event_data (
 			id UUID NOT NULL CONSTRAINT event_data_pkey PRIMARY KEY,
-		type system.event_data_type NOT NULL,
+		type event_data_type NOT NULL,
 		table_name TEXT NOT NULL,
 		row_ids JSONB NOT NULL,
 		values JSONB DEFAULT NULL,
 		created_at TIMESTAMP WITH TIME ZONE DEFAULT CLOCK_TIMESTAMP() NOT NULL,
-		schema_id INTEGER NOT NULL REFERENCES system.schema_migration(id),
+		schema_id INTEGER NOT NULL REFERENCES schema_migration(id),
 		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, (system.uuid_generate_v4())::TEXT, TRUE))::UUID) NOT NULL
+			(SET_CONFIG('system.transaction_id'::TEXT, (uuid_generate_v4())::TEXT, TRUE))::UUID) NOT NULL
 		)
 	`)
 	builder.sql(`
 		CREATE INDEX system_event_row_id
-		ON system.event_data(row_ids)
+		ON event_data(row_ids)
 	`)
 	builder.sql(`
 		CREATE INDEX system_event2_table_name
-		ON system.event_data(table_name)
+		ON event_data(table_name)
 	`)
 	builder.sql(`
 		CREATE INDEX system_event2_type
-		ON system.event_data(type)
+		ON event_data(type)
 	`)
 	builder.sql(`
 		CREATE INDEX system_event2_transaction
-		ON system.event_data(transaction_id)
+		ON event_data(transaction_id)
 	`)
 	builder.sql(`
-		CREATE TABLE system.stage_transaction (
+		CREATE TABLE stage_transaction (
 			transaction_id UUID NOT NULL,
-			stage_id UUID NOT NULL REFERENCES system.stage(id) ON DELETE CASCADE,
+			stage_id UUID NOT NULL REFERENCES stage(id) ON DELETE CASCADE,
 			applied_at TIMESTAMPTZ NOT NULL,
 			PRIMARY KEY (transaction_id, stage_id)
 		)
@@ -72,23 +73,23 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs) {
 		events AS (
 			SELECT
 				e.*,
-				(SELECT MAX(id) FROM system.schema_migration) AS schema_id,
+				(SELECT MAX(id) FROM schema_migration) AS schema_id,
 				1 AS index,
 				stage.id AS stage_id
-			FROM system.stage
-			JOIN system.event e ON stage.event_id = e.id
+			FROM stage
+			JOIN event e ON stage.event_id = e.id
  			UNION ALL
  			SELECT
  				event.*,
  				COALESCE(
  					CASE WHEN event.type = 'run_migration' THEN
-						(SELECT id FROM system.schema_migration WHERE version = event.data ->> 'version')
+						(SELECT id FROM schema_migration WHERE version = event.data ->> 'version')
 					END,
 					events.schema_id
 				),
  				index + 1,
  				stage_id
- 			FROM system.event
+ 			FROM event
  				JOIN events
  			ON events.previous_id = event.id
  		),
@@ -102,7 +103,7 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs) {
  			FROM events
  		)
  		INSERT
- 		INTO system.event_data (id, type, table_name, row_ids, values, created_at, schema_id, identity_id, transaction_id)
+ 		INTO event_data (id, type, table_name, row_ids, values, created_at, schema_id, identity_id, transaction_id)
  		SELECT
  			id,
  			type,
@@ -124,14 +125,14 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs) {
  				e.*,
  				1 AS index,
  				stage.id AS stage_id
- 			FROM system.stage
- 			JOIN system.event e ON stage.event_id = e.id
+ 			FROM stage
+ 			JOIN event e ON stage.event_id = e.id
  			UNION ALL
  			SELECT
  				event.*,
  				index + 1,
  				stage_id
- 			FROM system.event
+ 			FROM event
  			JOIN events ON events.previous_id = event.id
  		),
  		transaction_times AS (
@@ -145,12 +146,12 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs) {
  			ORDER BY transaction_id
  		)
  		INSERT
- 		INTO system.stage_transaction (transaction_id, stage_id, applied_at)
+ 		INTO stage_transaction (transaction_id, stage_id, applied_at)
  		SELECT transaction_id, stage_id, created_at
  		FROM transaction_times
 	`)
 	builder.sql(`
-		CREATE OR REPLACE FUNCTION "system"."trigger_event"() RETURNS TRIGGER AS
+		CREATE OR REPLACE FUNCTION "trigger_event"() RETURNS TRIGGER AS
 		$$
 		DECLARE new_event_type TEXT;
 		DECLARE table_name TEXT;
@@ -201,14 +202,14 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs) {
 			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 system.schema_migration), TRUE);
+				PERFORM SET_CONFIG('system.schema_id', (select MAX("id")::TEXT from schema_migration), TRUE);
 			ELSE
 				-- do nothing
 			END CASE;
 
-			INSERT INTO "system"."event_data" ("id", "type", "table_name", "row_ids", "values", "created_at", schema_id, identity_id)
+			INSERT INTO "event_data" ("id", "type", "table_name", "row_ids", "values", "created_at", schema_id, identity_id)
 			VALUES (
-				system.uuid_generate_v4(),
+				uuid_generate_v4(),
 				new_event_type,
 				table_name,
 				primary_values,
@@ -233,12 +234,12 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs) {
 				NULLIF(CURRENT_SETTING('system.transaction_id', true), '') IS NOT NULL
 				AND NULLIF(CURRENT_SETTING('system.transaction_inserted', true), '') IS NULL
 				THEN
-				INSERT INTO system.stage_transaction(transaction_id, stage_id, applied_at)
+				INSERT INTO stage_transaction(transaction_id, stage_id, applied_at)
 				VALUES (
 					CURRENT_SETTING('system.transaction_id')::UUID,
 					(
 						SELECT id
- 						FROM "system"."stage"
+ 						FROM "stage"
  						WHERE "slug" = RIGHT(TG_TABLE_SCHEMA, - LENGTH('stage_'))
  				    ),
 					CLOCK_TIMESTAMP()
@@ -268,11 +269,11 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs) {
 		}
 	}
 	builder.sql(`
-		ALTER TABLE system.stage
+		ALTER TABLE stage
 		ALTER event_id DROP NOT NULL
 	`)
 	builder.sql(`
-		ALTER TABLE system.event
+		ALTER TABLE event
 		RENAME TO event_bak
 	`)
 }

package/{migrations → src/migrations}/2021-05-19-1232000-event-log-fix-constraint.ts

@@ -1,5 +1,6 @@
 import { MigrationBuilder, Name } from '@contember/database-migrations'
-import { formatSchemaName, getJunctionTables, MigrationArgs } from '..'
+import { SystemMigrationArgs } from './types'
+import { getJunctionTables } from '../model'
 
 const recreateTrigger = (builder: MigrationBuilder, tableName: Name) => {
 	builder.dropTrigger(tableName, 'log_event_trx', { ifExists: true })
@@ -18,10 +19,10 @@ const recreateTrigger = (builder: MigrationBuilder, tableName: Name) => {
 	})
 }
 
-export default async function (builder: MigrationBuilder, args: MigrationArgs) {
+export default async function (builder: MigrationBuilder, args: SystemMigrationArgs) {
 	const schema = await args.schemaResolver()
 	const junctionTables = getJunctionTables(schema.model)
-	const schemas = args.project.stages.map(formatSchemaName)
+	const schemas = args.project.stages.map(it => `stage_${it.slug}`)
 
 	for (const table of junctionTables) {
 		for (const schema of schemas) {

package/src/migrations/2021-12-21-155500-events-up.sql

@@ -0,0 +1,6 @@
+CREATE INDEX event_data_created ON event_data (created_at);
+CREATE INDEX transaction_applied ON stage_transaction (applied_at);
+
+ALTER TABLE stage
+	DROP event_id;
+DROP TABLE event_bak;

package/src/migrations/2022-02-08-132600-fn-search-path.sql

@@ -0,0 +1,7 @@
+DO LANGUAGE plpgsql
+$$
+	BEGIN
+		EXECUTE FORMAT('ALTER FUNCTION trigger_event_commit() SET SEARCH_PATH = %s', QUOTE_IDENT(CURRENT_SCHEMA()));
+		EXECUTE FORMAT('ALTER FUNCTION trigger_event() SET SEARCH_PATH = %s', QUOTE_IDENT(CURRENT_SCHEMA()));
+	END
+$$

package/src/migrations/2022-02-08-140500-drop-deadcode.sql

@@ -0,0 +1,2 @@
+DROP FUNCTION rebase_events_unsafe(head UUID, oldbase UUID, newbase UUID, appliedevents UUID[]);
+DROP FUNCTION statement_trigger_event();

package/src/migrations/2022-02-08-144400-dynamic-stage-schema.sql

@@ -0,0 +1,41 @@
+ALTER TABLE stage
+	ADD COLUMN schema TEXT UNIQUE;
+UPDATE stage
+SET schema = 'stage_' || slug;
+ALTER TABLE stage
+	ALTER schema SET NOT NULL;
+
+CREATE OR REPLACE FUNCTION trigger_event_commit() RETURNS TRIGGER 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
+$$ LANGUAGE plpgsql;
+
+DO LANGUAGE plpgsql
+$$
+	BEGIN
+		EXECUTE FORMAT('ALTER FUNCTION trigger_event_commit() SET SEARCH_PATH = %s', QUOTE_IDENT(CURRENT_SCHEMA()));
+	END
+$$

package/src/migrations/index.ts

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

package/{migrations/index.ts → src/migrations/runner.ts}

@@ -1,11 +1,11 @@
-import { Migration, loadMigrations } from '@contember/database-migrations'
+import { loadMigrations, Migration } from '@contember/database-migrations'
 import projectMigrations from './2020-03-27-130000-project-migrations'
 import composedPrimary from './2020-05-06-150000-composed-primary'
 import eventTriggerPerf from './2020-06-01-103000-event-trigger-perf'
 import eventLogRework from './2021-05-07-155800-event-log-rework'
 import eventLogFixConstraint from './2021-05-19-1232000-event-log-fix-constraint'
 
-export default function (): Promise<Migration[]> {
+export const getSystemMigrations = (): Promise<Migration[]> => {
 	return loadMigrations(process.env.CONTEMBER_SYSTEM_MIGRATIONS_DIR || __dirname, [
 		new Migration('2020-03-27-130000-project-migrations', projectMigrations),
 		new Migration('2020-05-06-150000-composed-primary', composedPrimary),

package/src/migrations/types.ts

@@ -0,0 +1,7 @@
+import { Schema } from '@contember/schema'
+import { ProjectConfig } from '../types'
+
+export interface SystemMigrationArgs {
+	schemaResolver: () => Promise<Schema>
+	project: ProjectConfig
+}

package/src/model/ProjectInitializer.ts

@@ -1,19 +1,18 @@
-import { unnamedIdentity } from './helpers'
-import { ProjectConfig, StageConfig } from '../types'
+import { ProjectConfig } from '../types'
 import { ProjectMigrator, SchemaVersionBuilder } from './migrations'
 import { StageCreator } from './stages'
 import { DatabaseContext, DatabaseContextFactory } from './database'
 import { SystemDbMigrationsRunnerFactory } from '../SystemContainer'
 import {
 	Connection,
+	createDatabaseIfNotExists,
 	DatabaseCredentials,
-	EventManager,
 	retryTransaction,
 	SingleConnection,
 } from '@contember/database'
-import { createDatabaseIfNotExists, createPgClient } from '@contember/database-migrations'
 import { Logger } from '@contember/engine-common'
 import { Migration } from '@contember/schema-migrations'
+import { StagesQuery } from './queries'
 
 export class ProjectInitializer {
 	constructor(
@@ -29,28 +28,26 @@ export class ProjectInitializer {
 		logger: Logger,
 		migrations?: Migration[],
 	) {
-		const dbContext = databaseContextFactory.create(unnamedIdentity)
+		const dbContext = databaseContextFactory.create()
 		if (project.db) {
 			// todo: use dbContext
 			logger.group(`Executing system schema migration`)
 			await createDatabaseIfNotExists(project.db, logger.write.bind(logger))
-			const pgClient = await createPgClient(project.db)
-			await pgClient.connect()
-			const singleConnection = new SingleConnection(pgClient, {}, new EventManager(), true)
+			const singleConnection = new SingleConnection(project.db, {})
+			const systemSchema = dbContext.client.schema
 			const dbContextMigrations = databaseContextFactory
-				.withClient(singleConnection.createClient('system', { module: 'system' }))
-				.create(unnamedIdentity)
+				.withClient(singleConnection.createClient(systemSchema, { module: 'system' }))
+				.create()
 
 			const schemaResolver = () => this.schemaVersionBuilder.buildSchema(dbContextMigrations)
-			await this.systemDbMigrationsRunnerFactory(project.db, pgClient).migrate(
+			await this.systemDbMigrationsRunnerFactory(singleConnection, systemSchema).migrate(
 				logger.write.bind(logger),
 				{
 					schemaResolver,
 					project,
-					queryHandler: dbContextMigrations.queryHandler,
 				},
 			)
-			await pgClient.end()
+			await singleConnection.end()
 			logger.groupEnd()
 		}
 		return await retryTransaction(() =>
@@ -68,6 +65,7 @@ export class ProjectInitializer {
 	) {
 
 		logger.group(`Creating stages`)
+
 		for (const stage of project.stages) {
 			const created = await this.stageCreator.createStage(db, stage)
 			if (created) {
@@ -80,7 +78,8 @@ export class ProjectInitializer {
 		logger.groupEnd()
 		if (migrations) {
 			logger.group(`Executing project migrations`)
-			await this.projectMigrator.migrate(db, project, migrations, logger.write.bind(logger))
+			const stages = await db.queryHandler.fetch(new StagesQuery())
+			await this.projectMigrator.migrate(db, stages, migrations, logger.write.bind(logger))
 			logger.groupEnd()
 		}
 	}

package/src/model/ProjectTruncateExecutor.ts

@@ -1,9 +1,10 @@
 import { DatabaseContext } from './database'
 import { ProjectConfig } from '../types'
 import { TruncateEventsCommand } from './commands'
-import { formatSchemaName, getJunctionTables } from './helpers'
+import { getJunctionTables } from './helpers'
 import { Schema } from '@contember/schema'
 import { wrapIdentifier } from '@contember/database'
+import { StagesQuery } from './queries'
 
 export class ProjectTruncateExecutor {
 	public async truncateProject(db: DatabaseContext, project: ProjectConfig, schema: Schema) {
@@ -12,9 +13,9 @@ export class ProjectTruncateExecutor {
 			const tableNames = Object.values(schema.model.entities).filter(it => !it.view).map(it => it.tableName)
 			const junctionTableNames = getJunctionTables(schema.model).map(it => it.tableName)
 			const allTableNames = [...tableNames, ...junctionTableNames]
-			for (const stage of project.stages) {
-				const schemaName = formatSchemaName(stage)
-				const wrappedNames = allTableNames.map(it => `${wrapIdentifier(schemaName)}.${wrapIdentifier(it)}`)
+			const stages = await db.queryHandler.fetch(new StagesQuery())
+			for (const stage of stages) {
+				const wrappedNames = allTableNames.map(it => `${wrapIdentifier(stage.schema)}.${wrapIdentifier(it)}`)
 				await trx.client.query(`TRUNCATE ${wrappedNames}`)
 			}
 			await trx.client.query('SET CONSTRAINTS ALL IMMEDIATE')

package/src/model/commands/stages/{CreateOrUpdateStageCommand.ts → CreateStageCommand.ts}

@@ -1,26 +1,23 @@
-import { ConflictActionType, InsertBuilder, wrapIdentifier } from '@contember/database'
-import { formatSchemaName } from '../../helpers'
+import { InsertBuilder, wrapIdentifier } from '@contember/database'
 import { StageConfig } from '../../../types'
 import { Command } from '../Command'
+import { formatSchemaName } from '../../helpers'
 
-export class CreateOrUpdateStageCommand implements Command<boolean> {
+export class CreateStageCommand implements Command<void> {
 	constructor(private readonly stage: StageConfig) {}
 
-	public async execute({ db, providers }: Command.Args): Promise<boolean> {
-		const result = await InsertBuilder.create()
+	public async execute({ db, providers }: Command.Args): Promise<void> {
+		const schemaName = this.stage.schema ?? formatSchemaName(this.stage)
+		await InsertBuilder.create()
 			.into('stage')
 			.values({
 				id: providers.uuid(),
 				name: this.stage.name,
 				slug: this.stage.slug,
-			})
-			.onConflict(ConflictActionType.update, ['slug'], {
-				name: this.stage.name,
+				schema: schemaName,
 			})
 			.execute(db)
 
-		await db.query('CREATE SCHEMA IF NOT EXISTS ' + wrapIdentifier(formatSchemaName(this.stage)))
-
-		return result > 0
+		await db.query('CREATE SCHEMA IF NOT EXISTS ' + wrapIdentifier(schemaName))
 	}
 }

package/src/model/commands/stages/index.ts

@@ -1,2 +1,2 @@
-export * from './CreateOrUpdateStageCommand'
+export * from './CreateStageCommand'
 export * from './TruncateStagesCommand'

package/src/model/database/DatabaseContext.ts

@@ -2,7 +2,6 @@ import { Client, Connection, DatabaseQueryable } from '@contember/database'
 import { QueryHandler } from '@contember/queryable'
 import { UuidProvider } from '../../utils'
 import { CommandBus } from '../commands'
-import { setupSystemVariables } from '../helpers'
 
 export interface DatabaseContext<ConnectionType extends Connection.ConnectionLike = Connection.ConnectionLike> {
 	client: Client<ConnectionType>
@@ -14,8 +13,8 @@ export interface DatabaseContext<ConnectionType extends Connection.ConnectionLik
 export class DatabaseContextFactory {
 	constructor(private readonly client: Client, private readonly providers: UuidProvider) {}
 
-	public create(identityId: string | undefined): DatabaseContext {
-		return createDatabaseContext(this.client, identityId, this.providers)
+	public create(): DatabaseContext {
+		return createDatabaseContext(this.client, this.providers)
 	}
 
 	public withClient(client: Client) {
@@ -25,7 +24,6 @@ export class DatabaseContextFactory {
 
 const createDatabaseContext = <ConnectionType extends Connection.ConnectionLike = Connection.ConnectionLike>(
 	client: Client<ConnectionType>,
-	identityId: string | undefined,
 	providers: UuidProvider,
 ): DatabaseContext<ConnectionType> => ({
 	client,
@@ -33,10 +31,7 @@ const createDatabaseContext = <ConnectionType extends Connection.ConnectionLike
 	transaction: cb =>
 		client.transaction(async client => {
 			await client.query(Connection.REPEATABLE_READ)
-			if (identityId) {
-				await setupSystemVariables(client, identityId, providers)
-			}
-			return cb(createDatabaseContext(client, undefined, providers))
+			return cb(createDatabaseContext(client, providers))
 		}),
 	commandBus: new CommandBus(client, providers),
 })

package/src/model/dependencies/index.ts

@@ -1,2 +1 @@
-export * from './content'
 export * from './tenant'

package/src/model/dependencies/tenant/IdentityFetcher.ts

@@ -1,7 +1,7 @@
 import { Client } from '@contember/database'
 
 export interface IdentityFetcher {
-	fetchIdentities(client: Client, ids: string[]): Promise<TenantIdentity[]>
+	fetchIdentities(ids: string[]): Promise<TenantIdentity[]>
 }
 
 export type TenantIdentity = PersonIdentity | ApiKeyIdentity

package/src/model/dtos/Stage.ts

@@ -1,10 +1,7 @@
 export interface Stage {
+	readonly id: string
 	readonly name: string
 	readonly slug: string
+	readonly schema: string
 }
 
-export interface StageWithId extends Stage {
-	readonly id: string
-}
-
-export type StageWithoutEvent = Pick<Stage, Exclude<keyof Stage, 'event_id'>>

package/src/model/events/EventResponseBuilder.ts

@@ -4,19 +4,18 @@ import { assertNever } from '../../utils'
 import { IdentityFetcher } from '../dependencies'
 import { formatIdentity } from './identityUtils'
 import { appendCreateSpecificData, appendDeleteSpecificData, appendUpdateSpecificData } from './EventResponseHelper'
-import { Client } from '@contember/database'
 
 export class EventResponseBuilder {
 	constructor(private readonly identityFetcher: IdentityFetcher) {}
 
-	public async buildResponse(tenantDb: Client, events: AnyEvent[]): Promise<(CreateEvent | DeleteEvent | UpdateEvent)[]> {
+	public async buildResponse(events: AnyEvent[]): Promise<(CreateEvent | DeleteEvent | UpdateEvent)[]> {
 		const apiEventTypeMapping = {
 			[EventType.create]: ApiEventType.Create,
 			[EventType.update]: ApiEventType.Update,
 			[EventType.delete]: ApiEventType.Delete,
 		}
 		const identityIds = events.map(it => it.identityId).filter((it, index, ids) => ids.indexOf(it) === index)
-		const identities = await this.identityFetcher.fetchIdentities(tenantDb, identityIds)
+		const identities = await this.identityFetcher.fetchIdentities(identityIds)
 		const identitiesMap = Object.fromEntries(identities.map(it => [it.identityId, it]))
 
 		return events.map(it => {

package/src/model/migrations/ProjectMigrator.ts

@@ -3,11 +3,10 @@ import { Client, QueryError, wrapIdentifier } from '@contember/database'
 import { formatSchemaName } from '../helpers'
 import { Schema } from '@contember/schema'
 import { SaveMigrationCommand } from '../commands'
-import { StageWithoutEvent } from '../dtos'
+import { Stage } from '../dtos'
 import { DatabaseContext } from '../database'
 import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
 import { MigrateErrorCode } from '../../schema'
-import { ProjectConfig } from '../../types'
 import { SchemaVersionBuilder } from './SchemaVersionBuilder'
 
 export class ProjectMigrator {
@@ -19,7 +18,7 @@ export class ProjectMigrator {
 
 	public async migrate(
 		db: DatabaseContext,
-		project: ProjectConfig,
+		stages: Stage[],
 		migrationsToExecute: readonly Migration[],
 		logger: (message: string) => void,
 		ignoreOrder: boolean = false,
@@ -39,11 +38,12 @@ export class ProjectMigrator {
 			for (const modification of migration.modifications) {
 				[schema] = await this.applyModification(
 					db.client,
-					project.stages,
+					stages,
 					schema,
 					modification,
 					formatVersion,
 					migration.version,
+					db.client.schema,
 				)
 			}
 			await db.commandBus.execute(new SaveMigrationCommand(migration))
@@ -68,7 +68,7 @@ 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)
+			const described = await this.migrationDescriber.describeModifications(schema, migration, 'system') // system schema name not important here
 			if (described.length === 0) {
 				continue
 			}
@@ -86,25 +86,26 @@ export class ProjectMigrator {
 
 	private async applyModification(
 		db: Client,
-		stages: StageWithoutEvent[],
+		stages: Stage[],
 		schema: Schema,
 		modification: Migration.Modification,
 		formatVersion: number,
 		migrationVersion: string,
+		systemSchema: string,
 	): Promise<[Schema]> {
 		const {
 			sql,
 			schema: newSchema,
 			handler,
-		} = await this.migrationDescriber.describeModification(schema, modification, formatVersion)
+		} = await this.migrationDescriber.describeModification(schema, modification, { systemSchema, formatVersion })
 		for (const stage of stages) {
 			await this.executeOnStage(db, stage, sql, migrationVersion)
 		}
 		return [newSchema]
 	}
 
-	private async executeOnStage(db: Client, stage: StageWithoutEvent, sql: string, migrationVersion: string) {
-		await db.query('SET search_path TO ' + wrapIdentifier(formatSchemaName(stage)))
+	private async executeOnStage(db: Client, stage: Stage, sql: string, migrationVersion: string) {
+		await db.query('SET search_path TO ' + wrapIdentifier(stage.schema))
 		try {
 			await db.query(sql)
 		} catch (e) {

package/src/model/migrations/index.ts

@@ -1,5 +1,4 @@
 export * from './ExecutedMigrationsResolver'
 export * from './MigrationAlterer'
-export * from './MigrationExecutor'
 export * from './ProjectMigrator'
 export * from './SchemaVersionBuilder'

package/src/model/queries/stages/StageBySlugQuery.ts

@@ -1,6 +1,6 @@
 import { DatabaseQuery, DatabaseQueryable } from '@contember/database'
-import { StageWithId } from '../../dtos'
 import { prepareStageQueryBuilder } from './StageQueryFactory'
+import { Stage } from '../../dtos'
 
 class StageBySlugQuery extends DatabaseQuery<StageBySlugQuery.Result> {
 	constructor(private readonly slug: string) {
@@ -17,7 +17,7 @@ class StageBySlugQuery extends DatabaseQuery<StageBySlugQuery.Result> {
 }
 
 namespace StageBySlugQuery {
-	export type Result = null | StageWithId
+	export type Result = null | Stage
 }
 
 export { StageBySlugQuery }

package/src/model/queries/stages/StageQueryFactory.ts

@@ -1,10 +1,11 @@
 import { SelectBuilder } from '@contember/database'
-import { StageWithId } from '../../dtos'
+import { Stage } from '../../dtos'
 
 export const prepareStageQueryBuilder = () => {
-	return SelectBuilder.create<StageWithId>() //
+	return SelectBuilder.create<Stage>()
 		.select('id')
 		.select('name')
 		.select('slug')
+		.select('schema')
 		.from('stage')
 }