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

package/package.json

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

package/src/SystemContainer.ts

@@ -6,19 +6,15 @@ import {
 	SchemaDiffer,
 	SchemaMigrator,
 } from '@contember/schema-migrations'
-import { MigrationsRunner } from '@contember/database-migrations'
-import { Connection } from '@contember/database'
 import {
 	EventResponseBuilder,
 	ExecutedMigrationsResolver,
 	IdentityFetcher,
 	MigrationAlterer,
 	PermissionsFactory,
-	ProjectInitializer,
 	ProjectMigrator,
 	ProjectTruncateExecutor,
 	SchemaVersionBuilder,
-	StageCreator,
 } from './model'
 import { UuidProvider } from './utils'
 import {
@@ -31,7 +27,6 @@ import {
 	SystemResolverContextFactory,
 	TruncateMutationResolver,
 } from './resolvers'
-import { getSystemMigrations, SystemMigrationArgs } from './migrations'
 import { EventOldValuesResolver } from './resolvers/types'
 
 export interface SystemContainer {
@@ -39,11 +34,8 @@ export interface SystemContainer {
 	authorizator: Authorizator
 	resolverContextFactory: SystemResolverContextFactory
 	schemaVersionBuilder: SchemaVersionBuilder
-	projectInitializer: ProjectInitializer
 }
 
-export type SystemDbMigrationsRunnerFactory = (db: Connection.ConnectionLike, schema: string) => MigrationsRunner<SystemMigrationArgs>
-
 type Args = {
 	identityFetcher: IdentityFetcher
 }
@@ -63,7 +55,6 @@ export class SystemContainerFactory {
 				'authorizator',
 				'resolverContextFactory',
 				'schemaVersionBuilder',
-				'projectInitializer',
 			)
 	}
 	public createBuilder({ identityFetcher }: Args) {
@@ -74,8 +65,6 @@ export class SystemContainerFactory {
 				this.modificationHandlerFactory)
 			.addService('identityFetcher', () =>
 				identityFetcher)
-			.addService('systemDbMigrationsRunnerFactory', (): SystemDbMigrationsRunnerFactory =>
-				(db, schema) => new MigrationsRunner(db, schema, getSystemMigrations))
 			.addService('schemaMigrator', ({ modificationHandlerFactory }) =>
 				new SchemaMigrator(modificationHandlerFactory))
 			.addService('executedMigrationsResolver', ({}) =>
@@ -92,8 +81,6 @@ export class SystemContainerFactory {
 				new MigrationDescriber(modificationHandlerFactory))
 			.addService('projectMigrator', ({ migrationDescriber, schemaVersionBuilder, executedMigrationsResolver }) =>
 				new ProjectMigrator(migrationDescriber, schemaVersionBuilder, executedMigrationsResolver))
-			.addService('stageCreator', () =>
-				new StageCreator())
 			.addService('projectTruncateExecutor', () =>
 				new ProjectTruncateExecutor())
 			.addService('migrationAlterer', () =>
@@ -110,8 +97,6 @@ export class SystemContainerFactory {
 				new TruncateMutationResolver(projectTruncateExecutor))
 			.addService('migrationAlterMutationResolver', ({ migrationAlterer }) =>
 				new MigrationAlterMutationResolver(migrationAlterer))
-			.addService('projectInitializer', ({ projectMigrator, stageCreator, systemDbMigrationsRunnerFactory, schemaVersionBuilder }) =>
-				new ProjectInitializer(projectMigrator, stageCreator, systemDbMigrationsRunnerFactory, schemaVersionBuilder))
 			.addService('eventsQueryResolver', ({ eventResponseBuilder }) =>
 				new EventsQueryResolver(eventResponseBuilder))
 			.addService('eventOldValuesResolver', () =>

package/src/bin/runMigrations.ts

@@ -0,0 +1,35 @@
+import { SystemMigrationsRunner } from '../migrations'
+import { DatabaseContextFactory, emptyVersionedSchema, SchemaVersionBuilder } from '../model'
+import { Connection } from '@contember/database'
+import { createLogger, PrettyPrintLoggerHandler } from '@contember/logger'
+
+;(async () => {
+	const dbConfig = {
+		database: process.env.PGDATABASE as string,
+		host: process.env.PGHOST as string,
+		password: process.env.PGPASSWORD as string,
+		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, {
+			uuid: () => {
+				throw new Error()
+			},
+		}),
+		{ db: dbConfig, slug: 'test', stages: [] },
+		'system',
+		{
+			buildSchema: () => Promise.resolve(emptyVersionedSchema),
+		} as unknown as SchemaVersionBuilder,
+		{},
+	)
+	// eslint-disable-next-line no-console
+	await migrationsRunner.run(createLogger(new PrettyPrintLoggerHandler(process.stderr)))
+})().catch(e => {
+	// eslint-disable-next-line no-console
+	console.error(e)
+	process.exit(1)
+})

package/src/index.ts

@@ -12,12 +12,10 @@ export {
 	ProjectInitializer,
 	ProjectMigrator,
 	SchemaVersionBuilder,
-	setupSystemVariables,
 	Stage,
 	StageBySlugQuery,
 	StageCreator,
 	StagesQuery,
-	unnamedIdentity,
 	VersionedSchema,
 } from './model'
 export * from './SystemContainer'

package/src/migrations/{2018-08-04-102200-init.sql → 2018-08-04-102200-init.ts}

@@ -1,3 +1,6 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 CREATE DOMAIN "event_type" AS TEXT CHECK (
   VALUE IN ('init', 'create', 'update', 'delete', 'run_migration')
 );
@@ -26,3 +29,8 @@ CREATE TABLE "stage" (
   "event_id" uuid NOT NULL REFERENCES "event"("id") ON DELETE RESTRICT
 );
 CREATE INDEX "system_stage_event_id" ON "stage"("event_id");
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/{2018-08-05-130501-trigger-event-function.sql → 2018-08-05-130501-trigger-event-function.ts}

@@ -1,3 +1,6 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 DO
 $BLOCK$
     BEGIN
@@ -88,3 +91,8 @@ CREATE FUNCTION "trigger_event"() RETURNS TRIGGER AS $$
   END;
 
 $$ LANGUAGE plpgsql;
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/{2019-01-14-143432-event-trx-id.sql → 2019-01-14-143432-event-trx-id.ts}

@@ -1,3 +1,6 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 ALTER TABLE "event"
 	ADD COLUMN transaction_id uuid DEFAULT NULL;
 UPDATE "event"
@@ -6,3 +9,8 @@ SET transaction_id = uuid_generate_v4();
 ALTER TABLE "event"
 	ALTER "transaction_id" SET DEFAULT current_setting('system.transaction_id')::uuid,
 	ALTER "transaction_id" SET NOT NULL;
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/{2019-02-04-154500-event-rebase.sql → 2019-02-04-154500-event-rebase.ts}

@@ -1,3 +1,7 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
+
 DROP FUNCTION IF EXISTS rebase_events_unsafe(head UUID, oldBase UUID, newBase UUID, appliedEvents UUID[]);
 
 CREATE OR REPLACE FUNCTION rebase_events_unsafe(head UUID, oldBase UUID, newBase UUID, appliedEvents UUID[]) RETURNS TABLE (
@@ -47,3 +51,8 @@ FROM with_ids_by_window
 ORDER BY number DESC
 $$
 	LANGUAGE SQL;
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/2019-03-18-104147-event-run-migration-struct.ts

@@ -0,0 +1,11 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
+UPDATE event
+SET data = jsonb_build_object('version', coalesce(substring(data ->> 'file', 0, 17), data ->> 'version'))
+WHERE type = 'run_migration';
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/{2019-07-29-103000-trigger-event-function-fix.sql → 2019-07-29-103000-trigger-event-function-fix.ts}

@@ -1,3 +1,6 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 CREATE OR REPLACE FUNCTION "trigger_event"() RETURNS TRIGGER AS $$
 
   DECLARE new_event_id uuid := uuid_generate_v4();
@@ -55,3 +58,8 @@ CREATE OR REPLACE FUNCTION "trigger_event"() RETURNS TRIGGER AS $$
   END;
 
 $$ LANGUAGE plpgsql;
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/{2019-11-28-100000-missing-setting-fallback.sql → 2019-11-28-100000-missing-setting-fallback.ts}

@@ -1,3 +1,6 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 ALTER TABLE "event"
     ALTER COLUMN "identity_id" SET DEFAULT
         coalesce(
@@ -10,3 +13,8 @@ ALTER TABLE "event"
             nullif(current_setting('system.transaction_id', true), '')::uuid,
             set_config('system.transaction_id', uuid_generate_v4()::text, true)::uuid
         );
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/{2021-03-23-110000-timestamp-fix.sql → 2021-03-23-110000-timestamp-fix.ts}

@@ -1,6 +1,14 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 ALTER TABLE "schema_migration"
 	ALTER "executed_at" TYPE TIMESTAMPTZ,
 	ALTER "executed_at" SET DEFAULT now();
 
 ALTER TABLE "event"
 	ALTER "created_at" TYPE TIMESTAMPTZ;
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

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

@@ -42,7 +42,7 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs<Sy
 		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, (uuid_generate_v4())::TEXT, TRUE))::UUID) NOT NULL
+			(SET_CONFIG('system.transaction_id'::TEXT, ("uuid_generate_v4"())::TEXT, TRUE))::UUID) NOT NULL
 		)
 	`)
 	builder.sql(`
@@ -210,7 +210,7 @@ export default async function (builder: MigrationBuilder, args: MigrationArgs<Sy
 
 			INSERT INTO "event_data" ("id", "type", "table_name", "row_ids", "values", "created_at", schema_id, identity_id)
 			VALUES (
-				uuid_generate_v4(),
+				"uuid_generate_v4"(),
 				new_event_type,
 				table_name,
 				primary_values,

package/src/migrations/{2021-12-21-155500-events-up.sql → 2021-12-21-155500-events-up.ts}

@@ -1,6 +1,14 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 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;
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/{2022-02-08-132600-fn-search-path.sql → 2022-02-08-132600-fn-search-path.ts}

@@ -1,3 +1,6 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 DO LANGUAGE plpgsql
 $$
 	BEGIN
@@ -5,3 +8,8 @@ $$
 		EXECUTE FORMAT('ALTER FUNCTION trigger_event() SET SEARCH_PATH = %s', QUOTE_IDENT(CURRENT_SCHEMA()));
 	END
 $$
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

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

@@ -0,0 +1,10 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
+DROP FUNCTION rebase_events_unsafe(head UUID, oldbase UUID, newbase UUID, appliedevents UUID[]);
+DROP FUNCTION statement_trigger_event();
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/{2022-02-08-144400-dynamic-stage-schema.sql → 2022-02-08-144400-dynamic-stage-schema.ts}

@@ -1,3 +1,6 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
 ALTER TABLE stage
 	ADD COLUMN schema TEXT UNIQUE;
 UPDATE stage
@@ -39,3 +42,8 @@ $$
 		EXECUTE FORMAT('ALTER FUNCTION trigger_event_commit() SET SEARCH_PATH = %s', QUOTE_IDENT(CURRENT_SCHEMA()));
 	END
 $$
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

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

@@ -0,0 +1,66 @@
+import { MigrationArgs, MigrationBuilder } from '@contember/database-migrations'
+import { wrapIdentifier } from '@contember/database'
+import { SystemMigrationArgs } from './types'
+import { acceptFieldVisitor, NamingHelper } 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
+	for (const entity of Object.values(schema.model.entities)) {
+		for (const field of Object.values(entity.fields)) {
+			const result = acceptFieldVisitor<null | {
+				relation: Model.OneHasOneOwningRelation | Model.ManyHasOneRelation
+				targetEntity: Model.Entity
+			}>(schema.model, entity, field, {
+				visitManyHasOne: ({ entity, relation, targetEntity }) => {
+					return { relation, entity, targetEntity }
+				},
+				visitOneHasOneOwning: ({ entity, relation, targetEntity }) => {
+					return { relation, entity, targetEntity }
+				},
+				visitOneHasOneInverse: () => null,
+				visitManyHasManyInverse: () => null,
+				visitManyHasManyOwning: () => null,
+				visitOneHasMany: () => null,
+				visitColumn: () => null,
+			})
+			if (!result) {
+				continue
+			}
+			const { targetEntity, relation } = result
+			if (entity.view || targetEntity.view) {
+				continue
+			}
+			if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
+				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 }
+
+				builder.dropConstraint(tableName, fkName)
+
+				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,
+				})
+			}
+		}
+	}
+}

package/src/migrations/runner.ts

@@ -1,17 +1,81 @@
-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'
-import { SystemMigrationArgs } from './types'
+import { MigrationGroup, MigrationsRunner as DbMigrationsRunner } from '@contember/database-migrations'
+import _20180804102200init from './2018-08-04-102200-init'
+import _20180805130501triggereventfunction from './2018-08-05-130501-trigger-event-function'
+import _20190114143432eventtrxid from './2019-01-14-143432-event-trx-id'
+import _20190204154500eventrebase from './2019-02-04-154500-event-rebase'
+import _20190318104147eventrunmigrationstruct from './2019-03-18-104147-event-run-migration-struct'
+import _20190729103000triggereventfunctionfix from './2019-07-29-103000-trigger-event-function-fix'
+import _20191128100000missingsettingfallback from './2019-11-28-100000-missing-setting-fallback'
+import _20200327130000projectmigrations from './2020-03-27-130000-project-migrations'
+import _20200506150000composedprimary from './2020-05-06-150000-composed-primary'
+import _20200601103000eventtriggerperf from './2020-06-01-103000-event-trigger-perf'
+import _20210323110000timestampfix from './2021-03-23-110000-timestamp-fix'
+import _20210507155800eventlogrework from './2021-05-07-155800-event-log-rework'
+import _202105191232000eventlogfixconstraint from './2021-05-19-1232000-event-log-fix-constraint'
+import _20211221155500eventsup from './2021-12-21-155500-events-up'
+import _20220208132600fnsearchpath from './2022-02-08-132600-fn-search-path'
+import _20220208140500dropdeadcode from './2022-02-08-140500-drop-deadcode'
+import _20220208144400dynamicstageschema from './2022-02-08-144400-dynamic-stage-schema'
+import _20221003110000tableondelete from './2022-10-03-110000-table-on-delete'
+import snapshot from './snapshot'
 
-export const getSystemMigrations = (): Promise<Migration<SystemMigrationArgs>[]> => {
-	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),
-		new Migration('2020-06-01-103000-event-trigger-perf', eventTriggerPerf),
-		new Migration('2021-05-07-155800-event-log-rework', eventLogRework),
-		new Migration('2021-05-19-1232000-event-log-fix-constraint', eventLogFixConstraint),
-	])
+import { Client, Connection, createDatabaseIfNotExists, DatabaseConfig } 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'
+
+const migrations = {
+	'2018-08-04-102200-init': _20180804102200init,
+	'2018-08-05-130501-trigger-event-function': _20180805130501triggereventfunction,
+	'2019-01-14-143432-event-trx-id': _20190114143432eventtrxid,
+	'2019-02-04-154500-event-rebase': _20190204154500eventrebase,
+	'2019-03-18-104147-event-run-migration-struct': _20190318104147eventrunmigrationstruct,
+	'2019-07-29-103000-trigger-event-function-fix': _20190729103000triggereventfunctionfix,
+	'2019-11-28-100000-missing-setting-fallback': _20191128100000missingsettingfallback,
+	'2020-03-27-130000-project-migrations': _20200327130000projectmigrations,
+	'2020-05-06-150000-composed-primary': _20200506150000composedprimary,
+	'2020-06-01-103000-event-trigger-perf': _20200601103000eventtriggerperf,
+	'2021-03-23-110000-timestamp-fix': _20210323110000timestampfix,
+	'2021-05-07-155800-event-log-rework': _20210507155800eventlogrework,
+	'2021-05-19-1232000-event-log-fix-constraint': _202105191232000eventlogfixconstraint,
+	'2021-12-21-155500-events-up': _20211221155500eventsup,
+	'2022-02-08-132600-fn-search-path': _20220208132600fnsearchpath,
+	'2022-02-08-140500-drop-deadcode': _20220208140500dropdeadcode,
+	'2022-02-08-144400-dynamic-stage-schema': _20220208144400dynamicstageschema,
+	'2022-10-03-110000-table-on-delete': _20221003110000tableondelete,
+}
+
+
+export class SystemMigrationsRunner {
+	constructor(
+		private readonly databaseContextFactory: DatabaseContextFactory,
+		private readonly project: ProjectConfig & { db: DatabaseConfig },
+		private readonly schema: string,
+		private readonly schemaVersionBuilder: SchemaVersionBuilder,
+		private readonly migrationGroups: Record<string, MigrationGroup<unknown>>,
+	) {
+	}
+	async run(logger: Logger) {
+		await createDatabaseIfNotExists(this.project.db, message => typeof message === 'string' ? logger.warn(message) : logger.error(message))
+		const singleConnection = Connection.createSingle(this.project.db, err => logger.error(err))
+		await singleConnection.scope(async connection => {
+			const schemaResolver = (connection: Connection.ConnectionLike) => {
+				const dbContextMigrations = this.databaseContextFactory.create(connection)
+				return this.schemaVersionBuilder.buildSchema(dbContextMigrations)
+			}
+			const migrationResolver = new GroupMigrationsResolver(
+				new SnapshotMigrationResolver(snapshot, migrations),
+				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,
+			})
+		})
+		await singleConnection.end()
+	}
 }

package/src/migrations/snapshot-factory.ts

@@ -0,0 +1,45 @@
+import { MigrationArgs, MigrationBuilder } from '@contember/database-migrations'
+import { SystemMigrationArgs } from './types'
+
+export const snapshotMigration = (sqlFactory: (args: { randomUuidFn: string }) => string) => {
+	return async (builder: MigrationBuilder, args: MigrationArgs<SystemMigrationArgs>) => {
+		const hasGenRandomUuid = await args.connection.query(`
+            SELECT 1
+            FROM pg_proc
+            JOIN pg_namespace ON pg_proc.pronamespace = pg_namespace.oid
+            WHERE pg_namespace.nspname = 'pg_catalog' AND pg_proc.proname = 'gen_random_uuid'
+		`)
+		let randomUuidFn: string = 'uuid_generate_v4'
+		if (hasGenRandomUuid.rowCount > 0) {
+			randomUuidFn = 'gen_random_uuid'
+		} else {
+			const hasUuidGenV4 = await args.connection.query(`
+                SELECT 1
+                FROM pg_proc
+                JOIN pg_namespace ON pg_proc.pronamespace = pg_namespace.oid
+                WHERE pg_namespace.nspname = 'pg_catalog' AND pg_proc.proname = 'uuid_generate_v4'
+			`)
+			if (hasUuidGenV4.rowCount === 0) {
+				builder.sql(`
+				CREATE FUNCTION "uuid_generate_v4"() RETURNS "uuid"
+    			LANGUAGE "sql"
+    			AS $$
+            		SELECT OVERLAY(OVERLAY(md5(random()::TEXT || ':' || clock_timestamp()::TEXT) PLACING '4' FROM 13) PLACING
+                           to_hex(floor(random() * (11 - 8 + 1) + 8)::INT)::TEXT FROM 17)::UUID;
+            	$$;
+            `)
+			}
+		}
+		const sql = sqlFactory({ randomUuidFn })
+		builder.sql(sql)
+
+		builder.sql(`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/snapshot-template-end.txt

@@ -0,0 +1 @@
+`)

package/src/migrations/snapshot-template-start.txt

@@ -0,0 +1,2 @@
+import { snapshotMigration } from './snapshot-factory'
+export default snapshotMigration(({randomUuidFn}) => `