@contember/engine-content-api 2.0.0-alpha.20 → 2.0.0-alpha.21

package/src/mapper/{relations → update/relations}/OneHasOneInverseUpdateInputProcessor.ts

@@ -6,12 +6,15 @@ import {
 	MutationResultList,
 	MutationResultType,
 	NothingToDoReason,
-} from '../Result'
-import { UpdateInputProcessor } from '../../inputProcessing'
+} from '../../Result'
+import { UpdateInputProcessor } from '../../../inputProcessing'
 import { Input, Model } from '@contember/schema'
-import { Mapper } from '../Mapper'
+import { Mapper } from '../../Mapper'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
 
-export class OneHasOneInverseUpdateInputProcessor {
+type Context = Model.OneHasOneInverseContext
+
+export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
 		private readonly mapper: Mapper,
@@ -19,24 +22,101 @@ export class OneHasOneInverseUpdateInputProcessor {
 	}
 
 	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere }) {
-		const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
-		if (!newOwner) {
-			return [new MutationEntryNotFoundError([], input)]
+		return async () => {
+			const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
+			if (!newOwner) {
+				return [new MutationEntryNotFoundError([], input)]
+			}
+			return await this.connectInternal(ctx, newOwner)
 		}
-		return await this.connectInternal(ctx, newOwner)
 	}
 
 	public async connectOrCreate(
 		{ input, ...ctx }: Model.OneHasOneInverseContext & { input: Input.ConnectOrCreateInput },
 	) {
-		const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input.connect)
-		if (newOwner) {
-			return await this.connectInternal(ctx, newOwner)
+		return async () => {
+			const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input.connect)
+			if (newOwner) {
+				return await this.connectInternal(ctx, newOwner)
+			}
+			return await this.createInternal({ ...ctx, input: input.create })
 		}
-		return await this.create({ ...ctx, input: input.create })
 	}
 
 
+	public async create(ctx: Model.OneHasOneInverseContext & { input: Input.CreateDataInput }) {
+		return async () => {
+			return await this.createInternal(ctx)
+		}
+	}
+
+	public async update({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.UpdateDataInput }) {
+		return async () => {
+			return await this.mapper.update(
+				targetEntity,
+				{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
+				input,
+			)
+		}
+	}
+	public async upsert(context: Model.OneHasOneInverseContext & { input: UpdateInputProcessor.UpsertInput }) {
+		return async () => {
+			const { targetEntity, targetRelation, entity, input: { update, create } } = context
+			const result = await this.mapper.update(
+				targetEntity,
+				{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
+				update,
+			)
+			if (result[0].result === MutationResultType.notFoundError) {
+				return await this.createInternal({
+					...context,
+					input: create,
+				})
+			}
+			return result
+		}
+	}
+
+	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
+		return async () => {
+			if (!relation.nullable && !targetRelation.orphanRemoval) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+			const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
+				[targetRelation.name]: { [entity.primary]: this.primaryValue },
+			})
+			if (!currentOwner) {
+				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+			}
+			if (currentOwner && !targetRelation.nullable) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+
+			const result = await this.mapper.updateInternal(
+				targetEntity,
+				{ [targetEntity.primary]: currentOwner },
+				builder => {
+					builder.addPredicates([targetRelation.name])
+					builder.addFieldValue(targetRelation.name, null)
+				},
+			)
+			if (targetRelation.orphanRemoval) {
+				result.push(...(await this.mapper.delete(entity, { [entity.primary]: this.primaryValue })))
+			}
+			return result
+		}
+	}
+
+	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
+		return async () => {
+			if (!relation.nullable && !targetRelation.orphanRemoval) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+			// orphan removal is handled in mapper.delete
+			return await this.mapper.delete(targetEntity, { [targetRelation.name]: { [entity.primary]: this.primaryValue } })
+		}
+	}
+
 	private async connectInternal(
 		{ entity, targetEntity, targetRelation }: Model.OneHasOneInverseContext,
 		newOwner: Input.PrimaryValue,
@@ -76,7 +156,7 @@ export class OneHasOneInverseUpdateInputProcessor {
 		return result
 	}
 
-	public async create({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.CreateDataInput }) {
+	private async createInternal({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.CreateDataInput }) {
 		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
 			[targetRelation.name]: { [entity.primary]: this.primaryValue },
 		})
@@ -101,64 +181,4 @@ export class OneHasOneInverseUpdateInputProcessor {
 
 		return result
 	}
-
-	public async update({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.UpdateDataInput }) {
-		return await this.mapper.update(
-			targetEntity,
-			{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-			input,
-		)
-	}
-
-	public async upsert(context: Model.OneHasOneInverseContext & { input: UpdateInputProcessor.UpsertInput }) {
-		const { targetEntity, targetRelation, entity, input: { update, create } } = context
-		const result = await this.mapper.update(
-			targetEntity,
-			{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-			update,
-		)
-		if (result[0].result === MutationResultType.notFoundError) {
-			return await this.create({
-				...context,
-				input: create,
-			})
-		}
-		return result
-	}
-
-	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
-		if (!relation.nullable && !targetRelation.orphanRemoval) {
-			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-		}
-		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
-			[targetRelation.name]: { [entity.primary]: this.primaryValue },
-		})
-		if (!currentOwner) {
-			return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
-		}
-		if (currentOwner && !targetRelation.nullable) {
-			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-		}
-
-		const result = await this.mapper.updateInternal(
-			targetEntity,
-			{ [targetEntity.primary]: currentOwner },
-			builder => {
-				builder.addPredicates([targetRelation.name])
-				builder.addFieldValue(targetRelation.name, null)
-			},
-		)
-		if (targetRelation.orphanRemoval) {
-			result.push(...(await this.mapper.delete(entity, { [entity.primary]: this.primaryValue })))
-		}
-		return result
-	}
-
-	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
-		if (!relation.nullable && !targetRelation.orphanRemoval) {
-			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-		}
-		// orphan removal is handled in mapper.delete
-		return await this.mapper.delete(targetEntity, { [targetRelation.name]: { [entity.primary]: this.primaryValue } })
-	}
 }

package/src/mapper/update/relations/OneHasOneOwningUpdateInputProcessor.ts

@@ -0,0 +1,243 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationNothingToDo,
+	MutationResultList,
+	MutationResultType,
+	NothingToDoReason,
+} from '../../Result'
+import { Mapper } from '../../Mapper'
+import { UpdateBuilder } from '../../update/UpdateBuilder'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+
+type Context = Model.OneHasOneOwningContext
+
+export class OneHasOneOwningUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+	constructor(
+		private readonly primaryValue: Input.PrimaryValue,
+		private readonly mapper: Mapper,
+		private readonly updateBuilder: UpdateBuilder,
+	) {
+	}
+
+	public async connect(context: Model.OneHasOneOwningContext & { input: Input.UniqueWhere }) {
+		const { entity, relation, targetEntity, targetRelation, input } = context
+		const newInverseSide = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (!newInverseSide) {
+			return [new MutationEntryNotFoundError([], input)]
+		}
+		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+		const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
+		if (currentOwnerResult.some(it => it.error)
+			|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
+		) {
+			return currentOwnerResult
+		}
+
+		this.updateBuilder.addFieldValue(relation.name, newInverseSide)
+
+		return async () => {
+			return [
+				...currentOwnerResult,
+				...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
+			]
+		}
+	}
+
+	public async create(context: Model.OneHasOneOwningContext & { input: Input.CreateDataInput }) {
+		const { entity, relation, targetEntity, targetRelation } = context
+		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+		const createResult = await this.createInternal(context, currentInverseSide)
+		const newInverseSide = getInsertPrimary(createResult)
+		if (!newInverseSide) {
+			return createResult
+		}
+		this.updateBuilder.addFieldValue(relation.name, newInverseSide)
+
+		return async () => {
+			return [
+				...createResult,
+				...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
+			]
+		}
+	}
+
+	public async connectOrCreate({ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: Input.ConnectOrCreateInput }) {
+		const { relation, targetRelation, targetEntity, entity } = context
+		const currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
+		const newInverseSide = await this.mapper.getPrimaryValue(targetEntity, connect)
+
+		if (newInverseSide) {
+			const currentOwnerResult = await this.handleStateBeforeConnect(context, currentInverseSide, newInverseSide)
+			if (currentOwnerResult.some(it => it.error)
+				|| (currentOwnerResult.length === 1 && currentOwnerResult[0].result === MutationResultType.nothingToDo)
+			) {
+				return currentOwnerResult
+			}
+			this.updateBuilder.addFieldValue(relation.name, newInverseSide)
+			return async () => {
+				return [
+					...currentOwnerResult,
+					...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
+				]
+			}
+
+		}
+
+		const createResult = await this.createInternal({ ...context, input: create }, currentInverseSide)
+		const newInverseSideCreate = getInsertPrimary(createResult)
+		if (!newInverseSideCreate) {
+			return createResult
+		}
+		this.updateBuilder.addFieldValue(relation.name, newInverseSideCreate)
+		return async () => {
+			return [
+				...createResult,
+				...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)),
+			]
+		}
+	}
+
+	public async update({ entity, relation, targetEntity, input }: Model.OneHasOneOwningContext & { input: Input.UpdateDataInput }) {
+		return async () => {
+			const inversePrimary = await this.mapper.selectField(
+				entity,
+				{ [entity.primary]: this.primaryValue },
+				relation.name,
+			)
+			if (!inversePrimary) {
+				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+			}
+			return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, input)
+		}
+	}
+
+	public async upsert({ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput }) {
+		const primary = await this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
+		if (!primary) {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const insertPrimary = getInsertPrimary(insertResult)
+			if (!insertPrimary) {
+				return insertResult
+			}
+			this.updateBuilder.addFieldValue(relation.name, insertPrimary)
+			return []
+		}
+
+		return async () => {
+			return await this.mapper.update(targetEntity, { [targetEntity.primary]: primary }, update)
+		}
+	}
+
+	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneOwningContext & { input: undefined }) {
+		if (!relation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		const inversePrimary = (targetRelation && !targetRelation.nullable) || relation.orphanRemoval
+			? await this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
+			: undefined
+		if (inversePrimary && targetRelation && !targetRelation.nullable && !relation.orphanRemoval) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		this.updateBuilder.addFieldValue(relation.name, null)
+
+		if (relation.orphanRemoval && inversePrimary) {
+			return async () => {
+				return await this.mapper.delete(targetEntity, { [targetEntity.primary]: inversePrimary })
+			}
+		}
+
+		return []
+	}
+
+	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneOwningContext & { input: undefined }) {
+		if (!relation.nullable && relation.joiningColumn.onDelete !== Model.OnDelete.cascade) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		return async () => {
+			const targetPrimary = await this.mapper.selectField(
+				entity,
+				{ [entity.primary]: this.primaryValue },
+				relation.name,
+			)
+			if (!targetPrimary) {
+				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+			}
+			return await this.mapper.delete(targetEntity, new CheckedPrimary(targetPrimary))
+		}
+	}
+
+	private async createInternal(
+		{ targetEntity, targetRelation, relation, input }: Model.OneHasOneOwningContext & { input: Input.CreateDataInput },
+		currentInverseSide: Input.PrimaryValue | undefined,
+	): Promise<MutationResultList> {
+		if (targetRelation && !targetRelation.nullable && !relation.orphanRemoval && currentInverseSide) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		return await this.mapper.insert(targetEntity, input)
+	}
+
+	private async getCurrentInverseSide(targetRelation: Model.OneHasOneInverseRelation | null, relation: Model.OneHasOneOwningRelation, entity: Model.Entity) {
+		if ((targetRelation && !targetRelation.nullable) || relation.orphanRemoval) {
+			return this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
+		}
+		return undefined
+	}
+
+	private async cleanupOrphan(relation: Model.OneHasOneOwningRelation, targetEntity: Model.Entity, currentInverseSide: Input.PrimaryValue | undefined) {
+		if (relation.orphanRemoval && currentInverseSide) {
+			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: currentInverseSide })
+		}
+		return []
+	}
+
+	private async handleStateBeforeConnect(
+		{ targetEntity, targetRelation, relation, entity }: Model.OneHasOneOwningContext,
+		currentInverseSide: Input.PrimaryValue | undefined,
+		newInverseSide: Input.PrimaryValue,
+	): Promise<MutationResultList> {
+
+		if (currentInverseSide === newInverseSide) {
+			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
+		}
+
+		const currentOwnerOfNewInverseSide = await this.mapper.getPrimaryValue(entity, {
+			[relation.name]: { [targetEntity.primary]: newInverseSide },
+		})
+
+		if (currentOwnerOfNewInverseSide === this.primaryValue) {
+			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
+		}
+
+		// orphan removal handled bellow
+		if (targetRelation && !targetRelation.nullable && !relation.orphanRemoval && currentInverseSide) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		if (currentOwnerOfNewInverseSide) {
+			if (!relation.nullable) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+
+			return await this.mapper.updateInternal(
+				entity,
+				{
+					[entity.primary]: currentOwnerOfNewInverseSide,
+				},
+				builder => {
+					builder.addPredicates([relation.name])
+					builder.addFieldValue(relation.name, null)
+				},
+			)
+		}
+		return []
+	}
+}

package/tests/cases/integration/graphQlRequests/insert/oneHasMany/create.test.ts

@@ -49,22 +49,22 @@ test('insert posts with locales (one has many)', async () => {
 				},
 				{
 					sql: SQL`with "root_" as
-						(select ? :: uuid as "post_id", ? :: uuid as "id", ? :: text as "locale", ? :: text as "title")
-						insert into "public"."post_locale" ("post_id", "id", "locale", "title")
-						select "root_"."post_id", "root_"."id", "root_"."locale", "root_"."title"
+						(select ? :: uuid as "id", ? :: text as "locale", ? :: text as "title", ? :: uuid as "post_id")
+						insert into "public"."post_locale" ("id", "locale", "title", "post_id")
+						select "root_"."id", "root_"."locale", "root_"."title", "root_"."post_id"
             from "root_"
 						returning "id"`,
-					parameters: [testUuid(1), testUuid(2), 'cs', 'Ahoj svete'],
+					parameters: [testUuid(2), 'cs', 'Ahoj svete', testUuid(1)],
 					response: { rows: [{ id: testUuid(2) }] },
 				},
 				{
 					sql: SQL`with "root_" as
-						(select ? :: uuid as "post_id", ? :: uuid as "id", ? :: text as "locale", ? :: text as "title")
-						insert into "public"."post_locale" ("post_id", "id", "locale", "title")
-						select "root_"."post_id", "root_"."id", "root_"."locale", "root_"."title"
+						(select ? :: uuid as "id", ? :: text as "locale", ? :: text as "title", ? :: uuid as "post_id")
+						insert into "public"."post_locale" ("id", "locale", "title", "post_id")
+						select "root_"."id", "root_"."locale", "root_"."title", "root_"."post_id"
             from "root_"
 						returning "id"`,
-					parameters: [testUuid(1), testUuid(3), 'en', 'Hello world'],
+					parameters: [testUuid(3), 'en', 'Hello world', testUuid(1)],
 					response: { rows: [{ id: testUuid(3) }] },
 				},
 				{

package/tests/cases/integration/graphQlRequests/update/oneHasMany/connectOrCreate.test.ts

@@ -68,12 +68,12 @@ test('upsert - not exists (composed unique)', async () => {
 				},
 				{
 					sql: SQL`with "root_" as
-							(select ? :: uuid as "id", ? :: text as "title", ? :: text as "locale", ? :: uuid as "post_id")
-							insert into "public"."post_locale" ("id", "title", "locale", "post_id")
-							select "root_"."id", "root_"."title", "root_"."locale", "root_"."post_id"
+							(select ? :: uuid as "id", ? :: text as "title", ? :: uuid as "post_id", ? :: text as "locale")
+							insert into "public"."post_locale" ("id", "title", "post_id", "locale")
+							select "root_"."id", "root_"."title", "root_"."post_id", "root_"."locale"
               from "root_"
 							returning "id"`,
-					parameters: [testUuid(1), 'World', null, testUuid(2)],
+					parameters: [testUuid(1), 'World', testUuid(2), null],
 					response: { rows: [{ id: testUuid(1) }] },
 				},
 			]),

package/dist/development/src/mapper/DataManipulationBuilder.cjs

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const AbortDataManipulation = Symbol("AbortDataManipulation");
-exports.AbortDataManipulation = AbortDataManipulation;
-//# sourceMappingURL=DataManipulationBuilder.cjs.map

package/dist/development/src/mapper/DataManipulationBuilder.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataManipulationBuilder.cjs","sources":["../../../../../packages/engine-content-api/src/mapper/DataManipulationBuilder.ts"],"sourcesContent":["import { Value } from '@contember/schema'\n\nexport interface DataManipulationBuilder {\n\taddFieldValue(\n\t\tfieldName: string,\n\t\tvalue: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,\n\t): Promise<Value.AtomicValue<AbortDataManipulation | undefined>>\n}\n\n\nexport const AbortDataManipulation = Symbol('AbortDataManipulation')\nexport type AbortDataManipulation = typeof AbortDataManipulation\n"],"names":[],"mappings":";;AAUa,MAAA,wBAAwB,OAAO,uBAAuB;;"}

package/dist/development/src/mapper/DataManipulationBuilder.js

@@ -1,5 +0,0 @@
-const AbortDataManipulation = Symbol("AbortDataManipulation");
-export {
-  AbortDataManipulation
-};
-//# sourceMappingURL=DataManipulationBuilder.js.map

package/dist/development/src/mapper/DataManipulationBuilder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataManipulationBuilder.js","sources":["../../../../../packages/engine-content-api/src/mapper/DataManipulationBuilder.ts"],"sourcesContent":["import { Value } from '@contember/schema'\n\nexport interface DataManipulationBuilder {\n\taddFieldValue(\n\t\tfieldName: string,\n\t\tvalue: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,\n\t): Promise<Value.AtomicValue<AbortDataManipulation | undefined>>\n}\n\n\nexport const AbortDataManipulation = Symbol('AbortDataManipulation')\nexport type AbortDataManipulation = typeof AbortDataManipulation\n"],"names":[],"mappings":"AAUa,MAAA,wBAAwB,OAAO,uBAAuB;"}

package/dist/development/src/mapper/relations/ManyHasManyInputProcessor.cjs

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const Result = require("../Result.cjs");
-class ManyHasManyInputProcessor {
-  constructor(mapper) {
-    this.mapper = mapper;
-  }
-  async connect({ entity, targetEntity, relation, targetRelation, input }, primary) {
-    const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input);
-    if (!otherPrimary) {
-      return [new Result.MutationEntryNotFoundError([], input)];
-    }
-    return await this.mapper.connectJunction(entity, relation, primary, otherPrimary);
-  }
-  async create({ entity, targetEntity, relation, input }, primary) {
-    const insertResult = await this.mapper.insert(targetEntity, input);
-    const insertPrimary = Result.getInsertPrimary(insertResult);
-    if (!insertPrimary) {
-      return insertResult;
-    }
-    return [
-      ...insertResult,
-      ...await this.mapper.connectJunction(entity, relation, primary, insertPrimary)
-    ];
-  }
-  async connectOrCreate(context, primary) {
-    let otherPrimary = await this.mapper.getPrimaryValue(context.targetEntity, context.input.connect);
-    if (!otherPrimary) {
-      const insertResult = await this.mapper.insert(context.targetEntity, context.input.create);
-      otherPrimary = Result.getInsertPrimary(insertResult);
-      if (!otherPrimary) {
-        return insertResult;
-      }
-    }
-    return await this.mapper.connectJunction(context.entity, context.relation, primary, otherPrimary);
-  }
-  async update({ entity, targetEntity, relation, input: { where, data } }, primary) {
-    const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where);
-    if (!otherPrimary) {
-      return [new Result.MutationEntryNotFoundError([], where)];
-    }
-    return [
-      ...await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, data),
-      ...await this.mapper.connectJunction(entity, relation, primary, otherPrimary)
-    ];
-  }
-  async upsert({ entity, relation, targetEntity, input: { create, update, where } }, primary) {
-    const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where);
-    if (otherPrimary) {
-      const updateResult = await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, update);
-      const connectResult = await this.mapper.connectJunction(entity, relation, primary, otherPrimary);
-      return [...updateResult, ...connectResult];
-    } else {
-      const insertResult = await this.mapper.insert(targetEntity, create);
-      const primaryValue = Result.getInsertPrimary(insertResult);
-      if (!primaryValue) {
-        return insertResult;
-      }
-      const connectResult = await this.mapper.connectJunction(entity, relation, primary, primaryValue);
-      return [...insertResult, ...connectResult];
-    }
-  }
-  async disconnect({ entity, targetEntity, relation, input }, primary) {
-    const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input);
-    if (!otherPrimary) {
-      return [new Result.MutationEntryNotFoundError([], input)];
-    }
-    return await this.mapper.disconnectJunction(entity, relation, primary, otherPrimary);
-  }
-  async delete({ entity, targetEntity, relation, targetRelation, input }, primary) {
-    return await this.mapper.delete(targetEntity, input);
-  }
-}
-exports.ManyHasManyInputProcessor = ManyHasManyInputProcessor;
-//# sourceMappingURL=ManyHasManyInputProcessor.cjs.map

package/dist/development/src/mapper/relations/ManyHasManyInputProcessor.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ManyHasManyInputProcessor.cjs","sources":["../../../../../../packages/engine-content-api/src/mapper/relations/ManyHasManyInputProcessor.ts"],"sourcesContent":["import { UpdateInputProcessor } from '../../inputProcessing'\nimport { Input, Model } from '@contember/schema'\nimport { getInsertPrimary, MutationEntryNotFoundError, MutationResultList } from '../Result'\nimport { Mapper } from '../Mapper'\n\ntype RelationContext = Model.ManyHasManyOwningContext | Model.ManyHasManyInverseContext\n\nexport class ManyHasManyInputProcessor {\n\tconstructor(\n\t\tprivate readonly mapper: Mapper,\n\t) {\n\t}\n\n\tpublic async connect(\n\t\t{ entity, targetEntity, relation, targetRelation, input }: RelationContext & { input: Input.UniqueWhere },\n\t\tprimary: Input.PrimaryValue,\n\t) {\n\t\tconst otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input)\n\t\tif (!otherPrimary) {\n\t\t\treturn [new MutationEntryNotFoundError([], input)]\n\t\t}\n\t\treturn await this.mapper.connectJunction(entity, relation, primary, otherPrimary)\n\t}\n\n\tpublic async create(\n\t\t{ entity, targetEntity, relation, input }: RelationContext & { input: Input.CreateDataInput },\n\t\tprimary: Input.PrimaryValue,\n\t) {\n\t\tconst insertResult = await this.mapper.insert(targetEntity, input)\n\t\tconst insertPrimary = getInsertPrimary(insertResult)\n\t\tif (!insertPrimary) {\n\t\t\treturn insertResult\n\t\t}\n\t\treturn [\n\t\t\t...insertResult,\n\t\t\t...(await this.mapper.connectJunction(entity, relation, primary, insertPrimary)),\n\t\t]\n\t}\n\n\tpublic async connectOrCreate(\n\t\tcontext: RelationContext & { input: Input.ConnectOrCreateInput },\n\t\tprimary: Input.PrimaryValue,\n\t): Promise<MutationResultList> {\n\t\tlet otherPrimary = await this.mapper.getPrimaryValue(context.targetEntity, context.input.connect)\n\t\tif (!otherPrimary) {\n\t\t\tconst insertResult = await this.mapper.insert(context.targetEntity, context.input.create)\n\t\t\totherPrimary = getInsertPrimary(insertResult)\n\t\t\tif (!otherPrimary) {\n\t\t\t\treturn insertResult\n\t\t\t}\n\t\t}\n\t\treturn await this.mapper.connectJunction(context.entity, context.relation, primary, otherPrimary)\n\t}\n\n\tpublic async update(\n\t\t{ entity, targetEntity, relation, input: { where, data } }: RelationContext & { input: UpdateInputProcessor.UpdateManyInput },\n\t\tprimary: Input.PrimaryValue,\n\t) {\n\t\tconst otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where)\n\t\tif (!otherPrimary) {\n\t\t\treturn [new MutationEntryNotFoundError([], where)]\n\t\t}\n\t\treturn [\n\t\t\t...(await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, data)),\n\t\t\t...(await this.mapper.connectJunction(entity, relation, primary, otherPrimary)),\n\t\t]\n\t}\n\n\tpublic async upsert(\n\t\t{ entity, relation, targetEntity, input: { create, update, where } }: RelationContext & { input: UpdateInputProcessor.UpsertManyInput },\n\t\tprimary: Input.PrimaryValue,\n\t) {\n\t\tconst otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where)\n\t\tif (otherPrimary) {\n\t\t\tconst updateResult = await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, update)\n\t\t\tconst connectResult = await this.mapper.connectJunction(entity, relation, primary, otherPrimary)\n\t\t\treturn [...updateResult, ...connectResult]\n\t\t} else {\n\t\t\tconst insertResult = await this.mapper.insert(targetEntity, create)\n\n\t\t\tconst primaryValue = getInsertPrimary(insertResult)\n\t\t\tif (!primaryValue) {\n\t\t\t\treturn insertResult\n\t\t\t}\n\t\t\tconst connectResult = await this.mapper.connectJunction(entity, relation, primary, primaryValue)\n\t\t\treturn [...insertResult, ...connectResult]\n\t\t}\n\t}\n\n\tpublic async disconnect(\n\t\t{ entity, targetEntity, relation, input }: RelationContext & { input: Input.UniqueWhere },\n\t\tprimary: Input.PrimaryValue,\n\t) {\n\t\tconst otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input)\n\t\tif (!otherPrimary) {\n\t\t\treturn [new MutationEntryNotFoundError([], input)]\n\t\t}\n\n\t\treturn await this.mapper.disconnectJunction(entity, relation, primary, otherPrimary)\n\t}\n\n\tpublic async delete(\n\t\t{ entity, targetEntity, relation, targetRelation, input }: RelationContext & { input: Input.UniqueWhere },\n\t\tprimary: Input.PrimaryValue,\n\t) {\n\t\treturn await this.mapper.delete(targetEntity, input)\n\t}\n}\n"],"names":["MutationEntryNotFoundError","getInsertPrimary"],"mappings":"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"}