@contember/engine-content-api 1.3.0-alpha.1 → 1.3.0-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.3.0-alpha.1",
+  "version": "1.3.0-alpha.4",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,21 +10,21 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.3.0-alpha.1",
-    "@contember/dic": "^1.3.0-alpha.1",
-    "@contember/logger": "^1.3.0-alpha.1",
-    "@contember/graphql-utils": "^1.3.0-alpha.1",
-    "@contember/schema": "^1.3.0-alpha.1",
-    "@contember/schema-definition": "^1.3.0-alpha.1",
-    "@contember/schema-utils": "^1.3.0-alpha.1",
+    "@contember/database": "^1.3.0-alpha.4",
+    "@contember/dic": "^1.3.0-alpha.4",
+    "@contember/logger": "^1.3.0-alpha.4",
+    "@contember/graphql-utils": "^1.3.0-alpha.4",
+    "@contember/schema": "^1.3.0-alpha.4",
+    "@contember/schema-definition": "^1.3.0-alpha.4",
+    "@contember/schema-utils": "^1.3.0-alpha.4",
     "@graphql-tools/schema": "^8.3.5",
     "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.3.0-alpha.1",
-    "@contember/engine-api-tester": "^1.3.0-alpha.1",
-    "@contember/schema-definition": "^1.3.0-alpha.1",
+    "@contember/database-tester": "^1.3.0-alpha.4",
+    "@contember/engine-api-tester": "^1.3.0-alpha.4",
+    "@contember/schema-definition": "^1.3.0-alpha.4",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/ExecutionContainer.ts

@@ -0,0 +1,204 @@
+import { PredicateFactory, PredicatesInjector, VariableInjector } from './acl'
+import {
+	ConditionBuilder,
+	FieldsVisitorFactory,
+	JoinBuilder,
+	MetaHandler,
+	OrderByBuilder,
+	RelationFetcher,
+	WhereBuilder,
+} from './mapper/select'
+import { UniqueWhereExpander } from './inputProcessing'
+import { HasManyToHasOneReducer, HasManyToHasOneReducerExecutionHandler } from './extensions'
+import {
+	DeleteExecutor,
+	InsertBuilderFactory,
+	Inserter,
+	JunctionConnectHandler,
+	JunctionDisconnectHandler,
+	JunctionTableManager,
+	MapperFactory,
+	PathFactory,
+	SelectBuilder,
+	SelectBuilderFactory,
+	SelectHydrator,
+	UpdateBuilderFactory,
+	Updater,
+} from './mapper'
+import { Builder } from '@contember/dic'
+import { Acl, Model, Schema } from '@contember/schema'
+import { Client, SelectBuilder as DbSelectBuilder } from '@contember/database'
+import { Providers } from '@contember/schema-utils'
+import { PaginatedHasManyExecutionHandler } from './extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
+import { PaginatedHasManyFieldProvider } from './extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
+import { WhereOptimizer } from './mapper/select/optimizer/WhereOptimizer'
+import { ConditionOptimizer } from './mapper/select/optimizer/ConditionOptimizer'
+import { GraphQlQueryAstFactory, MutationResolver, ReadResolver, ValidationResolver } from './resolvers'
+import {
+	ColumnValueResolver,
+	DependencyCollector,
+	EntityRulesResolver, InputPreValidator,
+	QueryAstFactory,
+	ValidationDataSelector,
+} from './input-validation'
+
+export type ExecutionContainerArgs = {
+	schema: Schema & { id: number }
+	db: Client
+	identityId: string
+	identityVariables: Acl.VariablesMap
+	permissions: Acl.Permissions
+	systemSchema: string
+	project: { slug: string }
+	stage: { id: string; slug: string }
+}
+
+export interface ExecutionContainer {
+	readResolver: ReadResolver
+	mutationResolver: MutationResolver
+	validationResolver: ValidationResolver
+}
+
+export type ExecutionContainerBuilder = ReturnType<ExecutionContainerFactory['createBuilderInternal']>
+export type ExecutionContainerHook = (builder: ExecutionContainerBuilder) => ExecutionContainerBuilder
+
+export class ExecutionContainerFactory {
+	public readonly hooks: ExecutionContainerHook[] = []
+
+	constructor(
+		private readonly providers: Providers,
+	) {
+	}
+
+	createBuilder(args: ExecutionContainerArgs): ExecutionContainerBuilder {
+		const builder = this.createBuilderInternal(args)
+		return this.hooks.reduce((acc, cb) => cb(acc), builder)
+	}
+
+	createBuilderInternal({ permissions, identityVariables, identityId, db, schema, systemSchema, stage, project }: ExecutionContainerArgs) {
+		return new Builder({})
+			.addService('systemSchema', () =>
+				systemSchema)
+			.addService('db', () =>
+				db)
+			.addService('project', () =>
+				project)
+			.addService('stage', () =>
+				stage)
+			.addService('schema', () =>
+				schema)
+			.addService('providers', () =>
+				this.providers)
+			.addService('variableInjector', ({ schema }) =>
+				new VariableInjector(schema.model, identityVariables))
+			.addService('predicateFactory', ({ variableInjector, schema }) =>
+				new PredicateFactory(permissions, schema.model, variableInjector))
+			.addService('predicatesInjector', ({ predicateFactory, schema }) =>
+				new PredicatesInjector(schema.model, predicateFactory))
+			.addService('joinBuilder', ({ schema }) =>
+				new JoinBuilder(schema.model))
+			.addService('conditionBuilder', () =>
+				new ConditionBuilder())
+			.addService('pathFactory', () =>
+				new PathFactory())
+			.addService('whereOptimized', ({ schema }) =>
+				new WhereOptimizer(schema.model, new ConditionOptimizer()))
+			.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema }) =>
+				new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized, schema.settings.useExistsInHasManyFilter === true))
+			.addService('orderByBuilder', ({ joinBuilder, schema }) =>
+				new OrderByBuilder(schema.model, joinBuilder))
+			.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>
+				new RelationFetcher(whereBuilder, orderByBuilder, predicatesInjector, pathFactory))
+			.addService('fieldsVisitorFactory', ({ relationFetcher, predicateFactory, whereBuilder, schema }) =>
+				new FieldsVisitorFactory(schema.model, relationFetcher, predicateFactory, whereBuilder))
+			.addService('metaHandler', ({ whereBuilder, predicateFactory }) =>
+				new MetaHandler(whereBuilder, predicateFactory))
+			.addService('uniqueWhereExpander', ({ schema }) =>
+				new UniqueWhereExpander(schema.model))
+			.addService('hasManyToHasOneReducer', ({ uniqueWhereExpander, schema }) =>
+				new HasManyToHasOneReducerExecutionHandler(schema.model, uniqueWhereExpander))
+			.addService('paginatedHasManyExecutionHandler', ({ relationFetcher, schema }) =>
+				new PaginatedHasManyExecutionHandler(schema.model, relationFetcher))
+			.addService('selectHandlers', ({ hasManyToHasOneReducer, paginatedHasManyExecutionHandler }) => ({
+				[HasManyToHasOneReducer.extensionName]: hasManyToHasOneReducer,
+				[PaginatedHasManyFieldProvider.extensionName]: paginatedHasManyExecutionHandler,
+			}))
+			.addService('selectBuilderFactory', ({ whereBuilder, orderByBuilder, fieldsVisitorFactory, metaHandler, selectHandlers, pathFactory, predicateFactory, schema }) =>
+				new (class implements SelectBuilderFactory {
+					create(qb: DbSelectBuilder, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder {
+						return new SelectBuilder(
+							schema.model,
+							whereBuilder,
+							orderByBuilder,
+							metaHandler,
+							qb,
+							hydrator,
+							fieldsVisitorFactory,
+							selectHandlers,
+							pathFactory,
+							relationPath,
+							predicateFactory,
+						)
+					}
+				})())
+			.addService('insertBuilderFactory', ({ whereBuilder, pathFactory, schema, predicateFactory }) =>
+				new InsertBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
+			.addService('updateBuilderFactory', ({ whereBuilder, pathFactory, schema, predicateFactory }) =>
+				new UpdateBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
+			.addService('connectJunctionHandler', () =>
+				new JunctionConnectHandler())
+			.addService('disconnectJunctionHandler', ({}) =>
+				new JunctionDisconnectHandler())
+			.addService('junctionTableManager', ({ predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory, schema }) =>
+				new JunctionTableManager(schema.model, predicateFactory, whereBuilder, connectJunctionHandler, disconnectJunctionHandler, pathFactory))
+			.addService('deleteExecutor', ({ predicateFactory, updateBuilderFactory, whereBuilder, pathFactory, schema }) =>
+				new DeleteExecutor(schema.model, predicateFactory, whereBuilder, updateBuilderFactory, pathFactory))
+			.addService('updater', ({ predicateFactory, updateBuilderFactory, schema }) =>
+				new Updater(schema.model, predicateFactory, updateBuilderFactory))
+			.addService('inserter', ({  insertBuilderFactory, providers, schema }) =>
+				new Inserter(schema.model,  insertBuilderFactory, providers))
+			.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory, providers, schema }) => {
+				return new MapperFactory(
+					db,
+					identityId,
+					schema.model,
+					predicatesInjector,
+					selectBuilderFactory,
+					uniqueWhereExpander,
+					whereBuilder,
+					junctionTableManager,
+					deleteExecutor,
+					updater,
+					inserter,
+					pathFactory,
+					providers,
+				)
+			})
+
+			.addService('queryAstFactory', () =>
+				new GraphQlQueryAstFactory())
+			.addService('readResolver', ({ mapperFactory, queryAstFactory }) =>
+				new ReadResolver(mapperFactory, queryAstFactory))
+			.addService('validationDependencyCollector', () =>
+				new DependencyCollector())
+			.addService('validationQueryAstFactory', ({ schema }) =>
+				new QueryAstFactory(schema.model))
+			.addService('dataSelector', ({ validationQueryAstFactory, schema }) =>
+				new ValidationDataSelector(schema.model, validationQueryAstFactory))
+			.addService('columnValueResolver', ({ providers }) =>
+				new ColumnValueResolver(providers))
+			.addService('entityRulesResolver', ({ schema }) =>
+				new EntityRulesResolver(schema.validation, schema.model))
+			.addService('inputPreValidator', ({ entityRulesResolver, columnValueResolver, dataSelector, schema }) =>
+				new InputPreValidator(schema.model, entityRulesResolver, columnValueResolver, dataSelector))
+			.addService('mutationResolver', ({ mapperFactory, inputPreValidator, queryAstFactory, schema }) =>
+				new MutationResolver(schema.model, mapperFactory, inputPreValidator, queryAstFactory))
+			.addService('validationResolver', ({ inputPreValidator, mapperFactory }) =>
+				new ValidationResolver(mapperFactory, inputPreValidator))
+	}
+
+	public create(args: ExecutionContainerArgs): ExecutionContainer {
+		return this.createBuilder(args).build().pick('validationResolver', 'readResolver', 'mutationResolver')
+	}
+}
+

package/src/index.ts

@@ -5,6 +5,29 @@ export * from './schema'
 export * from './inputProcessing'
 export { EntityRulesResolver } from './input-validation'
 export * from './types'
+export * from './ExecutionContainer'
 export { graphql } from 'graphql'
 export { UserError } from './exception'
-export { createMapperContainer } from './mapper'
+export {
+	DataModificationEvent,
+	AfterCommitEvent,
+	AfterInsertEvent,
+	AfterJunctionUpdateEvent,
+	AfterUpdateEvent,
+	BeforeCommitEvent,
+	BeforeDeleteEvent,
+	BeforeInsertEvent,
+	BeforeJunctionUpdateEvent,
+	BeforeUpdateEvent,
+	EventManager,
+	Mapper,
+	MapperFactory,
+	ExecutionContainer,
+	ExecutionContainerBuilder,
+	Path,
+	WhereBuilder,
+	PathFactory,
+	ExecutionContainerFactory,
+	ExecutionContainerHook,
+	ExecutionContainerArgs,
+} from './mapper'

package/src/mapper/ColumnValue.ts

@@ -2,14 +2,14 @@ import { Value } from '@contember/schema'
 import { getFulfilledValues, getRejections } from '../utils'
 
 export type ColumnValue<E = never> = {
-	value: PromiseLike<Value.AtomicValue<E> | undefined>
+	value: PromiseLike<Value.FieldValue<E> | undefined>
 	fieldName: string
 	columnName: string
 	columnType: string
 }
 
 export type ResolvedColumnValue<E = never> = ColumnValue<E> & {
-	resolvedValue: Value.AtomicValue<E>
+	resolvedValue: Value.FieldValue<E>
 }
 
 export const resolveGenericValue = <T>(value: Value.GenericValueLike<T>): Promise<T> => {

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