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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-system-api",
-  "version": "0.12.0-beta.2",
+  "version": "1.0.0-alpha.3",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -9,28 +9,28 @@
     "test": "uvu dist/tests/cases/ \\.js$ && uvu migrations \\.test\\.js"
   },
   "dependencies": {
-    "@contember/authorization": "^0.12.0-beta.2",
-    "@contember/database": "^0.12.0-beta.2",
-    "@contember/database-migrations": "^0.12.0-beta.2",
-    "@contember/dic": "^0.12.0-beta.2",
-    "@contember/engine-common": "^0.12.0-beta.2",
-    "@contember/graphql-utils": "^0.12.0-beta.2",
-    "@contember/queryable": "^0.12.0-beta.2",
-    "@contember/schema": "^0.12.0-beta.2",
-    "@contember/schema-migrations": "^0.12.0-beta.2",
-    "@contember/schema-utils": "^0.12.0-beta.2",
+    "@contember/authorization": "^1.0.0-alpha.3",
+    "@contember/database": "^1.0.0-alpha.3",
+    "@contember/database-migrations": "^1.0.0-alpha.3",
+    "@contember/dic": "^1.0.0-alpha.3",
+    "@contember/engine-common": "^1.0.0-alpha.3",
+    "@contember/graphql-utils": "^1.0.0-alpha.3",
+    "@contember/queryable": "^1.0.0-alpha.3",
+    "@contember/schema": "^1.0.0-alpha.3",
+    "@contember/schema-migrations": "^1.0.0-alpha.3",
+    "@contember/schema-utils": "^1.0.0-alpha.3",
     "@graphql-tools/utils": "^7.10.0",
     "apollo-server-errors": "^2.4.0",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/engine-api-tester": "^0.12.0-beta.2",
-    "@contember/schema-definition": "^0.12.0-beta.2",
+    "@contember/engine-api-tester": "^1.0.0-alpha.3",
+    "@contember/schema-definition": "^1.0.0-alpha.3",
     "@graphql-codegen/cli": "^1.15.2",
     "@graphql-codegen/typescript": "^1.15.2",
     "@graphql-codegen/typescript-operations": "^1.15.2",
     "@graphql-codegen/typescript-resolvers": "^1.15.2",
-    "@types/node": "^15.12.5",
+    "@types/node": "^17.0.5",
     "graphql": "^15.4.0",
     "pg": "^8.5.0",
     "uvu": "^0.5.1"

package/src/SystemContainer.ts

@@ -9,37 +9,33 @@ import {
 import { MigrationsRunner } from '@contember/database-migrations'
 import { DatabaseCredentials } from '@contember/database'
 import {
-	ContentEventsApplier,
-	CreatedRowReferenceDependencyBuilder,
-	DeletedRowReferenceDependencyBuilder,
-	DependencyBuilderList,
-	DiffBuilder,
 	EntitiesSelector,
+	EventResponseBuilder,
 	ExecutedMigrationsResolver,
-	HistoryEventResponseBuilder,
+	IdentityFetcher,
 	MigrationAlterer,
 	MigrationExecutor,
 	PermissionsFactory,
 	ProjectInitializer,
 	ProjectMigrator,
 	ProjectTruncateExecutor,
-	SameRowDependencyBuilder,
 	SchemaVersionBuilder,
 	StageCreator,
-	TransactionDependencyBuilder,
 } from './model'
 import { UuidProvider } from './utils'
 import {
+	EventsQueryResolver,
 	ExecutedMigrationsQueryResolver,
 	MigrateMutationResolver,
+	MigrationAlterMutationResolver,
 	ResolverContextFactory,
 	ResolverFactory,
 	StagesQueryResolver,
 	TruncateMutationResolver,
 } from './resolvers'
 import { ClientBase } from 'pg'
-import { IdentityFetcher } from './model/dependencies/tenant/IdentityFetcher'
-import { MigrationAlterMutationResolver } from './resolvers/mutation/MigrationAlterMutationResolver'
+import { MigrationArgs } from './migrations'
+import { EventOldValuesResolver } from './resolvers/types'
 
 export interface SystemContainer {
 	systemResolversFactory: ResolverFactory
@@ -50,15 +46,14 @@ export interface SystemContainer {
 	systemDbMigrationsRunnerFactory: SystemDbMigrationsRunnerFactory
 }
 
-export type SystemDbMigrationsRunnerFactory = (db: DatabaseCredentials, dbClient: ClientBase) => MigrationsRunner
+export type SystemDbMigrationsRunnerFactory = (db: DatabaseCredentials, dbClient: ClientBase) => MigrationsRunner<MigrationArgs>
 
 type Args = {
 	providers: UuidProvider
 	modificationHandlerFactory: ModificationHandlerFactory
 	entitiesSelector: EntitiesSelector
-	eventApplier: ContentEventsApplier
+	systemDbMigrationsRunnerFactory: (db: DatabaseCredentials, dbClient: ClientBase) => MigrationsRunner<MigrationArgs>
 	identityFetcher: IdentityFetcher
-	systemDbMigrationsRunnerFactory: (db: DatabaseCredentials, dbClient: ClientBase) => MigrationsRunner
 }
 
 export class SystemContainerFactory {
@@ -80,6 +75,8 @@ export class SystemContainerFactory {
 				container.systemDbMigrationsRunnerFactory)
 			.addService('modificationHandlerFactory', () =>
 				container.modificationHandlerFactory)
+			.addService('identityFetcher', () =>
+				container.identityFetcher)
 			.addService('schemaMigrator', ({ modificationHandlerFactory }) =>
 				new SchemaMigrator(modificationHandlerFactory))
 			.addService('executedMigrationsResolver', ({}) =>
@@ -98,37 +95,32 @@ export class SystemContainerFactory {
 				new MigrationExecutor(modificationHandlerFactory))
 			.addService('migrationDescriber', ({ modificationHandlerFactory }) =>
 				new MigrationDescriber(modificationHandlerFactory))
-			.addService('dependencyBuilder', ({}) =>
-				new DependencyBuilderList([
-					new SameRowDependencyBuilder(),
-					new TransactionDependencyBuilder(),
-					new DeletedRowReferenceDependencyBuilder(),
-					new CreatedRowReferenceDependencyBuilder(),
-				]))
 			.addService('projectMigrator', ({ migrationDescriber, schemaVersionBuilder, executedMigrationsResolver }) =>
 				new ProjectMigrator(migrationDescriber, schemaVersionBuilder, executedMigrationsResolver))
 			.addService('stageCreator', () =>
 				new StageCreator())
-			.addService('diffBuilder', ({ dependencyBuilder, schemaVersionBuilder }) =>
-				new DiffBuilder(dependencyBuilder, schemaVersionBuilder, container.entitiesSelector))
 			.addService('projectTruncateExecutor', () =>
 				new ProjectTruncateExecutor())
 			.addService('migrationAlterer', () =>
 				new MigrationAlterer())
+			.addService('eventResponseBuilder', ({ identityFetcher }) =>
+				new EventResponseBuilder(identityFetcher))
 			.addService('stagesQueryResolver', () =>
 				new StagesQueryResolver())
 			.addService('executedMigrationsQueryResolver', () =>
 				new ExecutedMigrationsQueryResolver())
-			.addService('historyEventResponseBuilder', () =>
-				new HistoryEventResponseBuilder(container.identityFetcher))
 			.addService('migrateMutationResolver', ({ projectMigrator }) =>
 				new MigrateMutationResolver(projectMigrator))
 			.addService('truncateMutationResolver', ({ projectTruncateExecutor }) =>
 				new TruncateMutationResolver(projectTruncateExecutor))
 			.addService('migrationAlterMutationResolver', ({ migrationAlterer }) =>
 				new MigrationAlterMutationResolver(migrationAlterer))
-			.addService('systemResolversFactory', ({ stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver }) =>
-				new ResolverFactory(stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver))
+			.addService('eventsQueryResolver', ({ eventResponseBuilder }) =>
+				new EventsQueryResolver(eventResponseBuilder))
+			.addService('eventOldValuesResolver', () =>
+				new EventOldValuesResolver())
+			.addService('systemResolversFactory', ({ stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver, eventsQueryResolver, eventOldValuesResolver }) =>
+				new ResolverFactory(stagesQueryResolver, executedMigrationsQueryResolver, migrateMutationResolver, truncateMutationResolver, migrationAlterMutationResolver, eventsQueryResolver, eventOldValuesResolver))
 			.addService('resolverContextFactory', ({ authorizator, schemaVersionBuilder }) =>
 				new ResolverContextFactory(authorizator, schemaVersionBuilder))
 			.addService('projectInitializer', ({ projectMigrator, stageCreator, systemDbMigrationsRunnerFactory, schemaVersionBuilder }) =>

package/src/index.ts

@@ -17,7 +17,6 @@ export {
 	ProjectMigrator,
 	StageCreator,
 	getJunctionTables,
-	UpdateStageEventCommand,
 } from './model'
 export * from './SystemContainer'
 export * from './resolvers'

package/src/model/ProjectInitializer.ts

@@ -1,7 +1,7 @@
 import { unnamedIdentity } from './helpers'
 import { ProjectConfig, StageConfig } from '../types'
 import { ProjectMigrator, SchemaVersionBuilder } from './migrations'
-import { createStageTree, StageCreator } from './stages'
+import { StageCreator } from './stages'
 import { DatabaseContext, DatabaseContextFactory } from './database'
 import { SystemDbMigrationsRunnerFactory } from '../SystemContainer'
 import {
@@ -11,7 +11,6 @@ import {
 	retryTransaction,
 	SingleConnection,
 } from '@contember/database'
-import { MigrationArgs } from '../migrations'
 import { createDatabaseIfNotExists, createPgClient } from '@contember/database-migrations'
 import { Logger } from '@contember/engine-common'
 import { Migration } from '@contember/schema-migrations'
@@ -43,7 +42,7 @@ export class ProjectInitializer {
 				.create(unnamedIdentity)
 
 			const schemaResolver = () => this.schemaVersionBuilder.buildSchema(dbContextMigrations)
-			await this.systemDbMigrationsRunnerFactory(project.db, pgClient).migrate<MigrationArgs>(
+			await this.systemDbMigrationsRunnerFactory(project.db, pgClient).migrate(
 				logger.write.bind(logger),
 				{
 					schemaResolver,
@@ -67,11 +66,10 @@ export class ProjectInitializer {
 		logger: Logger,
 		migrations?: Migration[],
 	) {
-		const stageTree = createStageTree(project)
-		const root = stageTree.getRoot()
 
-		const createStage = async (parent: StageConfig | null, stage: StageConfig) => {
-			const created = await this.stageCreator.createStage(db, parent, stage, logger)
+		logger.group(`Creating stages`)
+		for (const stage of project.stages) {
+			const created = await this.stageCreator.createStage(db, stage)
 			if (created) {
 				logger.write(`Created stage ${stage.slug} `)
 			} else {
@@ -79,15 +77,6 @@ export class ProjectInitializer {
 			}
 		}
 
-		const createRecursive = async (parent: StageConfig | null, stage: StageConfig) => {
-			await createStage(parent, stage)
-			for (const childStage of stageTree.getChildren(stage)) {
-				await createRecursive(stage, childStage)
-			}
-		}
-
-		logger.group(`Creating stages`)
-		await createRecursive(null, root)
 		logger.groupEnd()
 		if (migrations) {
 			logger.group(`Executing project migrations`)

package/src/model/authorization/AuthorizationActions.ts

@@ -5,14 +5,6 @@ export namespace AuthorizationActions {
 		project = 'project',
 	}
 
-	export const PROJECT_RELEASE_ANY = Authorizator.createAction(Resources.project, 'releaseAny')
-	export const PROJECT_RELEASE_SOME = Authorizator.createAction(Resources.project, 'releaseSome')
-
-	export const PROJECT_REBASE_ANY = Authorizator.createAction(Resources.project, 'rebaseAny')
-
-	export const PROJECT_DIFF_ANY = Authorizator.createAction(Resources.project, 'diffAny')
-	export const PROJECT_DIFF_SOME = Authorizator.createAction(Resources.project, 'diffSome')
-
 	export const PROJECT_HISTORY_ANY = Authorizator.createAction(Resources.project, 'historyAny')
 
 	export const PROJECT_MIGRATE = Authorizator.createAction(Resources.project, 'migrate')

package/src/model/authorization/StagePermissionsFactory.ts

@@ -13,32 +13,11 @@ export class StagePermissionsFactory {
 
 		const rolePermissions = this.createRolePermissions(filteredSchema.acl)
 		Object.entries(rolePermissions).forEach(([role, value]) => {
-			// diff
-			if (value.diff === Acl.SystemPermissionsLevel.some) {
-				permissions.allow(role, AuthorizationActions.PROJECT_DIFF_SOME)
-			} else if (value.diff === Acl.SystemPermissionsLevel.any) {
-				permissions.allow(role, AuthorizationActions.PROJECT_DIFF_ANY)
-				permissions.allow(role, AuthorizationActions.PROJECT_DIFF_SOME)
-			}
-
 			// history
 			if (value.history === Acl.SystemPermissionsLevel.any) {
 				permissions.allow(role, AuthorizationActions.PROJECT_HISTORY_ANY)
 			}
 
-			// release
-			if (value.release === Acl.SystemPermissionsLevel.some) {
-				permissions.allow(role, AuthorizationActions.PROJECT_RELEASE_SOME)
-			} else if (value.release === Acl.SystemPermissionsLevel.any) {
-				permissions.allow(role, AuthorizationActions.PROJECT_RELEASE_ANY)
-				permissions.allow(role, AuthorizationActions.PROJECT_RELEASE_SOME)
-			}
-
-			// rebase
-			if (value.rebase === Acl.SystemPermissionsLevel.any) {
-				permissions.allow(role, AuthorizationActions.PROJECT_REBASE_ANY)
-			}
-
 			// migrate
 			if (value.migrate) {
 				permissions.allow(role, AuthorizationActions.PROJECT_MIGRATE)

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

@@ -17,11 +17,10 @@ export class CreateOrUpdateStageCommand implements Command<boolean> {
 			.onConflict(ConflictActionType.update, ['slug'], {
 				name: this.stage.name,
 			})
-			.returning('event_id')
 			.execute(db)
 
 		await db.query('CREATE SCHEMA IF NOT EXISTS ' + wrapIdentifier(formatSchemaName(this.stage)))
 
-		return result.length === 1
+		return result > 0
 	}
 }

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

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

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

@@ -1,2 +1 @@
-export * from './ContentEventsApplier'
 export * from './EntitiesSelector'

package/src/model/dependencies/index.ts

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

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

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

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

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

package/src/model/events/{HistoryEventResponseBuilder.ts → EventResponseBuilder.ts}

@@ -1,32 +1,28 @@
 import { AnyEvent, EventType } from '@contember/engine-common'
-import {
-	HistoryCreateEvent,
-	HistoryDeleteEvent,
-	HistoryEvent as ApiEvent,
-	HistoryEventType as ApiEventType,
-	HistoryUpdateEvent,
-} from '../../schema'
+import { CreateEvent, DeleteEvent, EventType as ApiEventType, UpdateEvent } from '../../schema'
 import { assertNever } from '../../utils'
-import { IdentityFetcher } from '../dependencies/tenant/IdentityFetcher'
+import { IdentityFetcher } from '../dependencies'
 import { formatIdentity } from './identityUtils'
 import { appendCreateSpecificData, appendDeleteSpecificData, appendUpdateSpecificData } from './EventResponseHelper'
+import { Client } from '@contember/database'
 
-export class HistoryEventResponseBuilder {
+export class EventResponseBuilder {
 	constructor(private readonly identityFetcher: IdentityFetcher) {}
 
-	public async buildResponse(events: AnyEvent[]): Promise<ApiEvent[]> {
+	public async buildResponse(tenantDb: Client, events: AnyEvent[]): Promise<(CreateEvent | DeleteEvent | UpdateEvent)[]> {
 		const apiEventTypeMapping = {
 			[EventType.create]: ApiEventType.Create,
 			[EventType.update]: ApiEventType.Update,
 			[EventType.delete]: ApiEventType.Delete,
 		}
 		const identityIds = events.map(it => it.identityId).filter((it, index, ids) => ids.indexOf(it) === index)
-		const identities = await this.identityFetcher.fetchIdentities(identityIds)
+		const identities = await this.identityFetcher.fetchIdentities(tenantDb, identityIds)
 		const identitiesMap = Object.fromEntries(identities.map(it => [it.identityId, it]))
 
 		return events.map(it => {
 			const commonData = {
 				createdAt: it.createdAt,
+				appliedAt: it.appliedAt,
 				id: it.id,
 				type: apiEventTypeMapping[it.type],
 				description: this.formatDescription(it),
@@ -36,11 +32,11 @@ export class HistoryEventResponseBuilder {
 			}
 			switch (it.type) {
 				case EventType.create:
-					return ((): HistoryCreateEvent => appendCreateSpecificData(commonData, it))()
+					return ((): CreateEvent => appendCreateSpecificData(commonData, it))()
 				case EventType.update:
-					return ((): HistoryUpdateEvent => appendUpdateSpecificData(commonData, it))()
+					return ((): UpdateEvent => appendUpdateSpecificData(commonData, it))()
 				case EventType.delete:
-					return ((): HistoryDeleteEvent => appendDeleteSpecificData(commonData, it))()
+					return ((): DeleteEvent => appendDeleteSpecificData(commonData, it))()
 			}
 			assertNever(it)
 		})
@@ -49,11 +45,11 @@ export class HistoryEventResponseBuilder {
 	private formatDescription(event: AnyEvent): string {
 		switch (event.type) {
 			case EventType.create:
-				return `Creating ${event.tableName}#${event.rowId}`
+				return `Creating ${event.tableName}#${event.rowId.join(';')}`
 			case EventType.update:
-				return `Updating ${event.tableName}#${event.rowId}`
+				return `Updating ${event.tableName}#${event.rowId.join(';')}`
 			case EventType.delete:
-				return `Deleting ${event.tableName}#${event.rowId}`
+				return `Deleting ${event.tableName}#${event.rowId.join(';')}`
 			default:
 				return assertNever(event)
 		}

package/src/model/events/EventResponseHelper.ts

@@ -3,7 +3,7 @@ import { AnyEvent, ContentEvent, CreateEvent, DeleteEvent, UpdateEvent } from '@
 export const appendUpdateSpecificData = <T>(commonData: T, event: UpdateEvent) => ({
 	...commonData,
 	tableName: event.tableName,
-	primaryKeys: event.rowId,
+	primaryKey: event.rowId,
 	diffValues: event.values,
 	oldValues: {},
 })
@@ -11,13 +11,13 @@ export const appendUpdateSpecificData = <T>(commonData: T, event: UpdateEvent) =
 export const appendCreateSpecificData = <T>(commonData: T, event: CreateEvent) => ({
 	...commonData,
 	tableName: event.tableName,
-	primaryKeys: event.rowId,
+	primaryKey: event.rowId,
 	newValues: event.values,
 })
 
 export const appendDeleteSpecificData = <T>(commonData: T, event: DeleteEvent) => ({
 	...commonData,
 	tableName: event.tableName,
-	primaryKeys: event.rowId,
+	primaryKey: event.rowId,
 	oldValues: {},
 })

package/src/model/events/index.ts

@@ -1,5 +1 @@
-export * from './dependency'
-export * from './DependencyBuilder'
-export * from './DiffBuilder'
-export * from './HistoryEventResponseBuilder'
-export * from './TableReferencingResolver'
+export * from './EventResponseBuilder'

package/src/model/migrations/MigrationExecutor.ts

@@ -1,10 +1,8 @@
-import { EventType } from '@contember/engine-common'
 import { wrapIdentifier } from '@contember/database'
 import { Schema } from '@contember/schema'
 import { Migration, ModificationHandlerFactory } from '@contember/schema-migrations'
 import { createMigrationBuilder } from '@contember/database-migrations'
 import { Stage } from '../dtos'
-import { UpdateStageEventCommand } from '../commands'
 import { formatSchemaName } from '../helpers'
 import { DatabaseContext } from '../database'
 

package/src/model/migrations/ProjectMigrator.ts

@@ -1,4 +1,3 @@
-import { createStageTree, StageTree } from '../stages'
 import { Migration, MigrationDescriber } from '@contember/schema-migrations'
 import { Client, QueryError, wrapIdentifier } from '@contember/database'
 import { formatSchemaName } from '../helpers'
@@ -10,7 +9,6 @@ import { ExecutedMigrationsResolver } from './ExecutedMigrationsResolver'
 import { MigrateErrorCode } from '../../schema'
 import { ProjectConfig } from '../../types'
 import { SchemaVersionBuilder } from './SchemaVersionBuilder'
-import { StagingDisabledError } from '../../StagingDisabledError'
 
 export class ProjectMigrator {
 	constructor(
@@ -26,7 +24,6 @@ export class ProjectMigrator {
 		logger: (message: string) => void,
 		ignoreOrder: boolean = false,
 	) {
-		const stageTree = createStageTree(project)
 		if (migrationsToExecute.length === 0) {
 			return
 		}
@@ -35,10 +32,6 @@ export class ProjectMigrator {
 
 		const sorted = [...migrationsToExecute].sort((a, b) => a.version.localeCompare(b.version))
 
-		const rootStage = stageTree.getRoot()
-		if (stageTree.getChildren(rootStage).length !== 0) {
-			throw new StagingDisabledError()
-		}
 		for (const migration of sorted) {
 			logger(`Executing migration ${migration.name}...`)
 			const formatVersion = migration.formatVersion
@@ -46,7 +39,7 @@ export class ProjectMigrator {
 			for (const modification of migration.modifications) {
 				[schema] = await this.applyModification(
 					db.client,
-					stageTree,
+					project.stages,
 					schema,
 					modification,
 					formatVersion,
@@ -93,19 +86,20 @@ export class ProjectMigrator {
 
 	private async applyModification(
 		db: Client,
-		stageTree: StageTree,
+		stages: StageWithoutEvent[],
 		schema: Schema,
 		modification: Migration.Modification,
 		formatVersion: number,
 		migrationVersion: string,
 	): Promise<[Schema]> {
-		const stage = stageTree.getRoot()
 		const {
 			sql,
 			schema: newSchema,
 			handler,
 		} = await this.migrationDescriber.describeModification(schema, modification, formatVersion)
-		await this.executeOnStage(db, stage, sql, migrationVersion)
+		for (const stage of stages) {
+			await this.executeOnStage(db, stage, sql, migrationVersion)
+		}
 		return [newSchema]
 	}
 

package/src/model/migrations/SchemaVersionBuilder.ts

@@ -7,7 +7,7 @@ import { normalizeSchema } from '@contember/schema-utils'
 
 export type VersionedSchema = Schema & { version: string; notNormalized: Schema & { version: string } }
 
-const emptyVersionedSchema = { ...emptySchema, version: '', notNormalized: { ...emptySchema, version: '' } }
+const emptyVersionedSchema = { ...normalizeSchema(emptySchema), version: '', notNormalized: { ...emptySchema, version: '' } }
 
 export class SchemaVersionBuilder {
 	constructor(

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

@@ -4,46 +4,49 @@ import { assertNever } from '../../../utils'
 export type EventRow = {
 	id: string
 	type: EventType
-	data: any
-	previous_id: string
+	table_name: string
+	row_ids: string[]
+	values: Record<string, any>
 	created_at: Date
+	applied_at: Date
 	identity_id: string
 	transaction_id: string
-	index: number
 }
 
 export const createEventsFromRows = (rows: EventRow[]): AnyEvent[] => {
 	return rows.map(event => {
-		const data = event.data
 		switch (event.type) {
 			case EventType.create:
 				return new CreateEvent(
 					event.id,
 					event.created_at,
+					event.applied_at,
 					event.identity_id,
 					event.transaction_id,
-					typeof data.rowId === 'string' ? [data.rowId] : data.rowId,
-					data.tableName,
-					data.values,
+					event.row_ids,
+					event.table_name,
+					event.values,
 				)
 			case EventType.update:
 				return new UpdateEvent(
 					event.id,
 					event.created_at,
+					event.applied_at,
 					event.identity_id,
 					event.transaction_id,
-					typeof data.rowId === 'string' ? [data.rowId] : data.rowId,
-					data.tableName,
-					data.values,
+					event.row_ids,
+					event.table_name,
+					event.values,
 				)
 			case EventType.delete:
 				return new DeleteEvent(
 					event.id,
 					event.created_at,
+					event.applied_at,
 					event.identity_id,
 					event.transaction_id,
-					typeof data.rowId === 'string' ? [data.rowId] : data.rowId,
-					data.tableName,
+					event.row_ids,
+					event.table_name,
 				)
 			default:
 				assertNever(event.type)