@contember/engine-system-api 1.2.1 → 1.3.0-alpha.4

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/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/migrations/ProjectMigrator.ts

@@ -29,7 +29,7 @@ export class ProjectMigrator {
 		if (migrationsToExecute.length === 0) {
 			return
 		}
-		let { version, notNormalized, ...schema }  = await this.schemaVersionBuilder.buildSchema(db)
+		let { version, notNormalized, id, ...schema }  = await this.schemaVersionBuilder.buildSchema(db)
 		const validated = await this.validateMigrations(db, schema, version, migrationsToExecute, { ignoreOrder, skipExecuted })
 
 		const sorted = [...validated].sort((a, b) => a.version.localeCompare(b.version))

package/src/model/migrations/SchemaVersionBuilder.ts

@@ -5,9 +5,9 @@ import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
 import { DatabaseContext } from '../database'
 import { normalizeSchema } from '@contember/schema-utils'
 
-export type VersionedSchema = Schema & { version: string; notNormalized: Schema & { version: string } }
+export type VersionedSchema = Schema & { version: string; id: number; notNormalized: Schema & { version: string; id: number } }
 
-const emptyVersionedSchema = { ...normalizeSchema(emptySchema), version: '', notNormalized: { ...emptySchema, version: '' } }
+export const emptyVersionedSchema = { ...normalizeSchema(emptySchema), version: '', id: -1, notNormalized: { ...emptySchema, version: '', id: -1 } }
 
 export class SchemaVersionBuilder {
 	constructor(
@@ -25,6 +25,7 @@ export class SchemaVersionBuilder {
 			(schema, migration) => ({
 				...this.schemaMigrator.applyModifications(schema, migration.modifications, migration.formatVersion),
 				version: migration.version,
+				id: migration.id,
 			}),
 			after?.notNormalized ?? emptyVersionedSchema.notNormalized,
 		)

package/src/model/queries/events/EventQueryHelpers.ts

@@ -1,4 +1,4 @@
-import { AnyEvent, CreateEvent, DeleteEvent, EventType, UpdateEvent } from '@contember/engine-common'
+import { ContentEvent, CreateEvent, DeleteEvent, EventType, UpdateEvent } from '../../events'
 import { assertNever } from '../../../utils'
 
 export type EventRow = {
@@ -13,7 +13,7 @@ export type EventRow = {
 	transaction_id: string
 }
 
-export const createEventsFromRows = (rows: EventRow[]): AnyEvent[] => {
+export const createEventsFromRows = (rows: EventRow[]): ContentEvent[] => {
 	return rows.map(event => {
 		switch (event.type) {
 			case EventType.create:

package/src/model/queries/events/EventsQuery.ts

@@ -6,11 +6,11 @@ import {
 	SelectBuilder,
 	SelectBuilderSpecification, Value,
 } from '@contember/database'
-import { AnyEvent, ContentEvent } from '@contember/engine-common'
+import { ContentEvent } from '../../events'
 import { EventsFilter, EventsFilterDate, EventsOrder } from '../../../schema'
 import { createEventsFromRows, EventRow } from './EventQueryHelpers'
 
-export class EventsQuery extends DatabaseQuery<AnyEvent[]> {
+export class EventsQuery extends DatabaseQuery<ContentEvent[]> {
 	constructor(
 		private readonly filter: EventsFilter,
 		private readonly order: EventsOrder,

package/src/model/queries/migrations/ExecutedMigrationsQueryHelper.ts

@@ -2,9 +2,10 @@ import { SelectBuilder } from '@contember/database'
 import { ExecutedMigration } from '../../dtos'
 import { VERSION_INITIAL } from '@contember/schema-migrations'
 
-type ExecutedMigrationRow = { name: string; migration: any; checksum: string; executed_at: Date }
+type ExecutedMigrationRow = { id: number; name: string; migration: any; checksum: string; executed_at: Date }
 export const createExecutedMigrationQueryBuilder = () =>
 	SelectBuilder.create<ExecutedMigrationRow>()
+		.select('id')
 		.select('name')
 		.select('migration')
 		.select('checksum')
@@ -14,6 +15,7 @@ export const createExecutedMigrationQueryBuilder = () =>
 
 export const createExecutedMigrationDto = (row: ExecutedMigrationRow) =>
 	new ExecutedMigration(
+		row.id,
 		row.name,
 		row.migration.formatVersion || VERSION_INITIAL,
 		row.migration.modifications,

package/src/tsconfig.json

@@ -5,38 +5,15 @@
 		"esModuleInterop": true
 	},
 	"references": [
-		{
-			"path": "../../authorization/src"
-		},
-		{
-			"path": "../../database/src"
-		},
-		{
-			"path": "../../database-migrations/src"
-		},
-		{
-			"path": "../../engine-common/src"
-		},
-		{
-			"path": "../../graphql-utils/src"
-		},
-		{
-			"path": "../../logger/src"
-		},
-		{
-			"path": "../../queryable/src"
-		},
-		{
-			"path": "../../schema/src"
-		},
-		{
-			"path": "../../schema-utils/src"
-		},
-		{
-			"path": "../../schema-migrations/src"
-		},
-		{
-			"path": "../../dic/src"
-		}
+		{ "path": "../../authorization/src" },
+		{ "path": "../../database/src" },
+		{ "path": "../../database-migrations/src" },
+		{ "path": "../../graphql-utils/src" },
+		{ "path": "../../logger/src" },
+		{ "path": "../../queryable/src" },
+		{ "path": "../../schema/src" },
+		{ "path": "../../schema-utils/src" },
+		{ "path": "../../schema-migrations/src" },
+		{ "path": "../../dic/src" }
 	]
 }

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

@@ -0,0 +1,42 @@
+import migration from '../../../src/migrations/2022-10-03-110000-table-on-delete'
+import { createMigrationBuilder } from '@contember/database-migrations'
+import { assert, test } from 'vitest'
+import { SchemaBuilder } from '@contember/schema-definition'
+import { emptySchema } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+import { createConnectionMock } from '@contember/database-tester'
+
+
+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,
+		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_87ef9a";
+ALTER TABLE "stage_live"."post"
+  ADD CONSTRAINT "fk_post_author_id_87ef9a" FOREIGN KEY ("author_id") REFERENCES "stage_live"."author"("id") ON DELETE SET NULL DEFERRABLE INITIALLY IMMEDIATE;
+`,
+	)
+})
+

package/tests/tsconfig.json

@@ -5,11 +5,7 @@
 		"esModuleInterop": true
 	},
 	"references": [
-		{
-			"path": "../src"
-		},
-		{
-			"path": "../../engine-api-tester/src"
-		}
+		{ "path": "../src" },
+		{ "path": "../../engine-api-tester/src" }
 	]
 }

package/tsconfig.json

@@ -2,11 +2,7 @@
 	"files": [],
 	"include": [],
 	"references": [
-		{
-			"path": "./src"
-		},
-		{
-			"path": "./tests"
-		}
+		{ "path": "./src" },
+		{ "path": "./tests" }
 	]
 }

package/dist/src/model/helpers/SystemVariablesSetupHelper.d.ts

@@ -1,5 +0,0 @@
-import { Client } from '@contember/database';
-import { UuidProvider } from '../../utils';
-export declare const unnamedIdentity = "00000000-0000-0000-0000-000000000000";
-export declare function setupSystemVariables(db: Client, identityId: string, providers: UuidProvider): Promise<void>;
-//# sourceMappingURL=SystemVariablesSetupHelper.d.ts.map

package/dist/src/model/helpers/SystemVariablesSetupHelper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SystemVariablesSetupHelper.d.ts","sourceRoot":"","sources":["../../../../src/model/helpers/SystemVariablesSetupHelper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,eAAO,MAAM,eAAe,yCAAyC,CAAA;AAErE,wBAAsB,oBAAoB,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,iBAQjG"}

package/dist/src/model/helpers/SystemVariablesSetupHelper.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupSystemVariables = exports.unnamedIdentity = void 0;
-exports.unnamedIdentity = '00000000-0000-0000-0000-000000000000';
-async function setupSystemVariables(db, identityId, providers) {
-    await Promise.all([
-        await db.query('SELECT set_config(?, ?, false)', [
-            'tenant.identity_id',
-            identityId,
-        ]),
-        await db.query('SELECT set_config(?, ?, false)', ['system.transaction_id', providers.uuid()]),
-    ]);
-}
-exports.setupSystemVariables = setupSystemVariables;
-//# sourceMappingURL=SystemVariablesSetupHelper.js.map

package/dist/src/model/helpers/SystemVariablesSetupHelper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SystemVariablesSetupHelper.js","sourceRoot":"","sources":["../../../../src/model/helpers/SystemVariablesSetupHelper.ts"],"names":[],"mappings":";;;AAGa,QAAA,eAAe,GAAG,sCAAsC,CAAA;AAE9D,KAAK,UAAU,oBAAoB,CAAC,EAAU,EAAE,UAAkB,EAAE,SAAuB;IACjG,MAAM,OAAO,CAAC,GAAG,CAAC;QACjB,MAAM,EAAE,CAAC,KAAK,CAAC,gCAAgC,EAAE;YAChD,oBAAoB;YACpB,UAAU;SACV,CAAC;QACF,MAAM,EAAE,CAAC,KAAK,CAAC,gCAAgC,EAAE,CAAC,uBAAuB,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;KAC7F,CAAC,CAAA;AACH,CAAC;AARD,oDAQC"}