@contember/engine-content-api 2.0.0-alpha.36 → 2.0.0-alpha.37

package/src/mapper/types.ts

@@ -1,3 +1,117 @@
-import { Model } from '@contember/schema'
+import { Model, Input, Value } from '@contember/schema'
+import { CheckedPrimary } from './CheckedPrimary'
 
 export type JoiningColumns = { sourceColumn: Model.JoiningColumn; targetColumn: Model.JoiningColumn }
+
+export namespace MapperInput {
+
+	export interface ConnectRelationInput {
+		connect: Input.UniqueWhere | CheckedPrimary
+	}
+
+	export interface CreateRelationInput {
+		create: CreateDataInput
+	}
+
+	export interface ConnectOrCreateInput {
+		connect: Input.UniqueWhere | CheckedPrimary
+		create: CreateDataInput
+	}
+
+	export interface ConnectOrCreateRelationInput {
+		connectOrCreate: ConnectOrCreateInput
+	}
+
+	export interface DisconnectSpecifiedRelationInput {
+		disconnect: Input.UniqueWhere
+	}
+
+	export interface DeleteSpecifiedRelationInput {
+		delete: Input.UniqueWhere
+	}
+
+	export interface UpdateSpecifiedRelationInput {
+		update: { by: Input.UniqueWhere; data: UpdateDataInput }
+	}
+
+	export interface UpsertSpecifiedRelationInput {
+		upsert: { by: Input.UniqueWhere; update: UpdateDataInput; create: CreateDataInput }
+	}
+
+	export interface DisconnectRelationInput {
+		disconnect: true
+	}
+
+	export interface UpdateRelationInput {
+		update: UpdateDataInput
+	}
+
+	export interface DeleteRelationInput {
+		delete: true
+	}
+
+	export interface UpsertRelationInput {
+		upsert: { update: UpdateDataInput; create: CreateDataInput }
+	}
+
+	export interface CreateDataInput {
+		[column: string]: Value.FieldValue | CreateOneRelationInput | CreateManyRelationInput
+	}
+
+	export type CreateOneRelationInput = { alias?: string } & (
+		| ConnectRelationInput
+		| CreateRelationInput
+		| ConnectOrCreateRelationInput
+	)
+
+	export type CreateManyRelationInput = Array<CreateOneRelationInput>
+
+	export interface UpdateDataInput {
+		[column: string]: Value.FieldValue | UpdateOneRelationInput | UpdateManyRelationInput
+	}
+
+	export interface UpdateInput {
+		by: Input.UniqueWhere
+		filter?: Input.OptionalWhere
+		data: UpdateDataInput
+	}
+
+	export interface UpsertInput {
+		by: Input.UniqueWhere
+		filter?: Input.OptionalWhere
+		update: UpdateDataInput
+		create: CreateDataInput
+	}
+
+	export interface CreateInput {
+		data: CreateDataInput
+	}
+
+	export interface DeleteInput {
+		by: Input.UniqueWhere
+		filter?: Input.OptionalWhere
+	}
+
+
+	export type UpdateOneRelationInput =
+		| CreateRelationInput
+		| ConnectRelationInput
+		| ConnectOrCreateRelationInput
+		| DeleteRelationInput
+		| DisconnectRelationInput
+		| UpdateRelationInput
+		| UpsertRelationInput
+
+	export type UpdateManyRelationInputItem = { alias?: string } & (
+		| CreateRelationInput
+		| ConnectRelationInput
+		| ConnectOrCreateRelationInput
+		| DeleteSpecifiedRelationInput
+		| DisconnectSpecifiedRelationInput
+		| UpdateSpecifiedRelationInput
+		| UpsertSpecifiedRelationInput
+	)
+
+	export type UpdateManyRelationInput = Array<UpdateManyRelationInputItem>
+
+}

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -9,6 +9,7 @@ import { ManyHasManyUpdateInputProcessor } from './relations/ManyHasManyUpdateIn
 import { UpdateInputProcessor } from '../../inputProcessing'
 import { MutationResultList } from '../Result'
 import { ManyHasOneUpdateInputProcessor } from './relations/ManyHasOneUpdateInputProcessor'
+import { MapperInput } from '../types'
 
 export type SqlUpdateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue}) => Promise<MutationResultList>)
 
@@ -21,7 +22,7 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<SqlUpdateIn
 
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
-		private readonly data: Input.UpdateDataInput,
+		private readonly data: MapperInput.UpdateDataInput,
 		private readonly updateBuilder: UpdateBuilder,
 		private readonly mapper: Mapper,
 	) {

package/src/mapper/update/UpdateBuilder.ts

@@ -3,13 +3,13 @@ import { Acl, Input, Model, Value } from '@contember/schema'
 import { acceptEveryFieldVisitor, getColumnName, getColumnType } from '@contember/schema-utils'
 import { Operator, QueryBuilder, UpdateBuilder as DbUpdateBuilder, Value as DbValue } from '@contember/database'
 import { PathFactory, WhereBuilder } from '../select'
-import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
+import { ColumnValue, normalizeDbValue } from '../ColumnValue'
 import { PredicateFactory } from '../../acl'
 import { AfterUpdateEvent, BeforeUpdateEvent } from '../EventManager'
 import { Mapper } from '../Mapper'
 
 export interface UpdateResult {
-	values: ResolvedColumnValue[]
+	values: ColumnValue[]
 	executed: boolean
 	affectedRows: number | null
 }
@@ -31,13 +31,15 @@ export class UpdateBuilder {
 
 	public addFieldValue(
 		fieldName: string,
-		value: Value.GenericValueLike<Value.AtomicValue<undefined>>,
-	): Promise<Value.AtomicValue<undefined>> {
+		value: Value.FieldValue | undefined,
+	): void {
+		if (value === undefined) {
+			return
+		}
 		const columnName = getColumnName(this.schema, this.entity, fieldName)
 		const columnType = getColumnType(this.schema, this.entity, fieldName)
-		const resolvedValue = resolveGenericValue(value)
-		this.rowData.set(columnName, { columnName, value: resolvedValue, columnType, fieldName })
-		return resolvedValue
+
+		this.rowData.set(columnName, { columnName, value, columnType, fieldName })
 	}
 
 	public addNewWhere(where: Input.OptionalWhere): void {
@@ -56,7 +58,7 @@ export class UpdateBuilder {
 
 	public async execute(mapper: Mapper): Promise<UpdateResult> {
 		try {
-			const resolvedData = await resolveRowData([...this.rowData.values()])
+			const resolvedData = [...this.rowData.values()]
 			if (Object.keys(resolvedData).length === 0) {
 				return { values: [], affectedRows: null, executed: false }
 			}
@@ -67,7 +69,13 @@ export class UpdateBuilder {
 					qb = resolvedData.reduce(
 						(qb, value) =>
 							qb
-								.select(expr => expr.selectValue(value.resolvedValue as DbValue, value.columnType), value.columnName)
+								.select(
+									expr => expr.selectValue(
+										normalizeDbValue(value.value, value.columnType),
+										value.columnType,
+									),
+									value.columnName,
+								)
 								.select(['root_', value.columnName], value.columnName + oldColSuffix),
 						qb,
 					)
@@ -118,13 +126,13 @@ export class UpdateBuilder {
 				})
 
 
-			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData as ResolvedColumnValue[], this.primary)
+			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData, this.primary)
 			await mapper.eventManager.fire(beforeEvent)
 
 			const result = await qb.execute(mapper.db)
 
 			if (result.length === 1) {
-				const eventData = (resolvedData as ResolvedColumnValue[]).map(it => ({
+				const eventData = (resolvedData).map(it => ({
 					...it,
 					old: result[0][it.columnName + oldColSuffix],
 				}))
@@ -133,7 +141,7 @@ export class UpdateBuilder {
 				await mapper.eventManager.fire(afterUpdateEvent)
 			}
 
-			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result.length, executed: true }
+			return { values: resolvedData, affectedRows: result.length, executed: true }
 		} catch (e) {
 			throw e
 		}

package/src/mapper/update/Updater.ts

@@ -5,10 +5,11 @@ import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason, RowValues } from '../Result'
+import { MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason } from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
 import { DatabaseMetadata } from '@contember/database'
+import { MapperInput } from '../types'
 
 export class Updater {
 	constructor(
@@ -22,7 +23,7 @@ export class Updater {
 		mapper: Mapper,
 		entity: Model.Entity,
 		primaryValue: Input.PrimaryValue,
-		data: Input.UpdateDataInput,
+		data: MapperInput.UpdateDataInput,
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		const updateBuilder = this.updateBuilderFactory.create(entity, primaryValue)

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

@@ -3,6 +3,8 @@ import { Input, Model } from '@contember/schema'
 import { getInsertPrimary, MutationEntryNotFoundError } from '../../Result'
 import { Mapper } from '../../Mapper'
 import { SqlUpdateInputProcessorResult } from '../../update'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
 
 type Context = Model.ManyHasManyOwningContext | Model.ManyHasManyInverseContext
 
@@ -13,19 +15,17 @@ export class ManyHasManyUpdateInputProcessor implements UpdateInputProcessor.Has
 	}
 
 	public async connect(
-		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
-			const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!otherPrimary) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
+			const [otherPrimary, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (err) return [err]
 			return await this.mapper.connectJunction(entity, relation, primary, otherPrimary)
 		}
 	}
 
 	public async create(
-		{ entity, targetEntity, relation, input }: Context & { input: Input.CreateDataInput },
+		{ entity, targetEntity, relation, input }: Context & { input: MapperInput.CreateDataInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
 			const insertResult = await this.mapper.insert(targetEntity, input)
@@ -41,10 +41,10 @@ export class ManyHasManyUpdateInputProcessor implements UpdateInputProcessor.Has
 	}
 
 	public async connectOrCreate(
-		context: Context & { input: Input.ConnectOrCreateInput },
+		context: Context & { input: MapperInput.ConnectOrCreateInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
-			let otherPrimary = await this.mapper.getPrimaryValue(context.targetEntity, context.input.connect)
+			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 = getInsertPrimary(insertResult)
@@ -60,12 +60,10 @@ export class ManyHasManyUpdateInputProcessor implements UpdateInputProcessor.Has
 		{ entity, targetEntity, relation, input: { where, data } }: Context & { input: UpdateInputProcessor.UpdateManyInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
-			const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where)
-			if (!otherPrimary) {
-				return [new MutationEntryNotFoundError([], where)]
-			}
+			const [otherPrimary, err] = await this.mapper.getPrimaryValue(targetEntity, where)
+			if (err) return [err]
 			return [
-				...(await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, data)),
+				...(await this.mapper.update(targetEntity, new CheckedPrimary(otherPrimary), data)),
 				...(await this.mapper.connectJunction(entity, relation, primary, otherPrimary)),
 			]
 		}
@@ -75,9 +73,9 @@ export class ManyHasManyUpdateInputProcessor implements UpdateInputProcessor.Has
 		{ entity, relation, targetEntity, input: { create, update, where } }: Context & { input: UpdateInputProcessor.UpsertManyInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
-			const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where)
+			const [otherPrimary] = await this.mapper.getPrimaryValue(targetEntity, where)
 			if (otherPrimary) {
-				const updateResult = await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, update)
+				const updateResult = await this.mapper.update(targetEntity, new CheckedPrimary(otherPrimary), update)
 				const connectResult = await this.mapper.connectJunction(entity, relation, primary, otherPrimary)
 				return [...updateResult, ...connectResult]
 			} else {
@@ -97,10 +95,8 @@ export class ManyHasManyUpdateInputProcessor implements UpdateInputProcessor.Has
 		{ entity, targetEntity, relation, input }: Context & { input: Input.UniqueWhere },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
-			const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!otherPrimary) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
+			const [otherPrimary, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (err) return [err]
 
 			return await this.mapper.disconnectJunction(entity, relation, primary, otherPrimary)
 		}

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

@@ -11,6 +11,8 @@ import {
 import { Mapper } from '../../Mapper'
 import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
 import { UpdateBuilder } from '../UpdateBuilder'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
 
 type Context = Model.ManyHasOneContext
 
@@ -24,18 +26,16 @@ export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasO
 	}
 
 	public async connect(
-		{ targetEntity, relation, input }: Context & { input: Input.UniqueWhere },
+		{ targetEntity, relation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
 	) {
-		const value = await this.mapper.getPrimaryValue(targetEntity, input)
-		if (!value) {
-			return [new MutationEntryNotFoundError([], input)]
-		}
+		const [value, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (err) return [err]
 		this.builder.addFieldValue(relation.name, value)
 		return []
 	}
 
 	public async create(
-		{ relation, targetEntity, input }: Context & { input: Input.CreateDataInput },
+		{ relation, targetEntity, input }: Context & { input: MapperInput.CreateDataInput },
 	) {
 		const insertResult = await this.mapper.insert(targetEntity, input)
 		const value = getInsertPrimary(insertResult)
@@ -47,9 +47,9 @@ export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasO
 	}
 
 	public async connectOrCreate(
-		{ input: { connect, create }, relation, targetEntity }: Context & { input: Input.ConnectOrCreateInput },
+		{ input: { connect, create }, relation, targetEntity }: Context & { input: MapperInput.ConnectOrCreateInput },
 	) {
-		const value = await this.mapper.getPrimaryValue(targetEntity, connect)
+		const [value] = await this.mapper.getPrimaryValue(targetEntity, connect)
 		if (value) {
 			this.builder.addFieldValue(relation.name, value)
 		} else {
@@ -65,7 +65,7 @@ export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasO
 	}
 
 	public async update(
-		{ entity, relation, targetEntity, targetRelation, input }: Context & { input: Input.UpdateDataInput },
+		{ entity, relation, targetEntity, targetRelation, input }: Context & { input: MapperInput.UpdateDataInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
 			const inversePrimary = await this.mapper.selectField(
@@ -76,7 +76,7 @@ export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasO
 			if (!inversePrimary) {
 				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
 			}
-			return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, input)
+			return await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), input)
 		}
 	}
 
@@ -94,7 +94,7 @@ export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasO
 		}
 
 		return async () =>
-			await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, update)
+			await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), update)
 	}
 
 	public async disconnect(

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

@@ -3,6 +3,8 @@ import { Input, Model } from '@contember/schema'
 import { Mapper } from '../../Mapper'
 import { MutationResultType } from '../../Result'
 import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
 
 type Context = Model.OneHasManyContext
 
@@ -13,33 +15,33 @@ export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasM
 	}
 
 	public async connect(
-		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.UniqueWhere },
+		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
 			return await this.mapper.update(targetEntity, input, {
-				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+				[targetRelation.name]: { connect: new CheckedPrimary(primary) },
 			})
 		}
 	}
 
 	public async create(
-		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.CreateDataInput },
+		{ entity, targetEntity, targetRelation, input }: Context & { input: MapperInput.CreateDataInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
 			return await this.mapper.insert(targetEntity, {
 				...input,
-				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+				[targetRelation.name]: { connect: new CheckedPrimary(primary) },
 			})
 		}
 	}
 
 	public async connectOrCreate(
-		{ entity, targetRelation, targetEntity, input: { connect, create } }: Context & { input: Input.ConnectOrCreateInput },
+		{ entity, targetRelation, targetEntity, input: { connect, create } }: Context & { input: MapperInput.ConnectOrCreateInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
 			const connectData = {
 				[targetRelation.name]: {
-					connect: { [entity.primary]: primary },
+					connect: new CheckedPrimary(primary),
 				},
 			}
 			return await this.mapper.upsert(targetEntity, connect, connectData, {
@@ -79,7 +81,7 @@ export class OneHasManyUpdateInputProcessor implements UpdateInputProcessor.HasM
 			if (result[0].result === MutationResultType.notFoundError) {
 				return await this.mapper.insert(targetEntity, {
 					...create,
-					[targetRelation.name]: { connect: { [entity.primary]: primary } },
+					[targetRelation.name]: { connect: new CheckedPrimary(primary) },
 				})
 			}
 			return result

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

@@ -1,7 +1,6 @@
 import {
 	ConstraintType,
 	MutationConstraintViolationError,
-	MutationEntryNotFoundError,
 	MutationNothingToDo,
 	MutationResultList,
 	MutationResultType,
@@ -11,6 +10,8 @@ import { UpdateInputProcessor } from '../../../inputProcessing'
 import { Input, Model } from '@contember/schema'
 import { Mapper } from '../../Mapper'
 import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneInverseContext
 
@@ -21,21 +22,19 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 	) {
 	}
 
-	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere }) {
+	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere | CheckedPrimary }) {
 		return async () => {
-			const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
-			if (!newOwner) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
+			const [newOwner, err] = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
+			if (err) return [err]
 			return await this.connectInternal(ctx, newOwner)
 		}
 	}
 
 	public async connectOrCreate(
-		{ input, ...ctx }: Model.OneHasOneInverseContext & { input: Input.ConnectOrCreateInput },
+		{ input, ...ctx }: Model.OneHasOneInverseContext & { input: MapperInput.ConnectOrCreateInput },
 	) {
 		return async () => {
-			const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input.connect)
+			const [newOwner] = await this.mapper.getPrimaryValue(ctx.targetEntity, input.connect)
 			if (newOwner) {
 				return await this.connectInternal(ctx, newOwner)
 			}
@@ -44,13 +43,13 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 	}
 
 
-	public async create(ctx: Model.OneHasOneInverseContext & { input: Input.CreateDataInput }) {
+	public async create(ctx: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
 		return async () => {
 			return await this.createInternal(ctx)
 		}
 	}
 
-	public async update({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.UpdateDataInput }) {
+	public async update({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.UpdateDataInput }) {
 		return async () => {
 			return await this.mapper.update(
 				targetEntity,
@@ -59,6 +58,7 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 			)
 		}
 	}
+
 	public async upsert(context: Model.OneHasOneInverseContext & { input: UpdateInputProcessor.UpsertInput }) {
 		return async () => {
 			const { targetEntity, targetRelation, entity, input: { update, create } } = context
@@ -82,7 +82,7 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 			if (!relation.nullable && !targetRelation.orphanRemoval) {
 				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
 			}
-			const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
+			const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
 				[targetRelation.name]: { [entity.primary]: this.primaryValue },
 			})
 			if (!currentOwner) {
@@ -94,7 +94,7 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 
 			const result = await this.mapper.updateInternal(
 				targetEntity,
-				{ [targetEntity.primary]: currentOwner },
+				new CheckedPrimary(currentOwner),
 				builder => {
 					builder.addPredicates([targetRelation.name])
 					builder.addFieldValue(targetRelation.name, null)
@@ -121,7 +121,7 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		{ entity, targetEntity, targetRelation }: Model.OneHasOneInverseContext,
 		newOwner: Input.PrimaryValue,
 	) {
-		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
+		const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
 			[targetRelation.name]: { [entity.primary]: this.primaryValue },
 		})
 		if (newOwner === currentOwner) {
@@ -133,7 +133,7 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 				// todo cascade delete support?
 				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
 			}
-			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: currentOwner }, builder => {
+			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, new CheckedPrimary(currentOwner), builder => {
 				builder.addPredicates([targetRelation.name])
 				builder.addFieldValue(targetRelation.name, null)
 			})
@@ -143,7 +143,7 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 			? await this.mapper.selectField(targetEntity, { [targetEntity.primary]: newOwner }, targetRelation.name)
 			: null
 
-		const connectToNewOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: newOwner }, builder => {
+		const connectToNewOwner = await this.mapper.updateInternal(targetEntity, new CheckedPrimary(newOwner), builder => {
 			builder.addPredicates([targetRelation.name])
 			builder.addFieldValue(targetRelation.name, this.primaryValue)
 		})
@@ -156,8 +156,8 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		return result
 	}
 
-	private async createInternal({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.CreateDataInput }) {
-		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
+	private async createInternal({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: MapperInput.CreateDataInput }) {
+		const [currentOwner] = await this.mapper.getPrimaryValue(targetEntity, {
 			[targetRelation.name]: { [entity.primary]: this.primaryValue },
 		})
 		if (currentOwner && !targetRelation.nullable) {
@@ -166,7 +166,7 @@ export class OneHasOneInverseUpdateInputProcessor implements UpdateInputProcesso
 		}
 		const result: MutationResultList = []
 		if (currentOwner) {
-			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: currentOwner }, builder => {
+			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, new CheckedPrimary(currentOwner), builder => {
 				builder.addPredicates([targetRelation.name])
 				builder.addFieldValue(targetRelation.name, null)
 			})