@contember/engine-content-api 1.2.1 → 1.3.0-alpha.2

package/src/mapper/EventManager.ts

@@ -0,0 +1,158 @@
+import { Input, Model, Value } from '@contember/schema'
+import { ResolvedColumnValue } from './ColumnValue'
+import { Mapper } from './Mapper'
+import { logger } from '@contember/logger'
+
+export class BeforeInsertEvent {
+	public type = 'BeforeInsertEvent' as const
+
+	public afterEvent: AfterInsertEvent | undefined = undefined
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly data: ResolvedColumnValue[],
+	) {
+	}
+}
+
+export class AfterInsertEvent {
+	public type = 'AfterInsertEvent' as const
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly data: ResolvedColumnValue[],
+		public readonly id: Input.PrimaryValue,
+	) {
+	}
+}
+
+
+export class BeforeUpdateEvent {
+	public type = 'BeforeUpdateEvent' as const
+
+	public afterEvent: AfterUpdateEvent | undefined = undefined
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly data: ResolvedColumnValue[],
+		public readonly id: Input.PrimaryValue,
+	) {
+	}
+}
+
+export class AfterUpdateEvent {
+	public type = 'AfterUpdateEvent' as const
+
+	private _hasChanges: boolean | undefined
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly data: (ResolvedColumnValue & { old: Value.FieldValue })[],
+		public readonly id: Input.PrimaryValue,
+	) {
+	}
+	get hasChanges() {
+		// todo: deep equals
+		return this._hasChanges = this.data.some(it => it.resolvedValue !== it.old)
+	}
+}
+
+export class BeforeDeleteEvent {
+	public type = 'BeforeDeleteEvent' as const
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly id: Input.PrimaryValue,
+	) {
+	}
+}
+
+export class BeforeJunctionUpdateEvent {
+	public type = 'BeforeJunctionUpdateEvent' as const
+
+	public afterEvent: AfterJunctionUpdateEvent | undefined = undefined
+
+	constructor(
+		public readonly owningEntity: Model.Entity,
+		public readonly owningRelation: Model.ManyHasManyOwningRelation,
+		public readonly owningId: Input.PrimaryValue,
+		public readonly inverseId: Input.PrimaryValue,
+		public readonly operation: 'connect' | 'disconnect',
+	) {
+	}
+}
+
+
+export class AfterJunctionUpdateEvent {
+	public type = 'AfterJunctionUpdateEvent' as const
+
+	constructor(
+		public readonly owningEntity: Model.Entity,
+		public readonly owningRelation: Model.ManyHasManyOwningRelation,
+		public readonly owningId: Input.PrimaryValue,
+		public readonly inverseId: Input.PrimaryValue,
+		public readonly operation: 'connect' | 'disconnect',
+		public readonly hasChanges: boolean,
+	) {
+	}
+}
+
+export class BeforeCommitEvent {
+	public type = 'BeforeCommitEvent' as const
+}
+
+export class AfterCommitEvent {
+	public type = 'AfterCommitEvent' as const
+}
+
+export type DataModificationEvent =
+	| BeforeInsertEvent
+	| AfterInsertEvent
+	| BeforeUpdateEvent
+	| AfterUpdateEvent
+	| BeforeJunctionUpdateEvent
+	| AfterJunctionUpdateEvent
+	| BeforeDeleteEvent
+
+export type AnyEvent =
+	| DataModificationEvent
+	| BeforeCommitEvent
+	| AfterCommitEvent
+
+export type EventMap<E extends AnyEvent = AnyEvent> = {
+	[K in E['type']]: E extends { type: K } ? E : never
+}
+
+export type EventListener<K extends keyof EventMap> = (event: EventMap[K], mapper: Mapper) => Promise<void>
+
+export class EventManager {
+	private listeners: { [K in keyof EventMap]: EventListener<K>[] } = {
+		BeforeInsertEvent: [],
+		AfterInsertEvent: [],
+		BeforeUpdateEvent: [],
+		AfterUpdateEvent: [],
+		BeforeDeleteEvent: [],
+		BeforeCommitEvent: [],
+		AfterCommitEvent: [],
+		BeforeJunctionUpdateEvent: [],
+		AfterJunctionUpdateEvent: [],
+	}
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public listen<K extends keyof EventMap>(type: K, cb: EventListener<K>) {
+		this.listeners[type].push(cb)
+	}
+
+	public async fire<K extends keyof EventMap>(event: EventMap[K]) {
+		(await Promise.allSettled(this.listeners[event.type].map(it => (it as EventListener<K>)(event, this.mapper))))
+			.map(it => {
+				if (it.status === 'rejected') {
+					logger.error(it.reason)
+				}
+			})
+	}
+}

package/src/mapper/JunctionTableManager.ts

@@ -1,6 +1,5 @@
 import { getEntity } from '@contember/schema-utils'
-import { PathFactory } from './select'
-import { WhereBuilder } from './select'
+import { PathFactory, WhereBuilder } from './select'
 import { PredicateFactory } from '../acl'
 import {
 	Client,
@@ -16,14 +15,21 @@ import {
 	MutationJunctionUpdateOk,
 	MutationNoResultError,
 	MutationNothingToDo,
-	MutationResult,
 	MutationResultList,
+	MutationResultType,
 	NothingToDoReason,
 } from './Result'
 import { ImplementationException } from '../exception'
+import { AfterJunctionUpdateEvent, BeforeJunctionUpdateEvent } from './EventManager'
+import { Mapper } from './Mapper'
 
 type OkResultFactory = () => MutationJunctionUpdateOk
 
+type JunctionMutationResult =
+	| MutationJunctionUpdateOk
+	| MutationNothingToDo
+	| MutationNoResultError
+
 export class JunctionTableManager {
 	constructor(
 		private readonly schema: Model.Schema,
@@ -35,43 +41,55 @@ export class JunctionTableManager {
 	) {}
 
 	public async connectJunction(
-		db: Client,
+		mapper: Mapper,
 		owningEntity: Model.Entity,
 		relation: Model.ManyHasManyOwningRelation,
 		owningUnique: Input.PrimaryValue,
 		inverseUnique: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-		return [
-			await this.executeJunctionModification(
-				db,
-				owningEntity,
-				relation,
-				owningUnique,
-				inverseUnique,
-				this.connectJunctionHandler,
-			),
-		]
+		const beforeEvent = new BeforeJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'connect')
+		await mapper.eventManager.fire(beforeEvent)
+		const result = await this.executeJunctionModification(
+			mapper.db,
+			owningEntity,
+			relation,
+			owningUnique,
+			inverseUnique,
+			this.connectJunctionHandler,
+		)
+		if (result.result !== MutationResultType.noResultError) {
+			const afterEvent = new AfterJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'connect', result.result === MutationResultType.ok)
+			await mapper.eventManager.fire(afterEvent)
+		}
+		return [result]
 	}
 
 	public async disconnectJunction(
-		db: Client,
+		mapper: Mapper,
 		owningEntity: Model.Entity,
 		relation: Model.ManyHasManyOwningRelation,
 		owningUnique: Input.PrimaryValue,
 		inverseUnique: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-		return [
-			await this.executeJunctionModification(
-				db,
-				owningEntity,
-				relation,
-				owningUnique,
-				inverseUnique,
-				this.disconnectJunctionHandler,
-			),
-		]
+		const beforeEvent = new BeforeJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'connect')
+		await mapper.eventManager.fire(beforeEvent)
+		const result = await this.executeJunctionModification(
+			mapper.db,
+			owningEntity,
+			relation,
+			owningUnique,
+			inverseUnique,
+			this.disconnectJunctionHandler,
+		)
+		if (result.result !== MutationResultType.noResultError) {
+			const afterEvent = new AfterJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'disconnect', result.result === MutationResultType.ok)
+			beforeEvent.afterEvent = afterEvent
+			await mapper.eventManager.fire(afterEvent)
+		}
+		return [result]
 	}
 
+
 	private async executeJunctionModification(
 		db: Client,
 		owningEntity: Model.Entity,
@@ -79,7 +97,7 @@ export class JunctionTableManager {
 		owningPrimary: Input.PrimaryValue,
 		inversePrimary: Input.PrimaryValue,
 		handler: JunctionHandler,
-	): Promise<MutationResult> {
+	): Promise<JunctionMutationResult> {
 		const joiningTable = relation.joiningTable
 		const inverseEntity = getEntity(this.schema, relation.target)
 		if (inverseEntity.view || owningEntity.view) {
@@ -145,9 +163,9 @@ interface JunctionComplexExecutionArgs {
 }
 
 interface JunctionHandler {
-	executeSimple(args: JunctionSimpleExecutionArgs): Promise<MutationResult>
+	executeSimple(args: JunctionSimpleExecutionArgs): Promise<JunctionMutationResult>
 
-	executeComplex(args: JunctionComplexExecutionArgs): Promise<MutationResult>
+	executeComplex(args: JunctionComplexExecutionArgs): Promise<JunctionMutationResult>
 }
 
 export class JunctionConnectHandler implements JunctionHandler {
@@ -157,7 +175,7 @@ export class JunctionConnectHandler implements JunctionHandler {
 		owningPrimary,
 		inversePrimary,
 		okResultFactory,
-	}: JunctionSimpleExecutionArgs): Promise<MutationResult> {
+	}: JunctionSimpleExecutionArgs): Promise<JunctionMutationResult> {
 		const result = await InsertBuilder.create()
 			.into(joiningTable.tableName)
 			.values({
@@ -177,7 +195,7 @@ export class JunctionConnectHandler implements JunctionHandler {
 		joiningTable,
 		dataCallback,
 		okResultFactory,
-	}: JunctionComplexExecutionArgs): Promise<MutationResult> {
+	}: JunctionComplexExecutionArgs): Promise<JunctionMutationResult> {
 		const insert = InsertBuilder.create()
 			.into(joiningTable.tableName)
 			.values({
@@ -216,7 +234,7 @@ export class JunctionDisconnectHandler implements JunctionHandler {
 		owningPrimary,
 		inversePrimary,
 		okResultFactory,
-	}: JunctionSimpleExecutionArgs): Promise<MutationResult> {
+	}: JunctionSimpleExecutionArgs): Promise<JunctionMutationResult> {
 		const qb = DeleteBuilder.create()
 			.from(joiningTable.tableName)
 			.where(cond => cond.compare(joiningTable.joiningColumn.columnName, Operator.eq, owningPrimary))
@@ -234,7 +252,7 @@ export class JunctionDisconnectHandler implements JunctionHandler {
 		joiningTable,
 		dataCallback,
 		okResultFactory,
-	}: JunctionComplexExecutionArgs): Promise<MutationResult> {
+	}: JunctionComplexExecutionArgs): Promise<JunctionMutationResult> {
 		const deleteQb = DeleteBuilder.create()
 			.from(joiningTable.tableName)
 			.using('data')

package/src/mapper/Mapper.ts

@@ -1,35 +1,43 @@
 import { Input, Model } from '@contember/schema'
-import { getColumnName } from '@contember/schema-utils'
-import { SelectGroupedObjects, SelectHydrator, SelectIndexedResultObjects, SelectResultObject } from './select'
-import { PathFactory } from './select'
-import * as database from '@contember/database'
-import { Client, SelectBuilder } from '@contember/database'
-import { SelectBuilderFactory } from './select'
+import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
+import {
+	OrderByHelper,
+	PathFactory,
+	SelectBuilderFactory,
+	SelectGroupedObjects,
+	SelectHydrator,
+	SelectIndexedResultObjects,
+	SelectResultObject,
+	WhereBuilder,
+} from './select'
+import { Client, Connection, ConstraintHelper, SelectBuilder } from '@contember/database'
 import { PredicatesInjector } from '../acl'
-import { WhereBuilder } from './select'
 import { JunctionTableManager } from './JunctionTableManager'
 import { DeletedEntitiesStorage, DeleteExecutor } from './delete'
 import { MutationEntryNotFoundError, MutationResultList } from './Result'
-import { Updater } from './update'
-import { Inserter } from './insert'
+import { UpdateBuilder, Updater } from './update'
+import { InsertBuilder, Inserter } from './insert'
 import { tryMutation } from './ErrorUtils'
-import { OrderByHelper } from './select'
-import {  ObjectNode, UniqueWhereExpander } from '../inputProcessing'
-import { UpdateBuilder } from './update'
+import { ObjectNode, UniqueWhereExpander } from '../inputProcessing'
 import { Mutex } from '../utils'
 import { CheckedPrimary } from './CheckedPrimary'
-import { ConstraintHelper } from '@contember/database'
 import { ImplementationException } from '../exception'
+import { EventManager } from './EventManager'
 
-export class Mapper {
+export class Mapper<ConnectionType extends Connection.ConnectionLike = Connection.ConnectionLike> {
 	private primaryKeyCache: Record<string, Promise<string> | string> = {}
+	private systemVariablesSetupDone: Promise<void> | undefined
 	public readonly deletedEntities = new DeletedEntitiesStorage()
 	public readonly mutex = new Mutex()
 	public readonly constraintHelper: ConstraintHelper
 
+	public readonly eventManager: EventManager
+
 	constructor(
+		public readonly db: Client<ConnectionType>,
+		public readonly identityId: string,
+		public readonly transactionId: string,
 		private readonly schema: Model.Schema,
-		public readonly db: database.Client,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,
@@ -41,9 +49,10 @@ export class Mapper {
 		private readonly pathFactory: PathFactory,
 	) {
 		this.constraintHelper = new ConstraintHelper(db)
+		this.eventManager = new EventManager(this)
 	}
 
-	public async selectField(entity: Model.Entity, where: Input.UniqueWhere, fieldName: string) {
+	public async selectField(entity: Model.Entity, where: Input.UniqueWhere | CheckedPrimary, fieldName: string) {
 		const columnName = getColumnName(this.schema, entity, fieldName)
 
 		const qb = SelectBuilder.create() //
@@ -119,7 +128,7 @@ export class Mapper {
 		relationPath: Model.AnyRelationContext[],
 		groupBy?: string,
 	) {
-		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, [])
+		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, undefined)
 		const path = this.pathFactory.create([])
 		const augmentedBuilder = qb.from(entity.tableName, path.alias).meta('path', [...input.path, input.alias])
 
@@ -163,15 +172,17 @@ export class Mapper {
 		return Object.fromEntries(result)
 	}
 
-	public async insert(entity: Model.Entity, data: Input.CreateDataInput): Promise<MutationResultList> {
+	public async insert(
+		entity: Model.Entity,
+		data: Input.CreateDataInput,
+		builderCb: (builder: InsertBuilder) => void = () => {},
+	): Promise<MutationResultList> {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, () =>
-			this.inserter.insert(this, entity, data, id => {
-				const where = { [entity.primary]: id }
-				this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
-			}),
+			this.insertInternal(entity, data, builderCb),
 		)
 	}
 
@@ -184,6 +195,7 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
@@ -195,19 +207,21 @@ export class Mapper {
 
 	public async updateInternal(
 		entity: Model.Entity,
-		by: Input.UniqueWhere,
-		predicateFields: string[],
+		by: Input.UniqueWhere | CheckedPrimary,
 		builderCb: (builder: UpdateBuilder) => void,
 	): Promise<MutationResultList> {
+		if (entity.view) {
+			throw new ImplementationException()
+		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
-				return [new MutationEntryNotFoundError([], by)]
+				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
 			}
-			return await this.updater.updateCb(this, entity, primaryValue, predicateFields, builderCb)
+			return await this.updater.updateCb(this, entity, primaryValue, builderCb)
 		})
 	}
-
 	public async upsert(
 		entity: Model.Entity,
 		by: Input.UniqueWhere,
@@ -218,18 +232,23 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
-				return await this.inserter.insert(this, entity, create, id => {
-					const where = { [entity.primary]: id }
-					this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
-				})
+				return await this.insertInternal(entity, create)
 			}
 			return await this.updater.update(this, entity, primaryValue, update, filter)
 		})
 	}
 
+	private insertInternal(entity: Model.Entity, data: Input.CreateDataInput, builderCb: (builder: InsertBuilder) => void = () => {}) {
+		return this.inserter.insert(this, entity, data, id => {
+			const where = { [entity.primary]: id }
+			this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
+		}, builderCb)
+	}
+
 	public async delete(
 		entity: Model.Entity,
 		by: Input.UniqueWhere | CheckedPrimary,
@@ -238,37 +257,58 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, () => this.deleteExecutor.execute(this, entity, by, filter))
 	}
 
 	public async connectJunction(
-		owningEntity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		owningPrimary: Input.PrimaryValue,
-		inversePrimary: Input.PrimaryValue,
+		entity: Model.Entity,
+		relation: Model.ManyHasManyOwningRelation | Model.ManyHasManyInverseRelation,
+		thisPrimary: Input.PrimaryValue,
+		otherPrimary: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-		return await this.junctionTableManager.connectJunction(
-			this.db,
-			owningEntity,
-			relation,
-			owningPrimary,
-			inversePrimary,
-		)
+		await this.setupSystemVariables()
+		const err = () => {
+			throw new ImplementationException()
+		}
+		return await acceptFieldVisitor(this.schema, entity, relation, {
+			visitManyHasManyOwning: ({ entity, relation }) => {
+				return this.junctionTableManager.connectJunction(this, entity, relation, thisPrimary, otherPrimary)
+			},
+			visitManyHasManyInverse: ({ targetEntity, targetRelation }) => {
+				return this.junctionTableManager.connectJunction(this, targetEntity, targetRelation, otherPrimary, thisPrimary)
+			},
+			visitColumn: err,
+			visitOneHasMany: err,
+			visitOneHasOneInverse: err,
+			visitOneHasOneOwning: err,
+			visitManyHasOne: err,
+		})
 	}
 
 	public async disconnectJunction(
-		owningEntity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		owningPrimary: Input.PrimaryValue,
-		inversePrimary: Input.PrimaryValue,
+		entity: Model.Entity,
+		relation: Model.ManyHasManyOwningRelation | Model.ManyHasManyInverseRelation,
+		thisPrimary: Input.PrimaryValue,
+		otherPrimary: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-		return await this.junctionTableManager.disconnectJunction(
-			this.db,
-			owningEntity,
-			relation,
-			owningPrimary,
-			inversePrimary,
-		)
+		await this.setupSystemVariables()
+		const err = () => {
+			throw new ImplementationException()
+		}
+		return await acceptFieldVisitor(this.schema, entity, relation, {
+			visitManyHasManyOwning: ({ entity, relation }) => {
+				return this.junctionTableManager.disconnectJunction(this, entity, relation, thisPrimary, otherPrimary)
+			},
+			visitManyHasManyInverse: ({ targetEntity, targetRelation }) => {
+				return this.junctionTableManager.disconnectJunction(this, targetEntity, targetRelation, otherPrimary, thisPrimary)
+			},
+			visitColumn: err,
+			visitOneHasMany: err,
+			visitOneHasOneInverse: err,
+			visitOneHasOneOwning: err,
+			visitManyHasOne: err,
+		})
 	}
 
 	public async getPrimaryValue(
@@ -295,6 +335,12 @@ export class Mapper {
 	private hashWhere(entityName: string, where: Input.UniqueWhere): string {
 		return JSON.stringify([entityName, where])
 	}
-}
 
-export type MapperFactory = (db: Client) => Mapper
+	private async setupSystemVariables() {
+		this.systemVariablesSetupDone ??= (async () => {
+			await this.db.query('SELECT set_config(?, ?, false)', ['tenant.identity_id', this.identityId]) // todo rename to system.identity_id
+			await this.db.query('SELECT set_config(?, ?, false)', ['system.transaction_id', this.transactionId])
+		})()
+		await this.systemVariablesSetupDone
+	}
+}

package/src/mapper/MapperFactory.ts

@@ -0,0 +1,67 @@
+import { PredicatesInjector } from '../acl'
+import { PathFactory, SelectBuilderFactory, WhereBuilder } from './select'
+import { UniqueWhereExpander } from '../inputProcessing'
+import { JunctionTableManager } from './JunctionTableManager'
+import { DeleteExecutor } from './delete'
+import { Updater } from './update'
+import { Inserter } from './insert'
+import { Model } from '@contember/schema'
+import { Client, Connection } from '@contember/database'
+import { Mapper } from './Mapper'
+import { Providers } from '@contember/schema-utils'
+
+export type MapperFactoryHook = (mapper: Mapper) => void
+
+export class MapperFactory {
+
+	public readonly hooks: MapperFactoryHook[] = []
+
+	constructor(
+		private readonly db: Client,
+		private readonly identityId: string,
+		private readonly schema: Model.Schema,
+		private readonly predicatesInjector: PredicatesInjector,
+		private readonly selectBuilderFactory: SelectBuilderFactory,
+		private readonly uniqueWhereExpander: UniqueWhereExpander,
+		private readonly whereBuilder: WhereBuilder,
+		private readonly junctionTableManager: JunctionTableManager,
+		private readonly deleteExecutor: DeleteExecutor,
+		private readonly updater: Updater,
+		private readonly inserter: Inserter,
+		private readonly pathFactory: PathFactory,
+		private readonly providers: Providers,
+	) {
+	}
+
+	public create() {
+		return this.createInternal(this.db)
+	}
+
+	public transaction<T>(cb: (mapper: Mapper<Connection.TransactionLike>) => Promise<T>): Promise<T> {
+		return this.db.transaction(async trx => {
+			await trx.connection.query(Connection.REPEATABLE_READ)
+			const mapper = this.createInternal(trx)
+			return await cb(mapper)
+		})
+	}
+
+	private createInternal<T extends Connection.ConnectionLike>(db: Client<T>) {
+		const mapper = new Mapper<T>(
+			db,
+			this.identityId,
+			this.providers.uuid(),
+			this.schema,
+			this.predicatesInjector,
+			this.selectBuilderFactory,
+			this.uniqueWhereExpander,
+			this.whereBuilder,
+			this.junctionTableManager,
+			this.deleteExecutor,
+			this.updater,
+			this.inserter,
+			this.pathFactory,
+		)
+		this.hooks.forEach(it => it(mapper))
+		return mapper
+	}
+}

package/src/mapper/Result.ts

@@ -50,7 +50,7 @@ interface MutationResultInterface {
 	hints: MutationResultHint[]
 }
 
-export type RowValues = { [fieldName: string]: Value.AtomicValue }
+export type RowValues = { [fieldName: string]: Value.FieldValue }
 
 export class MutationUpdateOk implements MutationResultInterface {
 	result = MutationResultType.ok as const
@@ -63,6 +63,7 @@ export class MutationUpdateOk implements MutationResultInterface {
 		public readonly primary: Value.PrimaryValue,
 		public readonly input: Input.UpdateDataInput,
 		public readonly values: RowValues,
+		public readonly oldValues?: RowValues,
 	) {}
 }
 
@@ -170,7 +171,7 @@ export class MutationEntryNotFoundError implements MutationResultInterface {
 	hints: MutationResultHint[] = []
 	message: string
 
-	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere) {
+	constructor(public readonly paths: Path[], public readonly where: Input.UniqueWhere | Input.Where) {
 		this.message = 'for input ' + JSON.stringify(where)
 	}
 }