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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-rc.4",
+  "version": "1.3.0-alpha.1",
   "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.2.0-rc.4",
-    "@contember/dic": "^1.2.0-rc.4",
-    "@contember/logger": "^1.2.0-rc.4",
-    "@contember/graphql-utils": "^1.2.0-rc.4",
-    "@contember/schema": "^1.2.0-rc.4",
-    "@contember/schema-definition": "^1.2.0-rc.4",
-    "@contember/schema-utils": "^1.2.0-rc.4",
+    "@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",
     "@graphql-tools/schema": "^8.3.5",
     "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-rc.4",
-    "@contember/engine-api-tester": "^1.2.0-rc.4",
-    "@contember/schema-definition": "^1.2.0-rc.4",
+    "@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",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/input-validation/preValidation/CreateInputPreValidationProcessor.ts

@@ -17,29 +17,35 @@ export class CreateInputPreValidationProcessor implements CreateInputProcessor<R
 	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyInverseContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 
 	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyOwningContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 
 	manyHasOne: CreateInputProcessor.HasOneRelationProcessor<Model.ManyHasOneContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 
 	oneHasMany: CreateInputProcessor.HasManyRelationProcessor<Model.OneHasManyContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 	oneHasOneInverse: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneInverseContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 	oneHasOneOwning: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneOwningContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
+		connectOrCreate: context => this.validateCreate({ ...context, input: context.input.create }),
 	}
 
 	async validateCreate(context: {

package/src/input-validation/preValidation/UpdateInputPreValidationProcessor.ts

@@ -23,6 +23,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -31,6 +32,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -39,6 +41,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -47,6 +50,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -55,6 +59,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,
@@ -64,6 +69,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
+		connectOrCreate: ctx => this.processCreate({ ...ctx, input: ctx.input.create }),
 		connect: NoResult,
 		disconnect: NoResult,
 		['delete']: NoResult,

package/src/inputProcessing/CreateInputProcessor.ts

@@ -1,7 +1,7 @@
 import { Input, Model } from '@contember/schema'
 
 interface CreateInputProcessor<Result = void> {
-	column(context: CreateInputProcessor.ContextWithInput<Model.ColumnContext, Input.ColumnValue | undefined>): Promise<Result>
+	column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<Result>
 
 	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyInverseContext, Result>
 	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyOwningContext, Result>
@@ -14,21 +14,18 @@ interface CreateInputProcessor<Result = void> {
 }
 
 namespace CreateInputProcessor {
-	export type ContextWithInput<Context, Input> = Context & { input: Input }
 
 	export interface HasOneRelationProcessor<Context, Result> {
-		nothing?: (context: ContextWithInput<Context, undefined>) => Promise<Result>
-		connect: (context: ContextWithInput<Context, Input.UniqueWhere>) => Promise<Result>
-		create: (context: ContextWithInput<Context, Input.CreateDataInput>) => Promise<Result>
+		nothing?: (context: Context & { input: undefined }) => Promise<Result>
+		connect: (context: Context & { input: Input.UniqueWhere }) => Promise<Result>
+		create: (context: Context & { input: Input.CreateDataInput }) => Promise<Result>
+		connectOrCreate: (context: Context & { input: Input.ConnectOrCreateInput }) => Promise<Result>
 	}
 
 	export interface HasManyRelationProcessor<Context, Result> {
-		connect: (
-			context: ContextWithInput<Context, Input.UniqueWhere> & { index: number; alias?: string },
-		) => Promise<Result>
-		create: (
-			context: ContextWithInput<Context, Input.CreateDataInput> & { index: number; alias?: string },
-		) => Promise<Result>
+		connect: (context: Context & { input: Input.UniqueWhere } & { index: number; alias?: string }) => Promise<Result>
+		create: (context: Context & { input: Input.CreateDataInput } & { index: number; alias?: string }) => Promise<Result>
+		connectOrCreate: (context: Context & { input: Input.ConnectOrCreateInput } & { index: number; alias?: string }) => Promise<Result>
 	}
 }
 

package/src/inputProcessing/CreateInputVisitor.ts

@@ -89,6 +89,9 @@ export class CreateInputVisitor<Result> implements
 		if (isIt<Input.CreateRelationInput>(input, 'create')) {
 			return processor.create({ ...context, input: input.create })
 		}
+		if (isIt<Input.ConnectOrCreateRelationInput>(input, 'connectOrCreate')) {
+			return processor.connectOrCreate({ ...context, input: input.connectOrCreate })
+		}
 		throw new ImplementationException()
 	}
 
@@ -113,6 +116,9 @@ export class CreateInputVisitor<Result> implements
 			if (isIt<Input.CreateRelationInput>(element, 'create')) {
 				result = processor.create({ ...context, input: element.create, index: i++, alias })
 			}
+			if (isIt<Input.ConnectOrCreateRelationInput>(element, 'connectOrCreate')) {
+				result = processor.connectOrCreate({ ...context, input: element.connectOrCreate, index: i++, alias })
+			}
 			if (result !== undefined) {
 				results.push(await result)
 			}
@@ -122,9 +128,12 @@ export class CreateInputVisitor<Result> implements
 
 	private verifyOperations(input: object) {
 		const keys = Object.keys(input).filter(it => it !== 'alias')
-		if (keys.length !== 1 || !['create', 'connect'].includes(keys[0])) {
+		const ops = Object.values(Input.CreateRelationOperation) as string[]
+		if (keys.length !== 1 || !ops.includes(keys[0])) {
 			const found = keys.length === 0 ? 'none' : keys.join(', ')
-			throw new UserError(`Expected either "create" or "connect". ${found} found.`)
+			throw new UserError(
+				`Expected exactly one of: ${ops.join(', ')}. ${found} found.`,
+			)
 		}
 	}
 }

package/src/inputProcessing/UniqueWhereExpander.ts

@@ -2,13 +2,17 @@ import { Input, Model, Writable } from '@contember/schema'
 import { getTargetEntity } from '@contember/schema-utils'
 import { UserError } from '../exception'
 import { getFieldsForUniqueWhere } from '../utils'
+import { CheckedPrimary } from '../mapper/CheckedPrimary'
 
 type ExtendedUniqueWhere = Input.UniqueWhere<Input.PrimaryValue[]>
 
 export class UniqueWhereExpander {
 	constructor(private readonly schema: Model.Schema) {}
 
-	expand(entity: Model.Entity, where: ExtendedUniqueWhere, path: string[] = []): Input.Where {
+	expand(entity: Model.Entity, where: ExtendedUniqueWhere | CheckedPrimary, path: string[] = []): Input.Where {
+		if (where instanceof CheckedPrimary) {
+			return { [entity.primary]: { eq: where.primaryValue } }
+		}
 		const isFilled = (field: string) => where[field] !== undefined && where[field] !== null
 
 		const isUnique = (() => {

package/src/inputProcessing/UpdateInputProcessor.ts

@@ -1,7 +1,8 @@
 import { Input, Model } from '@contember/schema'
 
+
 interface UpdateInputProcessor<Result = void> {
-	column(context: UpdateInputProcessor.ContextWithInput<Model.ColumnContext, Input.ColumnValue | undefined>): Promise<Result>
+	column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<Result>
 
 	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyInverseContext, Result>
 
@@ -17,7 +18,6 @@ interface UpdateInputProcessor<Result = void> {
 }
 
 namespace UpdateInputProcessor {
-	export type ContextWithInput<Context, Input> = Context & { input: Input }
 	export type UpsertInput = { update: Input.UpdateDataInput; create: Input.CreateDataInput }
 	export type UpdateManyInput = { where: Input.UniqueWhere; data: Input.UpdateDataInput }
 	export type UpsertManyInput = {
@@ -27,35 +27,35 @@ namespace UpdateInputProcessor {
 	}
 
 	export interface HasOneRelationInputProcessor<Context, Result> {
-		connect(context: ContextWithInput<Context, Input.UniqueWhere>): Promise<Result>
+		connect(context: Context & { input: Input.UniqueWhere }): Promise<Result>
+
+		create(context: Context & { input: Input.CreateDataInput }): Promise<Result>
 
-		create(context: ContextWithInput<Context, Input.CreateDataInput>): Promise<Result>
+		connectOrCreate(context: Context & { input: Input.ConnectOrCreateInput }): Promise<Result>
 
-		update(context: ContextWithInput<Context, Input.UpdateDataInput>): Promise<Result>
+		update(context: Context & { input: Input.UpdateDataInput }): Promise<Result>
 
-		upsert(context: ContextWithInput<Context, UpsertInput>): Promise<Result>
+		upsert(context: Context & { input: UpdateInputProcessor.UpsertInput }): Promise<Result>
 
-		disconnect(context: ContextWithInput<Context, undefined>): Promise<Result>
+		disconnect(context: Context & { input: undefined }): Promise<Result>
 
-		delete(context: ContextWithInput<Context, undefined>): Promise<Result>
+		delete(context: Context & { input: undefined }): Promise<Result>
 	}
 
 	export interface HasManyRelationInputProcessor<Context, Result> {
-		connect(context: ContextWithInput<Context, Input.UniqueWhere> & { index: number; alias?: string }): Promise<Result>
+		connect(context: Context & { input: Input.UniqueWhere; index: number; alias?: string }): Promise<Result>
+
+		create(context: Context & { input: Input.CreateDataInput; index: number; alias?: string }): Promise<Result>
 
-		create(
-			context: ContextWithInput<Context, Input.CreateDataInput> & { index: number; alias?: string },
-		): Promise<Result>
+		connectOrCreate(context: Context & { input: Input.ConnectOrCreateInput; index: number; alias?: string }): Promise<Result>
 
-		update(context: ContextWithInput<Context, UpdateManyInput> & { index: number; alias?: string }): Promise<Result>
+		update(context: Context & { input: UpdateInputProcessor.UpdateManyInput; index: number; alias?: string }): Promise<Result>
 
-		upsert(context: ContextWithInput<Context, UpsertManyInput> & { index: number; alias?: string }): Promise<Result>
+		upsert(context: Context & { input: UpdateInputProcessor.UpsertManyInput; index: number; alias?: string }): Promise<Result>
 
-		disconnect(
-			context: ContextWithInput<Context, Input.UniqueWhere> & { index: number; alias?: string },
-		): Promise<Result>
+		disconnect(context: Context & { input: Input.UniqueWhere; index: number; alias?: string }): Promise<Result>
 
-		delete(context: ContextWithInput<Context, Input.UniqueWhere> & { index: number; alias?: string }): Promise<Result>
+		delete(context: Context & { input: Input.UniqueWhere; index: number; alias?: string }): Promise<Result>
 	}
 }
 

package/src/inputProcessing/UpdateInputVisitor.ts

@@ -85,6 +85,9 @@ export class UpdateInputVisitor<Result> implements
 		if (isIt<Input.CreateRelationInput>(input, 'create')) {
 			return processor.create({ ...context, input: input.create })
 		}
+		if (isIt<Input.ConnectOrCreateRelationInput>(input, 'connectOrCreate')) {
+			return processor.connectOrCreate({ ...context, input: input.connectOrCreate })
+		}
 		if (isIt<Input.DeleteRelationInput>(input, 'delete')) {
 			return processor.delete({ ...context, input: undefined })
 		}
@@ -153,10 +156,11 @@ export class UpdateInputVisitor<Result> implements
 
 	private verifyOperations(input: object) {
 		const keys = Object.keys(input).filter(it => it !== 'alias')
-		if (keys.length !== 1 || !['create', 'connect', 'delete', 'disconnect', 'update', 'upsert'].includes(keys[0])) {
+		const ops = Object.values(Input.UpdateRelationOperation) as string[]
+		if (keys.length !== 1 || !ops.includes(keys[0])) {
 			const found = keys.length === 0 ? 'none' : keys.join(', ')
 			throw new UserError(
-				`Expected exactly one of: "create", "connect", "delete", "disconnect", "update" or "upsert". ${found} found.`,
+				`Expected exactly one of: ${ops.join(', ')}. ${found} found.`,
 			)
 		}
 	}

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/Mapper.ts

@@ -1,24 +1,27 @@
 import { Input, Model } from '@contember/schema'
-import { getColumnName } from '@contember/schema-utils'
-import { SelectGroupedObjects, SelectHydrator, SelectIndexedResultObjects, SelectResultObject } from './select'
-import { PathFactory } from './select'
+import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
+import {
+	OrderByHelper,
+	PathFactory,
+	SelectBuilderFactory,
+	SelectGroupedObjects,
+	SelectHydrator,
+	SelectIndexedResultObjects,
+	SelectResultObject,
+	WhereBuilder,
+} from './select'
 import * as database from '@contember/database'
-import { Client, SelectBuilder } from '@contember/database'
-import { SelectBuilderFactory } from './select'
+import { Client, 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'
 
 export class Mapper {
@@ -43,7 +46,7 @@ export class Mapper {
 		this.constraintHelper = new ConstraintHelper(db)
 	}
 
-	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() //
@@ -163,15 +166,20 @@ 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()
 		}
+		const pushId = (id: string) => {
+			const where = { [entity.primary]: id }
+			this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
+		}
 		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.inserter.insert(this, entity, data, pushId, builderCb),
 		)
 	}
 
@@ -195,19 +203,20 @@ 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()
+		}
 		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,
@@ -221,10 +230,11 @@ export class Mapper {
 		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 pushIdCallback = (id: string) => {
 					const where = { [entity.primary]: id }
 					this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
-				})
+				}
+				return await this.inserter.insert(this, entity, create, pushIdCallback, () => {})
 			}
 			return await this.updater.update(this, entity, primaryValue, update, filter)
 		})
@@ -242,33 +252,51 @@ export class Mapper {
 	}
 
 	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,
-		)
+		const err = () => {
+			throw new ImplementationException()
+		}
+		return await acceptFieldVisitor(this.schema, entity, relation, {
+			visitManyHasManyOwning: ({ entity, relation }) => {
+				return this.junctionTableManager.connectJunction(this.db, entity, relation, thisPrimary, otherPrimary)
+			},
+			visitManyHasManyInverse: ({ targetEntity, targetRelation }) => {
+				return this.junctionTableManager.connectJunction(this.db, 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,
-		)
+		const err = () => {
+			throw new ImplementationException()
+		}
+		return await acceptFieldVisitor(this.schema, entity, relation, {
+			visitManyHasManyOwning: ({ entity, relation }) => {
+				return this.junctionTableManager.disconnectJunction(this.db, entity, relation, thisPrimary, otherPrimary)
+			},
+			visitManyHasManyInverse: ({ targetEntity, targetRelation }) => {
+				return this.junctionTableManager.disconnectJunction(this.db, targetEntity, targetRelation, otherPrimary, thisPrimary)
+			},
+			visitColumn: err,
+			visitOneHasMany: err,
+			visitOneHasOneInverse: err,
+			visitOneHasOneOwning: err,
+			visitManyHasOne: err,
+		})
 	}
 
 	public async getPrimaryValue(

package/src/mapper/MapperContainer.ts

@@ -102,10 +102,15 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 					)
 				}
 			})())
-		.addService('insertBuilderFactory', ({ whereBuilder, pathFactory }) =>
-			new InsertBuilderFactory(schema.model, whereBuilder, pathFactory))
-		.addService('updateBuilderFactory', ({ whereBuilder, pathFactory }) =>
-			new UpdateBuilderFactory(schema.model, whereBuilder, pathFactory))
+		.addService(
+			'insertBuilderFactory',
+			({ whereBuilder, pathFactory, predicateFactory }) =>
+				new InsertBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory),
+		)
+		.addService(
+			'updateBuilderFactory',
+			({ whereBuilder, pathFactory, predicateFactory }) =>
+				new UpdateBuilderFactory(schema.model, whereBuilder, pathFactory, predicateFactory))
 		.addService('connectJunctionHandler', () =>
 			new JunctionConnectHandler())
 		.addService('disconnectJunctionHandler', ({}) =>
@@ -116,8 +121,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 			new DeleteExecutor(schema.model, predicateFactory, whereBuilder, updateBuilderFactory, pathFactory))
 		.addService('updater', ({ predicateFactory, updateBuilderFactory }) =>
 			new Updater(schema.model, predicateFactory, updateBuilderFactory))
-		.addService('inserter', ({ predicateFactory, insertBuilderFactory, providers }) =>
-			new Inserter(schema.model, predicateFactory, insertBuilderFactory, providers))
+		.addService('inserter', ({ insertBuilderFactory, providers }) => new Inserter(schema.model, insertBuilderFactory, providers))
 		.addService('mapperFactory', ({ predicatesInjector, selectBuilderFactory, uniqueWhereExpander, whereBuilder, junctionTableManager, deleteExecutor, updater, inserter, pathFactory }) => {
 			return (db: Client) =>
 				new Mapper(

package/src/mapper/Result.ts

@@ -170,7 +170,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)
 	}
 }