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

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

@@ -0,0 +1,105 @@
+import {
+	ConditionBuilder,
+	DatabaseQuery,
+	DatabaseQueryable,
+	Operator,
+	SelectBuilder,
+	SelectBuilderSpecification, Value,
+} from '@contember/database'
+import { AnyEvent, ContentEvent } from '@contember/engine-common'
+import { EventsFilter, EventsFilterDate, EventsOrder } from '../../../schema'
+import { createEventsFromRows, EventRow } from './EventQueryHelpers'
+
+export class EventsQuery extends DatabaseQuery<AnyEvent[]> {
+	constructor(
+		private readonly filter: EventsFilter,
+		private readonly order: EventsOrder,
+		private readonly offset: number,
+		private readonly limit: number,
+	) {
+		super()
+	}
+
+	async fetch({ db }: DatabaseQueryable): Promise<ContentEvent[]> {
+		const createDateMatcher = (column: string, dateFilter: EventsFilterDate | undefined): SelectBuilderSpecification => qb => {
+			if (!dateFilter) {
+				return qb
+			}
+			const { from, to } = dateFilter
+			if (from) {
+				qb = qb.where(expr => expr.compare(column, Operator.gte, from))
+			}
+			if (to) {
+				qb = qb.where(expr => expr.compare(column, Operator.lte, to))
+			}
+			return qb
+		}
+		const createInMatcher = (column: string | [string, string], values?: readonly Value[] | null): SelectBuilderSpecification => qb => {
+			if (!values) {
+				return qb
+			}
+			return qb.where(ConditionBuilder.create().in(column, values))
+		}
+
+		const qb = SelectBuilder.create<EventRow>()
+			.select('id')
+			.select('type')
+			.select('table_name')
+			.select('row_ids')
+			.select('values')
+			.select('created_at')
+			.select('applied_at')
+			.select('identity_id')
+			.select(['event_data', 'transaction_id'])
+
+			.from('event_data')
+			.join('stage_transaction', undefined, on =>
+				on.columnsEq(['event_data', 'transaction_id'], ['stage_transaction', 'transaction_id']),
+			)
+			.match(qb => {
+				switch (this.order) {
+					case EventsOrder.AppliedAtAsc:
+						return qb.orderBy('applied_at', 'asc')
+					case EventsOrder.AppliedAtDesc:
+						return qb.orderBy('applied_at', 'desc')
+					case EventsOrder.CreatedAtAsc:
+						return qb.orderBy('created_at', 'asc')
+					case EventsOrder.CreatedAtDesc:
+						return qb.orderBy('created_at', 'desc')
+				}
+			})
+			.match(createInMatcher('type', this.filter.types?.map(it => it.toLowerCase())))
+			.match(createInMatcher('table_name', this.filter.tables))
+			.match(createInMatcher('transactions', this.filter.transactions))
+			.match(createInMatcher('identities', this.filter.identities))
+			.match(createDateMatcher('created_at', this.filter.createdAt ?? undefined))
+			.match(createDateMatcher('applied_at', this.filter.appliedAt ?? undefined))
+			.match(qb => {
+				if (!this.filter.rows) {
+					return qb
+				}
+				type PrimaryKey = readonly string[]
+				const byTable: Record<string, PrimaryKey[]> = {}
+				for (const row of this.filter.rows) {
+					byTable[row.tableName] ??= []
+					byTable[row.tableName].push(row.primaryKey)
+				}
+				const rowFilters = Object.entries(byTable)
+				const ors = rowFilters.reduce(
+					(expr, [table, rowIds]) =>
+						expr.and(
+							ConditionBuilder.create()
+								.compare('table_name', Operator.eq, table)
+								.in('row_ids', rowIds.map(it => JSON.stringify(it))),
+						),
+					ConditionBuilder.create(),
+				)
+				return qb.where(ConditionBuilder.create().or(ors))
+			})
+
+			.limit(this.limit, this.offset)
+
+		return createEventsFromRows(await qb.getResult(db))
+	}
+
+}

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

@@ -0,0 +1,23 @@
+import { DatabaseQuery, DatabaseQueryable, Literal, Operator, SelectBuilder } from '@contember/database'
+
+export class OldValuesQuery extends DatabaseQuery<Record<string, any>> {
+	constructor(private readonly ids: string[]) {
+		super()
+	}
+
+	async fetch(queryable: DatabaseQueryable): Promise<Record<string, any>> {
+		const qb = SelectBuilder.create()
+			.select(expr => expr.raw('JSONB_OBJECT_AGG(values.key, values.value ORDER BY previous.created_at ASC)'), 'values')
+			.select(['event_data', 'id'])
+			.from('event_data')
+			.join('event_data', 'previous', on => on
+				.columnsEq(['event_data', 'row_ids'], ['previous', 'row_ids'])
+				.compareColumns(['event_data', 'created_at'], Operator.gt, ['previous', 'created_at']),
+			)
+			.join(new Literal('JSONB_EACH(previous.values)'), 'values')
+			.where(where => where.in(['event_data', 'id'], this.ids))
+			.groupBy(['event_data', 'id'])
+
+		return Object.fromEntries((await qb.getResult(queryable.db)).map(it => [it.id, it.values]))
+	}
+}

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

@@ -1 +1,3 @@
+export * from './EventsQuery'
 export * from './LatestTransactionIdByStageQuery'
+export * from './OldValuesQuery'

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

@@ -6,6 +6,5 @@ export const prepareStageQueryBuilder = () => {
 		.select('id')
 		.select('name')
 		.select('slug')
-		.select('event_id')
 		.from('stage')
 }

package/src/model/stages/StageCreator.ts

@@ -2,30 +2,19 @@ import { CreateOrUpdateStageCommand } from '../commands'
 import { StageBySlugQuery } from '../queries'
 import { StageConfig } from '../../types'
 import { DatabaseContext } from '../database'
-import { Logger } from '@contember/engine-common'
-import { StagingDisabledError } from '../../StagingDisabledError'
 
 class StageCreator {
 	constructor() {}
 
 	public async createStage(
 		db: DatabaseContext,
-		parent: StageConfig | null,
 		stage: StageConfig,
-		logger: Logger,
 	): Promise<boolean> {
 		const stageRow = await db.queryHandler.fetch(new StageBySlugQuery(stage.slug))
 		if (stageRow && stageRow.name === stage.name) {
 			return false
 		}
-		const created = await db.commandBus.execute(new CreateOrUpdateStageCommand(stage))
-		if (!created) {
-			return false
-		}
-		if (!parent) {
-			return true
-		}
-		throw new StagingDisabledError()
+		return await db.commandBus.execute(new CreateOrUpdateStageCommand(stage))
 	}
 }
 

package/src/model/stages/index.ts

@@ -1,2 +1 @@
 export * from './StageCreator'
-export * from './StageTree'

package/src/resolvers/ResolverContext.ts

@@ -1,5 +1,5 @@
 import { Authorizator } from '@contember/authorization'
-import { Acl, Schema } from '@contember/schema'
+import { Schema } from '@contember/schema'
 import { ForbiddenError } from 'apollo-server-errors'
 import { DatabaseContext, SchemaVersionBuilder } from '../model'
 import { ProjectConfig } from '../types'
@@ -7,6 +7,7 @@ import { Identity } from '../model/authorization'
 import { StagePermissionsFactory } from '../model/authorization/StagePermissionsFactory'
 import { StageScope } from '../model/authorization/StageScope'
 import { ItemLoader } from '../utils/batchQuery'
+import { Client } from '@contember/database'
 
 export class ResolverContextFactory {
 	constructor(
@@ -16,9 +17,9 @@ export class ResolverContextFactory {
 
 	public async create(
 		systemDbContext: DatabaseContext,
+		tenantDb: Client,
 		project: ProjectConfig,
 		identity: Identity,
-		variables: Acl.VariablesMap,
 	): Promise<ResolverContext> {
 		const schema = await this.schemaVersionBuilder.buildSchema(systemDbContext)
 		const stagePermissionsFactory = new StagePermissionsFactory(schema)
@@ -26,7 +27,6 @@ export class ResolverContextFactory {
 		return {
 			project,
 			identity,
-			variables,
 			schema,
 			authorizator: this.authorizator,
 			db: systemDbContext,
@@ -44,6 +44,7 @@ export class ResolverContextFactory {
 				loaders.set(loaderFactory, newLoader)
 				return newLoader
 			},
+			tenantDb,
 		}
 	}
 }
@@ -55,8 +56,8 @@ export interface ResolverContext {
 	readonly schema: Schema
 	readonly identity: Identity
 	readonly db: DatabaseContext
-	readonly variables: Acl.VariablesMap
 	readonly authorizator: Authorizator<Identity>
 	readonly requireAccess: (action: Authorizator.Action, stage: string, message?: string) => Promise<void>
 	readonly getLoader: <Args, Item>(loaderFactory: LoaderFactory<Args, Item>) => ItemLoader<Args, Item>
+	readonly tenantDb: Client
 }

package/src/resolvers/ResolverFactory.ts

@@ -1,36 +1,34 @@
-import { ExecutedMigrationsQueryResolver, StagesQueryResolver } from './query'
-import { HistoryEvent, HistoryEventType, Resolvers } from '../schema'
+import { EventsQueryResolver, ExecutedMigrationsQueryResolver, StagesQueryResolver } from './query'
+import { Event, EventType, Resolvers } from '../schema'
 import { assertNever } from '../utils'
-import { ResolverContext } from './ResolverContext'
-import { GraphQLResolveInfo } from 'graphql'
-import { MigrateMutationResolver, TruncateMutationResolver } from './mutation'
+import { MigrateMutationResolver, MigrationAlterMutationResolver, TruncateMutationResolver } from './mutation'
 import { DateTimeType, JSONType } from '@contember/graphql-utils'
-import { MigrationAlterMutationResolver } from './mutation/MigrationAlterMutationResolver'
+import { EventOldValuesResolver } from './types'
 
-class ResolverFactory {
+export class ResolverFactory {
 	public constructor(
 		private readonly stagesQueryResolver: StagesQueryResolver,
 		private readonly executedMigrationsQueryResolver: ExecutedMigrationsQueryResolver,
 		private readonly migrateMutationResolver: MigrateMutationResolver,
 		private readonly truncateMutationResolver: TruncateMutationResolver,
 		private readonly migrationAlterMutationResolver: MigrationAlterMutationResolver,
+		private readonly eventsQueryResolver: EventsQueryResolver,
+		private readonly eventOldValuesResolver: EventOldValuesResolver,
 	) {}
 
 	create(debugMode: boolean): Resolvers {
 		const resolvers: Resolvers & Required<Pick<Resolvers, 'Mutation'>> = {
 			DateTime: DateTimeType,
 			Json: JSONType,
-			HistoryEvent: {
-				__resolveType: (obj: HistoryEvent) => {
+			Event: {
+				__resolveType: (obj: Event) => {
 					switch (obj.type) {
-						case HistoryEventType.Create:
-							return 'HistoryCreateEvent'
-						case HistoryEventType.Update:
-							return 'HistoryUpdateEvent'
-						case HistoryEventType.Delete:
-							return 'HistoryDeleteEvent'
-						case HistoryEventType.RunMigration:
-							return 'HistoryRunMigrationEvent'
+						case EventType.Create:
+							return 'CreateEvent'
+						case EventType.Update:
+							return 'UpdateEvent'
+						case EventType.Delete:
+							return 'DeleteEvent'
 						case null:
 						case undefined:
 							return null
@@ -40,34 +38,26 @@ class ResolverFactory {
 				},
 			},
 			Query: {
-				stages: (parent: any, args: any, context: ResolverContext, info: GraphQLResolveInfo) =>
-					this.stagesQueryResolver.stages(parent, args, context, info),
-				executedMigrations: (parent: any, args: any, context: ResolverContext, info: GraphQLResolveInfo) =>
-					this.executedMigrationsQueryResolver.executedMigrations(parent, args, context, info),
+				stages: this.stagesQueryResolver.stages.bind(this.stagesQueryResolver),
+				executedMigrations: this.executedMigrationsQueryResolver.executedMigrations.bind(this.executedMigrationsQueryResolver),
+				events: this.eventsQueryResolver.events.bind(this.eventsQueryResolver),
 			},
 			Mutation: {
-				migrate: (parent: any, args: any, context: ResolverContext, info: GraphQLResolveInfo) =>
-					this.migrateMutationResolver.migrate(parent, args, context, info),
+				migrate: this.migrateMutationResolver.migrate.bind(this.migrateMutationResolver),
+			},
+			DeleteEvent: {
+				oldValues: this.eventOldValuesResolver.oldValues.bind(this.eventOldValuesResolver),
+			},
+			UpdateEvent: {
+				oldValues: this.eventOldValuesResolver.oldValues.bind(this.eventOldValuesResolver),
 			},
 		}
 		if (debugMode) {
 			resolvers.Mutation.truncate = this.truncateMutationResolver.truncate.bind(this.truncateMutationResolver)
-			resolvers.Mutation.migrationDelete = this.migrationAlterMutationResolver.migrationDelete.bind(
-				this.migrationAlterMutationResolver,
-			)
-			resolvers.Mutation.migrationModify = this.migrationAlterMutationResolver.migrationModify.bind(
-				this.migrationAlterMutationResolver,
-			)
+			resolvers.Mutation.migrationDelete = this.migrationAlterMutationResolver.migrationDelete.bind(this.migrationAlterMutationResolver)
+			resolvers.Mutation.migrationModify = this.migrationAlterMutationResolver.migrationModify.bind(this.migrationAlterMutationResolver)
 			resolvers.Mutation.forceMigrate = this.migrateMutationResolver.migrateForce.bind(this.migrateMutationResolver)
 		}
 		return resolvers
 	}
 }
-
-namespace ResolverFactory {
-	export type FieldResolverArgs = {
-		[argument: string]: any
-	}
-}
-
-export { ResolverFactory }

package/src/resolvers/mutation/MigrateMutationResolver.ts

@@ -3,7 +3,7 @@ import { ResolverContext } from '../ResolverContext'
 import { MutationResolver } from '../Resolver'
 import { MigrateResponse, MutationMigrateArgs } from '../../schema'
 import { Migration } from '@contember/schema-migrations'
-import { AuthorizationActions, createStageTree, MigrationError, ProjectMigrator } from '../../model'
+import { AuthorizationActions, MigrationError, ProjectMigrator } from '../../model'
 
 export class MigrateMutationResolver implements MutationResolver<'migrate'> {
 	constructor(private readonly projectMigrator: ProjectMigrator) {}
@@ -24,8 +24,9 @@ export class MigrateMutationResolver implements MutationResolver<'migrate'> {
 		info: GraphQLResolveInfo,
 		force = false,
 	): Promise<MigrateResponse> {
-		const rootStageSlug = createStageTree(context.project).getRoot().slug
-		await context.requireAccess(AuthorizationActions.PROJECT_MIGRATE, rootStageSlug)
+		for (const stage of context.project.stages) {
+			await context.requireAccess(AuthorizationActions.PROJECT_MIGRATE, stage.slug)
+		}
 		const migrations = args.migrations as readonly Migration[]
 
 		return context.db.transaction(async trx => {

package/src/resolvers/mutation/index.ts

@@ -1,2 +1,3 @@
 export * from './MigrateMutationResolver'
 export * from './TruncateMutationResolver'
+export * from './MigrationAlterMutationResolver'

package/src/resolvers/query/EventsQueryResolver.ts

@@ -0,0 +1,42 @@
+import { GraphQLResolveInfo } from 'graphql'
+import { ResolverContext } from '../ResolverContext'
+import { QueryResolver } from '../Resolver'
+import { EventsOrder, QueryEventsArgs, ResolversTypes } from '../../schema'
+import { AuthorizationActions, EventResponseBuilder, EventsQuery, StageBySlugQuery } from '../../model'
+import { UserInputError } from 'apollo-server-errors'
+
+export class EventsQueryResolver implements QueryResolver<'events'> {
+	constructor(
+		private readonly eventResponseBuilder: EventResponseBuilder,
+	) {
+	}
+
+	async events(
+		parent: any,
+		{ args }: QueryEventsArgs,
+		context: ResolverContext,
+		info: GraphQLResolveInfo,
+	): Promise<ResolversTypes['Event'][]> {
+		return context.db.transaction(async db => {
+			const stageSlug = args?.stage ?? context.project.stages[0].slug
+			const stage = await db.queryHandler.fetch(new StageBySlugQuery(stageSlug))
+			if (!stage) {
+				throw new UserInputError(`Stage ${stageSlug} not found`)
+			}
+			await context.requireAccess(
+				AuthorizationActions.PROJECT_HISTORY_ANY,
+				stage.slug,
+				'You are not allowed to view a history.',
+			)
+
+			const history = await db.queryHandler.fetch(new EventsQuery(
+				args?.filter ?? {},
+				args?.order ?? EventsOrder.AppliedAtDesc,
+				args?.offset ?? 0,
+				Math.min(args?.limit ?? 1000, 10000),
+			))
+
+			return await this.eventResponseBuilder.buildResponse(context.tenantDb, history)
+		})
+	}
+}

package/src/resolvers/query/index.ts

@@ -1,2 +1,3 @@
+export * from './EventsQueryResolver'
 export * from './ExecutedMigrationsQueryResolver'
 export * from './StagesQueryResolver'

package/src/resolvers/types/EventOldValuesResolver.ts

@@ -0,0 +1,13 @@
+import { DeleteEvent, DeleteEventResolvers, UpdateEvent, UpdateEventResolvers } from '../../schema'
+import { ResolverContext } from '../ResolverContext'
+import { oldValuesLoaderFactory } from './OldValuesHelpers'
+
+export class EventOldValuesResolver implements UpdateEventResolvers<ResolverContext>, DeleteEventResolvers<ResolverContext> {
+	async oldValues(
+		parent: UpdateEvent | DeleteEvent,
+		args: unknown,
+		context: ResolverContext,
+	): Promise<object> {
+		return await context.getLoader(oldValuesLoaderFactory)(parent.id)
+	}
+}

package/src/resolvers/types/OldValuesHelpers.ts

@@ -0,0 +1,11 @@
+import { DatabaseContext } from '../../model'
+import { createBatchLoader } from '../../utils/batchQuery'
+import { OldValuesQuery } from '../../model'
+
+export const oldValuesLoaderFactory = (db: DatabaseContext) =>
+	createBatchLoader<string, Record<string, object>, object>(
+		async ids => {
+			return db.queryHandler.fetch(new OldValuesQuery(ids))
+		},
+		(id, items) => items[id],
+	)

package/src/resolvers/types/index.ts

@@ -0,0 +1 @@
+export * from './EventOldValuesResolver'

package/src/schema/system.graphql.ts

@@ -13,109 +13,113 @@ const schema: DocumentNode = gql`
 	type Query {
 		stages: [Stage!]!
 		executedMigrations(version: String): [ExecutedMigration!]!
-		history(stage: String!, filter: [HistoryFilter!], sinceEvent: String, sinceTime: DateTime): HistoryResponse!
+		events(args: EventsArgs): [Event!]!
 	}
 
 	type Mutation {
 		migrate(migrations: [Migration!]!): MigrateResponse!
 	}
 
-	# === history filter ===
+	# === events ===
 
-	input HistoryFilter {
-		entity: String!
-		id: String!
+	input EventsArgs {
+		stage: String
+		filter: EventsFilter
+		order: EventsOrder
+		offset: Int
+		"Max 10000"
+		limit: Int
 	}
 
-	# === history ===
-
-	enum HistoryErrorCode {
-		STAGE_NOT_FOUND
+	enum EventsOrder {
+		CREATED_AT_ASC
+		CREATED_AT_DESC
+		APPLIED_AT_ASC
+		APPLIED_AT_DESC
 	}
 
-	type HistoryError {
-		code: HistoryErrorCode!
-		developerMessage: String!
+	input EventsFilter {
+		types: [EventType!]
+		rows: [EventFilterRow!]
+		tables: [String!]
+		transactions: [String!]
+		identities: [String!]
+		createdAt: EventsFilterDate
+		appliedAt: EventsFilterDate
 	}
 
-	type HistoryResponse {
-		ok: Boolean
-		errors: [HistoryErrorCode!]! @deprecated
-		error: HistoryError
-		result: HistoryResult
+	input EventsFilterDate {
+		from: DateTime
+		to: DateTime
 	}
 
-	type HistoryResult {
-		events: [HistoryEvent!]!
+	input EventFilterRow {
+		tableName: String!
+		primaryKey: [String!]!
 	}
 
-	interface HistoryEvent {
+	interface Event {
 		id: String!
 		transactionId: String!
 		identityDescription: String!
 		identityId: String!
 		description: String!
 		createdAt: DateTime!
-		type: HistoryEventType!
+		appliedAt: DateTime!
+		type: EventType!
+		tableName: String!
+		primaryKey: [String!]!
 	}
 
-	enum HistoryEventType {
+	enum EventType {
 		UPDATE
 		DELETE
 		CREATE
-		RUN_MIGRATION
 	}
 
-	type HistoryUpdateEvent implements HistoryEvent {
+	type UpdateEvent implements Event {
 		id: String!
 		transactionId: String!
 		identityId: String!
 		identityDescription: String!
 		description: String!
 		createdAt: DateTime!
-		type: HistoryEventType!
+		appliedAt: DateTime!
+		type: EventType!
 		tableName: String!
-		primaryKeys: [String!]!
+		primaryKey: [String!]!
 		oldValues: Json!
 		diffValues: Json!
 	}
 
-	type HistoryDeleteEvent implements HistoryEvent {
+	type DeleteEvent implements Event {
 		id: String!
 		transactionId: String!
 		identityId: String!
 		identityDescription: String!
 		description: String!
 		createdAt: DateTime!
-		type: HistoryEventType!
+		appliedAt: DateTime!
+		type: EventType!
 		tableName: String!
-		primaryKeys: [String!]!
+		primaryKey: [String!]!
 		oldValues: Json!
 	}
 
-	type HistoryCreateEvent implements HistoryEvent {
+	type CreateEvent implements Event {
 		id: String!
 		transactionId: String!
 		identityId: String!
 		identityDescription: String!
 		description: String!
 		createdAt: DateTime!
-		type: HistoryEventType!
+		appliedAt: DateTime!
+		type: EventType!
 		tableName: String!
-		primaryKeys: [String!]!
+		primaryKey: [String!]!
 		newValues: Json!
 	}
 
-	type HistoryRunMigrationEvent implements HistoryEvent {
-		id: String!
-		transactionId: String!
-		identityId: String!
-		identityDescription: String!
-		description: String!
-		createdAt: DateTime!
-		type: HistoryEventType!
-	}
-
 	# === executedMigrations ===
 
 	type ExecutedMigration {