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

package/src/mapper/DataManipulationBuilder.ts

@@ -0,0 +1,12 @@
+import { Value } from '@contember/schema'
+
+export interface DataManipulationBuilder {
+	addFieldValue(
+		fieldName: string,
+		value: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,
+	): Promise<Value.AtomicValue<AbortDataManipulation | undefined>>
+}
+
+
+export const AbortDataManipulation = Symbol('AbortDataManipulation')
+export type AbortDataManipulation = typeof AbortDataManipulation

package/src/mapper/ErrorUtils.ts

@@ -11,31 +11,37 @@ import {
 import * as Database from '@contember/database'
 import { UniqueWhereError } from '../inputProcessing'
 import { Model } from '@contember/schema'
-import { isOwningRelation, isRelation, NamingHelper } from '@contember/schema-utils'
+import { acceptFieldVisitor, SchemaDatabaseMetadata, tryGetColumnName } from '@contember/schema-utils'
 import { logger } from '@contember/logger'
-import RelationType = Model.RelationType
 
 
-const findUniqueConstraint = (schema: Model.Schema, constraintName: string): [Model.Entity, Model.UniqueConstraint] | [null, null] => {
-	for (const entity of Object.values(schema.entities)) {
-		for (const constraint of Object.values(entity.unique)) {
-			if (constraint.name === constraintName) {
-				return [entity, constraint]
-			}
-		}
+type UniqueConstraintResult = {
+	entity: Model.Entity
+	fields: string[]
+}
+
+const getEntityByTableName = (model: Model.Schema, tableName: string) => Object.values(model.entities).find(it => it.tableName === tableName)
+
+const findUniqueConstraint = (model: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, tableName: string, constraintName: string): UniqueConstraintResult | null => {
+	const constraint = databaseMetadata.getUniqueConstraint(tableName, constraintName)
+	if (!constraint) {
+		return null
 	}
-	for (const entity of Object.values(schema.entities)) {
-		for (const field of Object.values(entity.fields)) {
-			if (
-				field.type === RelationType.OneHasOne &&
-				isOwningRelation(field) &&
-				NamingHelper.createUniqueConstraintName(entity.name, [field.name]) === constraintName
-			) {
-				return [entity, { name: constraintName, fields: [field.name] }]
-			}
+	const entity = getEntityByTableName(model, constraint.tableName)
+	if (!entity) {
+		return null
+	}
+	const fieldsInConstraint: string[] = []
+	for (const field of Object.values(entity.fields)) {
+		const columnName = tryGetColumnName(model, entity, field.name)
+		if (columnName && constraint.columnNames.includes(columnName)) {
+			fieldsInConstraint.push(field.name)
 		}
 	}
-	return [null, null]
+	if (fieldsInConstraint.length === constraint.columnNames.length) {
+		return { entity, fields: fieldsInConstraint }
+	}
+	return null
 }
 
 type RelationInfo = {
@@ -44,28 +50,47 @@ type RelationInfo = {
 	targetEntity: Model.Entity
 }
 
-const findForeignConstraint = (schema: Model.Schema, constraintName: string): RelationInfo | null => {
-	for (const owningEntity of Object.values(schema.entities)) {
-		for (const field of Object.values(owningEntity.fields)) {
-			if (!isRelation(field) || !isOwningRelation(field) || !('joiningColumn' in field)) {
-				continue
-			}
-			const targetEntity = schema.entities[field.target]
-			const fkName = NamingHelper.createForeignKeyName(
-				owningEntity.tableName,
-				field.joiningColumn.columnName,
-				targetEntity.tableName,
-				targetEntity.primaryColumn,
-			)
-			if (fkName === constraintName) {
-				return { owningEntity, targetEntity, owningRelation: field }
+const findForeignConstraint = (model: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, tableName: string, constraintName: string): RelationInfo | null => {
+	const constraint = databaseMetadata.getForeignKeyConstraint(tableName, constraintName)
+	if (!constraint) {
+		return null
+	}
+	const owningEntity = getEntityByTableName(model, constraint.fromTable)
+	if (!owningEntity) {
+		// todo m:n
+		return null
+	}
+
+	const targetEntity = getEntityByTableName(model, constraint.toTable)
+	if (!targetEntity) {
+		return null
+	}
+	for (const field of Object.values(owningEntity.fields)) {
+		const relation = acceptFieldVisitor<(Model.Relation & Model.JoiningColumnRelation) | null>(model, owningEntity, field, {
+			visitColumn: () => null,
+			visitOneHasOneInverse: () => null,
+			visitManyHasManyInverse: () => null,
+			visitManyHasManyOwning: () => null,
+			visitOneHasMany: () => null,
+			visitOneHasOneOwning: ({ relation }) => relation,
+			visitManyHasOne: ({ relation }) => relation,
+		})
+		if (relation && relation.joiningColumn.columnName === constraint.fromColumn) {
+			return {
+				owningEntity,
+				owningRelation: relation,
+				targetEntity,
 			}
 		}
 	}
 	return null
 }
 
-export const convertError = (schema: Model.Schema, e: any): MutationResult => {
+export const convertError = (
+	schema: Model.Schema,
+	databaseMetadata: SchemaDatabaseMetadata,
+	e: any,
+): MutationResult => {
 
 	if (e instanceof Database.NotNullViolationError) {
 		return new MutationConstraintViolationError([], ConstraintType.notNull, e.originalMessage, [
@@ -73,7 +98,7 @@ export const convertError = (schema: Model.Schema, e: any): MutationResult => {
 		])
 	}
 	if (e instanceof Database.ForeignKeyViolationError) {
-		const relationInfo = e.constraint ? findForeignConstraint(schema, e.constraint) : null
+		const relationInfo = e.constraint && e.table ? findForeignConstraint(schema, databaseMetadata, e.table, e.constraint) : null
 		const violationDetail: string = 'detail' in e.previous ? e.previous.detail : ''
 		const matchResult = violationDetail.match(/^Key \(.+\)=\((.+)\) is still referenced from table/)
 		const message = relationInfo
@@ -85,13 +110,13 @@ export const convertError = (schema: Model.Schema, e: any): MutationResult => {
 		return new MutationConstraintViolationError([], ConstraintType.foreignKey, message, [MutationResultHint.sqlError])
 	}
 	if (e instanceof Database.UniqueViolationError) {
-		const [entity, constraint] = e.constraint ? findUniqueConstraint(schema, e.constraint) : [null, null]
+		const constraint = e.constraint && e.table ? findUniqueConstraint(schema, databaseMetadata, e.table, e.constraint) : null
 		const violationDetail: string = 'detail' in e.previous ? e.previous.detail : ''
 		const matchResult = violationDetail.match(/^Key \(.+\)=\((.+)\) already exists\.$/)
 		const values = matchResult?.[1]
-		const message = constraint && entity
+		const message = constraint
 			? `${values ? `Value (${values})` : 'Unknown value'}` +
-			  ` already exists in unique columns (${constraint.fields.join(', ')}) on entity ${entity.name}`
+			  ` already exists in unique columns (${constraint.fields.join(', ')}) on entity ${constraint.entity.name}`
 			: e.originalMessage
 		const paths = constraint ? constraint.fields.map(it => [{ field: it }]) : []
 		return new MutationConstraintViolationError(paths, ConstraintType.uniqueKey, message, [MutationResultHint.sqlError])
@@ -115,10 +140,10 @@ export const convertError = (schema: Model.Schema, e: any): MutationResult => {
 	throw e
 }
 
-export const tryMutation = async (schema: Model.Schema, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
+export const tryMutation = async (schema: Model.Schema, databaseMetadata: SchemaDatabaseMetadata, cb: () => Promise<MutationResultList>): Promise<MutationResultList> => {
 	try {
 		return await cb()
 	} catch (e) {
-		return [convertError(schema, e)]
+		return [convertError(schema, databaseMetadata, e)]
 	}
 }

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')