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

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

@@ -0,0 +1,111 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { Mapper } from '../../Mapper'
+import { MutationResultType } from '../../Result'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+
+type Context = Model.OneHasManyContext
+
+export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(targetEntity, input, {
+				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+			})
+		}
+	}
+
+	public async create(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.insert(targetEntity, {
+				...input,
+				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+			})
+		}
+	}
+
+	public async connectOrCreate(
+		{ entity, targetRelation, targetEntity, input: { connect, create } }: Context & { input: Input.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const connectData = {
+				[targetRelation.name]: {
+					connect: { [entity.primary]: primary },
+				},
+			}
+			return await this.mapper.upsert(targetEntity, connect, connectData, {
+				...create,
+				...connectData,
+			})
+		}
+	}
+
+	public async update(
+		{ entity, targetEntity, targetRelation, input: { data, where } }: Context & { input: UpdateInputProcessor.UpdateManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(
+				targetEntity,
+				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
+				{
+					...data,
+					// [targetRelation.name]: {connect: thisPrimary}
+				},
+			)
+		}
+	}
+
+	public async upsert(
+		{ entity, targetEntity, targetRelation, input: { create, update, where } }: Context & { input: UpdateInputProcessor.UpsertManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const result = await this.mapper.update(
+				targetEntity,
+				{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
+				{
+					...update,
+				// [targetRelation.name]: {connect: thisPrimary}
+				},
+			)
+			if (result[0].result === MutationResultType.notFoundError) {
+				return await this.mapper.insert(targetEntity, {
+					...create,
+					[targetRelation.name]: { connect: { [entity.primary]: primary } },
+				})
+			}
+			return result
+		}
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(
+				targetEntity,
+				{ ...input, [targetRelation.name]: { [entity.primary]: primary } },
+				{ [targetRelation.name]: { disconnect: true } },
+			)
+		}
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.delete(targetEntity, {
+				...input,
+				[targetRelation.name]: { [entity.primary]: primary },
+			})
+		}
+	}
+}

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;"}