@contember/engine-system-api 0.12.0-beta.2 → 1.0.0-alpha.0

package/dist/tests/cases/unit/events/transactionDependency.test.js

@@ -1,62 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const uvu_1 = require("uvu");
-const dependency_1 = require("../../../../src/model/events/dependency");
-const schema_definition_1 = require("@contember/schema-definition");
-const schema_utils_1 = require("@contember/schema-utils");
-const engine_common_1 = require("@contember/engine-common");
-const engine_api_tester_1 = require("@contember/engine-api-tester");
-const src_1 = require("../../../../src");
-const assert = __importStar(require("../../../src/asserts"));
-const test = uvu_1.suite('Same transaction dependency builder');
-const now = new Date('2020-10-28 10:00');
-test('basic deps', async () => {
-    const model = new schema_definition_1.SchemaBuilder().entity('Author', e => e.column('name')).buildSchema();
-    const dependencyBuilder = new dependency_1.TransactionDependencyBuilder();
-    const event1 = engine_api_tester_1.testUuid(30);
-    const event2 = engine_api_tester_1.testUuid(31);
-    const event3 = engine_api_tester_1.testUuid(32);
-    const authorEntityId = engine_api_tester_1.testUuid(10);
-    const trxId1 = engine_api_tester_1.testUuid(500);
-    const trxId2 = engine_api_tester_1.testUuid(501);
-    const events = [
-        new engine_common_1.UpdateEvent(event1, now, src_1.unnamedIdentity, trxId1, [authorEntityId], 'author', {}),
-        new engine_common_1.UpdateEvent(event2, now, src_1.unnamedIdentity, trxId1, [authorEntityId], 'author', {}),
-        new engine_common_1.UpdateEvent(event3, now, src_1.unnamedIdentity, trxId2, [authorEntityId], 'author', {}),
-    ];
-    const deps = await dependencyBuilder.build({ ...schema_utils_1.emptySchema, model }, events);
-    assert.is(deps.size, 3);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const event1deps = deps.get(event1);
-    // it also includes self-dep
-    assert.is(event1deps.size, 2);
-    assert.ok(event1deps.has(event2));
-    const event2deps = deps.get(event2);
-    assert.is(event2deps.size, 2);
-    assert.ok(event2deps.has(event1));
-    const event3deps = deps.get(event3);
-    assert.is(event3deps.size, 1);
-    assert.not.ok(event3deps.has(event1));
-    assert.not.ok(event3deps.has(event2));
-});
-test.run();
-//# sourceMappingURL=transactionDependency.test.js.map

package/dist/tests/cases/unit/events/transactionDependency.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transactionDependency.test.js","sourceRoot":"","sources":["../../../../../tests/cases/unit/events/transactionDependency.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,6BAA2B;AAC3B,wEAAsF;AACtF,oEAA4D;AAC5D,0DAAqD;AACrD,4DAAsD;AACtD,oEAAuD;AACvD,yCAAiD;AACjD,6DAA8C;AAE9C,MAAM,IAAI,GAAG,WAAK,CAAC,qCAAqC,CAAC,CAAA;AAEzD,MAAM,GAAG,GAAG,IAAI,IAAI,CAAC,kBAAkB,CAAC,CAAA;AAExC,IAAI,CAAC,YAAY,EAAE,KAAK,IAAI,EAAE;IAC7B,MAAM,KAAK,GAAG,IAAI,iCAAa,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,EAAE,CAAA;IAEvF,MAAM,iBAAiB,GAAG,IAAI,yCAA4B,EAAE,CAAA;IAC5D,MAAM,MAAM,GAAG,4BAAQ,CAAC,EAAE,CAAC,CAAA;IAC3B,MAAM,MAAM,GAAG,4BAAQ,CAAC,EAAE,CAAC,CAAA;IAC3B,MAAM,MAAM,GAAG,4BAAQ,CAAC,EAAE,CAAC,CAAA;IAC3B,MAAM,cAAc,GAAG,4BAAQ,CAAC,EAAE,CAAC,CAAA;IAEnC,MAAM,MAAM,GAAG,4BAAQ,CAAC,GAAG,CAAC,CAAA;IAC5B,MAAM,MAAM,GAAG,4BAAQ,CAAC,GAAG,CAAC,CAAA;IAC5B,MAAM,MAAM,GAAG;QACd,IAAI,2BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,qBAAe,EAAE,MAAM,EAAE,CAAC,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC;QACrF,IAAI,2BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,qBAAe,EAAE,MAAM,EAAE,CAAC,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC;QACrF,IAAI,2BAAW,CAAC,MAAM,EAAE,GAAG,EAAE,qBAAe,EAAE,MAAM,EAAE,CAAC,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC;KACrF,CAAA;IACD,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,KAAK,CAAC,EAAE,GAAG,0BAAW,EAAE,KAAK,EAAE,EAAE,MAAM,CAAC,CAAA;IAC7E,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IACvB,oEAAoE;IACpE,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAE,CAAA;IACpC,4BAA4B;IAC5B,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IAC7B,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IACjC,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAE,CAAA;IACpC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IAC7B,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IAEjC,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAE,CAAA;IACpC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IAC7B,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IACrC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;AACtC,CAAC,CAAC,CAAA;AAEF,IAAI,CAAC,GAAG,EAAE,CAAA"}

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

@@ -1,16 +0,0 @@
-import { UpdateBuilder } from '@contember/database'
-import { Command } from '../Command'
-
-export class UpdateStageEventCommand implements Command<void> {
-	constructor(private readonly stageSlug: string, private readonly eventId: string) {}
-
-	public async execute({ db }: Command.Args) {
-		await UpdateBuilder.create()
-			.table('stage')
-			.where({ slug: this.stageSlug })
-			.values({
-				event_id: this.eventId,
-			})
-			.execute(db)
-	}
-}

package/src/model/dependencies/content/ContentEventsApplier.ts

@@ -1,27 +0,0 @@
-import { ContentEvent } from '@contember/engine-common'
-import { Client } from '@contember/database'
-import { Acl, Schema } from '@contember/schema'
-
-export interface ContentEventApplyOkResult {
-	readonly ok: true
-	readonly appliedEvents: ContentEvent[]
-}
-
-export interface ContentEventApplyErrorResult {
-	readonly ok: false
-	readonly appliedEvents: ContentEvent[]
-	readonly failedEvent: ContentEvent
-}
-
-export interface ContentEventApplierContext {
-	db: Client
-	schema: Schema
-	identityVariables: Acl.VariablesMap
-	roles: string[]
-}
-
-export type ContentEventApplyResult = ContentEventApplyOkResult | ContentEventApplyErrorResult
-
-export interface ContentEventsApplier {
-	apply(context: ContentEventApplierContext, events: ContentEvent[]): Promise<ContentEventApplyResult>
-}

package/src/model/events/DependencyBuilder.ts

@@ -1,9 +0,0 @@
-import { ContentEvent } from '@contember/engine-common'
-import { Schema } from '@contember/schema'
-import { MapSet } from '../../utils'
-
-export interface DependencyBuilder {
-	build(schema: Schema, events: ContentEvent[]): Promise<EventsDependencies>
-}
-
-export type EventsDependencies = MapSet<string, string>

package/src/model/events/DiffBuilder.ts

@@ -1,150 +0,0 @@
-import { DependencyBuilder, EventsDependencies } from './DependencyBuilder'
-import { Stage } from '../dtos'
-import { ContentEvent } from '@contember/engine-common'
-import { DatabaseContext } from '../database'
-import { SchemaVersionBuilder } from '../migrations'
-import { EntitiesRelationsInput, EntitiesResult, EntitiesSelector } from '../dependencies'
-import { Acl, Input, Schema } from '@contember/schema'
-import { formatSchemaName } from '../helpers'
-import { filterSchemaByStage, getEntity } from '@contember/schema-utils'
-import { Identity } from '../authorization'
-import { ImmutableSet } from '../../utils/set'
-import { StagingDisabledError } from '../../StagingDisabledError'
-
-export type EventsPermissionsVerifierContext = {
-	variables: Acl.VariablesMap
-	identity: Identity
-}
-
-export class DiffBuilder {
-	constructor(
-		private readonly dependencyBuilder: DependencyBuilder,
-		private readonly schemaVersionBuilder: SchemaVersionBuilder,
-		private readonly entitiesSelector: EntitiesSelector,
-	) {}
-
-	public async build(
-		db: DatabaseContext,
-		permissionContext: EventsPermissionsVerifierContext,
-		baseStage: Stage,
-		headStage: Stage,
-		filter: ReadonlyArray<EventFilter> | null,
-	): Promise<DiffBuilderResponse> {
-		throw new StagingDisabledError()
-	}
-
-	private async filterEvents(
-		events: ContentEvent[],
-		eventDependencies: EventsDependencies,
-		permissionContext: EventsPermissionsVerifierContext,
-		db: DatabaseContext,
-		schema: Schema,
-		baseStage: Stage,
-		headStage: Stage,
-		filter: ReadonlyArray<EventFilter>,
-	): Promise<ContentEvent[]> {
-		if (filter.length === 0) {
-			return []
-		}
-		const baseEntities = await this.fetchAffectedEntities(db, permissionContext, schema, baseStage, filter)
-		const headEntities = await this.fetchAffectedEntities(db, permissionContext, schema, headStage, filter)
-		const allIds = [...baseEntities, ...headEntities]
-
-		const rootEvents: ContentEvent[] = events.filter(it => it.rowId.some(id => allIds.includes(id)))
-		const eventIds = new Set<string>([])
-
-		const collectDependencies = (ids: ImmutableSet<string>) => {
-			ids.forEach(id => {
-				if (eventIds.has(id)) {
-					return
-				}
-				eventIds.add(id)
-				const deps = eventDependencies.get(id)
-				if (deps) {
-					collectDependencies(deps)
-				}
-			})
-		}
-		const rootEventIds = new Set(rootEvents.map(it => it.id))
-		collectDependencies(rootEventIds)
-
-		return events.filter(it => eventIds.has(it.id))
-	}
-
-	private async fetchAffectedEntities(
-		db: DatabaseContext,
-		permissionContext: EventsPermissionsVerifierContext,
-		schema: Schema,
-		stage: Stage,
-		filter: readonly EventFilter[],
-	): Promise<string[]> {
-		const affectedEntities = (
-			await Promise.all(
-				filter.map(
-					async it =>
-						await this.entitiesSelector.getEntities(
-							{
-								db: db.client.forSchema(formatSchemaName(stage)),
-								schema: filterSchemaByStage(schema, stage.slug),
-								identityVariables: permissionContext.variables,
-								roles: permissionContext.identity.roles,
-							},
-							{
-								entity: it.entity,
-								relations: it.relations,
-								filter: it.id
-									? {
-										[getEntity(schema.model, it.entity).primary]: { eq: it.id },
-									  }
-									: it.filter || {},
-							},
-						),
-				),
-			)
-		).flatMap(it => it)
-		const collectIds = (result: EntitiesResult): string[] => {
-			const { id, ...rest } = result
-			return [
-				id,
-				...Object.values(rest).flatMap(it => {
-					if (!it) {
-						return []
-					}
-					if (Array.isArray(it)) {
-						return it.flatMap(collectIds)
-					}
-					return collectIds(it)
-				}),
-			]
-		}
-		return affectedEntities.flatMap(it => (it ? collectIds(it) : [])).filter(it => it !== null)
-	}
-}
-
-export type DiffBuilderResponse = DiffBuilderOkResponse | DiffBuilderErrorResponse
-
-export enum DiffBuilderErrorCode {
-	notRebased = 'notRebased',
-	invalidFilter = 'invalidFilter',
-}
-
-export class DiffBuilderErrorResponse {
-	public readonly ok: false = false
-
-	constructor(public readonly error: DiffBuilderErrorCode, public readonly message: string) {}
-}
-
-export type EventWithDependencies = ContentEvent & { dependencies: ImmutableSet<string> }
-
-export class DiffBuilderOkResponse {
-	public readonly ok: true = true
-
-	constructor(public readonly events: EventWithDependencies[]) {}
-}
-
-export type EventFilter = {
-	entity: string
-	id?: string
-	filter?: Input.Where
-	relations: EntitiesRelationsInput
-}

package/src/model/events/EventFilterValidator.ts

@@ -1,52 +0,0 @@
-import { Model } from '@contember/schema'
-import { EventFilter } from './DiffBuilder'
-import { acceptFieldVisitor, getEntity, ModelError, ModelErrorCode } from '@contember/schema-utils'
-import { EntitiesRelationsInput } from '../dependencies/content'
-
-export class InvalidFilterError {
-	constructor(public readonly message: string) {}
-}
-
-export class EventFilterValidator {
-	public static validateFilter(model: Model.Schema, filter: EventFilter): void {
-		const entity = EventFilterValidator.getEntity(model, filter.entity)
-		EventFilterValidator.validateRelations(model, entity, filter.relations, [entity.name])
-	}
-
-	private static getEntity(model: Model.Schema, entityName: string): Model.Entity {
-		try {
-			return getEntity(model, entityName)
-		} catch (e) {
-			if (e instanceof ModelError && e.code === ModelErrorCode.ENTITY_NOT_FOUND) {
-				throw new InvalidFilterError(`${entityName}: entity not found`)
-			}
-			throw e
-		}
-	}
-
-	private static validateRelations(
-		model: Model.Schema,
-		entity: Model.Entity,
-		relations: EntitiesRelationsInput,
-		path: string[],
-	): void {
-		for (const relation of relations) {
-			const newPath = [...path, relation.name]
-			try {
-				const targetEntity = acceptFieldVisitor(model, entity, relation.name, {
-					visitColumn: () => {
-						throw new InvalidFilterError(`${newPath.join('.')}: not a relation`)
-					},
-					visitRelation: ({}, {}, targetEntity) => {
-						return targetEntity
-					},
-				})
-				EventFilterValidator.validateRelations(model, targetEntity, relation.relations, newPath)
-			} catch (e) {
-				if (e instanceof ModelError && e.code === ModelErrorCode.FIELD_NOT_FOUND) {
-					throw new InvalidFilterError(`${newPath.join('.')}: field not found`)
-				}
-			}
-		}
-	}
-}

package/src/model/events/TableReferencingResolver.ts

@@ -1,45 +0,0 @@
-import { Model } from '@contember/schema'
-import { acceptEveryFieldVisitor } from '@contember/schema-utils'
-
-export const getTableReferencing = (schema: Model.Schema): TableReferencingResolverResult => {
-	const result: TableReferencingResolverResult = {}
-
-	for (let entity of Object.values(schema.entities)) {
-		result[entity.tableName] = {}
-		acceptEveryFieldVisitor(
-			schema,
-			entity,
-			new (class implements Model.RelationByTypeVisitor<void> {
-				visitManyHasOne({}, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity) {
-					result[entity.tableName][relation.joiningColumn.columnName] = targetEntity.tableName
-				}
-
-				visitOneHasOneOwning({}, relation: Model.OneHasOneOwningRelation, targetEntity: Model.Entity) {
-					result[entity.tableName][relation.joiningColumn.columnName] = targetEntity.tableName
-				}
-
-				visitManyHasManyOwning(
-					entity: Model.Entity,
-					relation: Model.ManyHasManyOwningRelation,
-					targetEntity: Model.Entity,
-				) {
-					result[relation.joiningTable.tableName] = {
-						[relation.joiningTable.joiningColumn.columnName]: entity.tableName,
-						[relation.joiningTable.inverseJoiningColumn.columnName]: targetEntity.tableName,
-					}
-				}
-
-				visitColumn() {}
-
-				visitManyHasManyInverse() {}
-
-				visitOneHasMany() {}
-
-				visitOneHasOneInverse() {}
-			})(),
-		)
-	}
-	return result
-}
-
-export type TableReferencingResolverResult = { [tableName: string]: { [column: string]: string } }

package/src/model/events/dependency/CreatedRowReferenceDependencyBuilder.ts

@@ -1,80 +0,0 @@
-import { ContentEvent, EventType } from '@contember/engine-common'
-import { DependencyBuilder, EventsDependencies } from '../DependencyBuilder'
-import { getTableReferencing, TableReferencingResolverResult } from '../TableReferencingResolver'
-import { Schema } from '@contember/schema'
-import { getJunctionTables } from '../../helpers'
-import assert from 'assert'
-import { MapSet, tuple } from '../../../utils'
-
-/**
- * Events that references a row depends on creation of such event (or its following update)
- *
- * A1 - A row creation
- * A2 - A row update
- * B1 - some update on B row
- * B2 - some update on B row that references A row
- *
- *     v----\
- * A1 A2 B1 B2
- *
- */
-export class CreatedRowReferenceDependencyBuilder implements DependencyBuilder {
-	async build(schema: Schema, events: ContentEvent[]): Promise<EventsDependencies> {
-		if (events.length === 0) {
-			return new MapSet()
-		}
-
-		const tableReferencing: TableReferencingResolverResult = getTableReferencing(schema.model)
-
-		const dependencies: EventsDependencies = new MapSet()
-		const formatRef = (id: string, table: string) => `${table}#${id}`
-		const createdRows = new Map<string, string>()
-		const junctionTables = getJunctionTables(schema.model)
-		const junctionTableMap = new Map(junctionTables.map(it => tuple(it.tableName, it)))
-
-		for (const event of events) {
-			const junctionTable = junctionTableMap.get(event.tableName)
-			if (!junctionTable) {
-				assert.strictEqual(event.rowId.length, 1)
-				const ref = formatRef(event.rowId[0], event.tableName)
-				if (event.type === EventType.create) {
-					createdRows.set(ref, event.id)
-				} else if (createdRows.has(ref)) {
-					// update event reference to latest event
-					createdRows.set(ref, event.id)
-				}
-			}
-
-			if (event.type !== EventType.create && event.type !== EventType.update) {
-				continue
-			}
-
-			for (let column in event.values) {
-				const referencedTable = tableReferencing[event.tableName][column]
-				if (!referencedTable) {
-					continue
-				}
-				const ref = formatRef(event.values[column], referencedTable)
-				const createEventId = createdRows.get(ref)
-				if (createEventId !== undefined) {
-					dependencies.add(event.id, createEventId)
-				}
-			}
-			if (junctionTable) {
-				event.rowId.forEach((id, index) => {
-					assert.ok(index === 0 || index === 1)
-					const columnName =
-						index === 0 ? junctionTable.joiningColumn.columnName : junctionTable.inverseJoiningColumn.columnName
-					const table = tableReferencing[junctionTable.tableName][columnName]
-					const ref = formatRef(id, table)
-					const createdEventId = createdRows.get(ref)
-					if (createdEventId) {
-						dependencies.add(event.id, createdEventId)
-					}
-				})
-			}
-		}
-
-		return dependencies
-	}
-}

package/src/model/events/dependency/DeletedRowReferenceDependencyBuilder.ts

@@ -1,75 +0,0 @@
-import { ContentEvent, EventType } from '@contember/engine-common'
-import { DependencyBuilder, EventsDependencies } from '../DependencyBuilder'
-import { getTableReferencing, TableReferencingResolverResult } from '../TableReferencingResolver'
-import { Schema } from '@contember/schema'
-import { getJunctionTables } from '../../helpers'
-import assert from 'assert'
-import { MapSet, tuple } from '../../../utils'
-
-/**
- * Delete event depends on all previous events which references this row
- *
- * A1 - update event which references X row
- * A2 - another event which does not reference X row
- *
- *  v----\
- * A1 A2 X1
- *
- */
-export class DeletedRowReferenceDependencyBuilder implements DependencyBuilder {
-	async build(schema: Schema, events: ContentEvent[]): Promise<EventsDependencies> {
-		if (events.length === 0) {
-			return new MapSet()
-		}
-
-		const tableReferencing: TableReferencingResolverResult = getTableReferencing(schema.model)
-		const formatRef = (id: string, table: string) => `${table}#${id}`
-		const dependencies: EventsDependencies = new MapSet()
-		const deletedRows = new Map()
-		const junctionTables = getJunctionTables(schema.model)
-		const junctionTableMap = new Map(junctionTables.map(it => tuple(it.tableName, it)))
-
-		for (const event of events) {
-			if (!junctionTableMap.has(event.tableName)) {
-				assert.strictEqual(event.rowId.length, 1)
-				if (event.type === EventType.delete) {
-					deletedRows.set(formatRef(event.rowId[0], event.tableName), event.id)
-				}
-			}
-		}
-
-		for (const event of events) {
-			if (event.type !== EventType.create && event.type !== EventType.update) {
-				continue
-			}
-			const junctionTable = junctionTableMap.get(event.tableName)
-			if (junctionTable) {
-				event.rowId.forEach((id, index) => {
-					assert.ok(index === 0 || index === 1)
-					const columnName =
-						index === 0 ? junctionTable.joiningColumn.columnName : junctionTable.inverseJoiningColumn.columnName
-					const table = tableReferencing[junctionTable.tableName][columnName]
-					const ref = formatRef(id, table)
-					const deleteEventId = deletedRows.get(ref)
-					if (deleteEventId) {
-						dependencies.add(deleteEventId, event.id)
-					}
-				})
-			} else {
-				for (let column in event.values) {
-					const referencedTable = tableReferencing[event.tableName][column]
-					if (!referencedTable) {
-						continue
-					}
-					const ref = formatRef(event.values[column], referencedTable)
-					const deleteEventId = deletedRows.get(ref)
-					if (deleteEventId) {
-						dependencies.add(deleteEventId, event.id)
-					}
-				}
-			}
-		}
-
-		return dependencies
-	}
-}

package/src/model/events/dependency/DependencyBuilderList.ts

@@ -1,18 +0,0 @@
-import { DependencyBuilder, EventsDependencies } from '../DependencyBuilder'
-import { ContentEvent } from '@contember/engine-common'
-import { Schema } from '@contember/schema'
-import { MapSet } from '../../../utils'
-
-export class DependencyBuilderList implements DependencyBuilder {
-	constructor(private readonly builders: DependencyBuilder[]) {}
-
-	async build(schema: Schema, events: ContentEvent[]): Promise<EventsDependencies> {
-		const deps: EventsDependencies = new MapSet()
-		for (const event of events) {
-			deps.add(event.id)
-		}
-		const buildersDeps = await Promise.all(this.builders.map(builder => builder.build(schema, events)))
-		deps.merge(...buildersDeps)
-		return deps
-	}
-}

package/src/model/events/dependency/SameRowDependencyBuilder.ts

@@ -1,36 +0,0 @@
-import { ContentEvent } from '@contember/engine-common'
-import { DependencyBuilder, EventsDependencies } from '../DependencyBuilder'
-import { Schema } from '@contember/schema'
-import { getJunctionTables } from '../../helpers'
-import assert from 'assert'
-import { MapSet } from '../../../utils'
-
-/**
- * Events on a same row are depending on each other. Meaning that
- * a) all previous events has to be executed
- * b) all following events has to be executed (todo rethink)
- *
- *  v-----v-----v
- * A1 B1 A2 B2 A3
- *    ^-----^
- */
-export class SameRowDependencyBuilder implements DependencyBuilder {
-	async build(schema: Schema, events: ContentEvent[]): Promise<EventsDependencies> {
-		const rows = new MapSet<string, string>()
-		const dependencies: EventsDependencies = new MapSet()
-		const junctionTables = new Set(getJunctionTables(schema.model).map(it => it.tableName))
-		const formatRef = (id: string, table: string) => `${table}#${id}`
-		for (const event of events) {
-			if (junctionTables.has(event.tableName)) {
-				continue
-			}
-			assert.strictEqual(event.rowId.length, 1)
-			const ref = formatRef(event.rowId[0], event.tableName)
-
-			const events = rows.add(ref, event.id)
-			dependencies.set(event.id, events)
-		}
-
-		return dependencies
-	}
-}

package/src/model/events/dependency/TransactionDependencyBuilder.ts

@@ -1,31 +0,0 @@
-import { ContentEvent } from '@contember/engine-common'
-import { DependencyBuilder, EventsDependencies } from '../DependencyBuilder'
-import { Schema } from '@contember/schema'
-import { MapSet } from '../../../utils'
-
-/**
- * Events in transaction are dependent on each other (meaning you have to execute whole transaction at once)
- * todo this has to be optimized that only "dangerous" operations are dependent
- *
- * v--v   v--v--v
- * A1 A2 B1 B2 B3
- *
- */
-export class TransactionDependencyBuilder implements DependencyBuilder {
-	async build(schema: Schema, events: ContentEvent[]): Promise<EventsDependencies> {
-		let trxId = null
-		let eventsInTrx: Set<string> = new Set()
-		let dependencies: EventsDependencies = new MapSet()
-
-		for (const event of events) {
-			if (trxId !== event.transactionId) {
-				trxId = event.transactionId
-				eventsInTrx = new Set()
-			}
-			eventsInTrx.add(event.id)
-			dependencies.set(event.id, eventsInTrx)
-		}
-
-		return dependencies
-	}
-}

package/src/model/events/dependency/index.ts

@@ -1,5 +0,0 @@
-export * from './CreatedRowReferenceDependencyBuilder'
-export * from './DeletedRowReferenceDependencyBuilder'
-export * from './DependencyBuilderList'
-export * from './SameRowDependencyBuilder'
-export * from './TransactionDependencyBuilder'

package/src/model/stages/StageTree.ts

@@ -1,36 +0,0 @@
-import { StageWithoutEvent } from '../dtos'
-import { ProjectConfig, StageConfig } from '../../types'
-import { ImplementationException } from '../../utils'
-
-export class StageTree {
-	constructor(private readonly root: StageConfig, private readonly childMap: StageTreeMap) {}
-
-	public getRoot(): StageConfig {
-		return this.root
-	}
-
-	public getChildren(stage: StageWithoutEvent): StageConfig[] {
-		return this.childMap[stage.slug] || []
-	}
-}
-
-export const createStageTree = (project: Pick<ProjectConfig, 'stages'>): StageTree => {
-	const rootStages = project.stages.filter(it => !it.base)
-	if (rootStages.length !== 1) {
-		throw new Error(`Exactly 1 root stage expected, ${rootStages.length} found`)
-	}
-	const rootStage = rootStages[0]
-	const stages = project.stages
-		.filter(it => it.base)
-		.reduce<StageTreeMap>((acc, stage) => {
-			if (!stage.base) {
-				throw new ImplementationException()
-			}
-			return {
-				...acc,
-				[stage.base]: [...(acc[stage.base] || []), stage],
-			}
-		}, {})
-	return new StageTree(rootStage, stages)
-}
-export type StageTreeMap = { [parent: string]: StageConfig[] }