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

package/src/mapper/EventManager.ts

@@ -1,6 +1,6 @@
 import { Input, Model, Value } from '@contember/schema'
-import { ResolvedColumnValue } from './ColumnValue'
 import { Mapper } from './Mapper'
+import { ColumnValue } from './ColumnValue'
 
 export class BeforeInsertEvent {
 	public type = 'BeforeInsertEvent' as const
@@ -9,7 +9,7 @@ export class BeforeInsertEvent {
 
 	constructor(
 		public readonly entity: Model.Entity,
-		public readonly data: ResolvedColumnValue[],
+		public readonly data: ColumnValue[],
 	) {
 	}
 }
@@ -19,7 +19,7 @@ export class AfterInsertEvent {
 
 	constructor(
 		public readonly entity: Model.Entity,
-		public readonly data: ResolvedColumnValue[],
+		public readonly data: ColumnValue[],
 		public readonly id: Input.PrimaryValue,
 	) {
 	}
@@ -33,7 +33,7 @@ export class BeforeUpdateEvent {
 
 	constructor(
 		public readonly entity: Model.Entity,
-		public readonly data: ResolvedColumnValue[],
+		public readonly data: ColumnValue[],
 		public readonly id: Input.PrimaryValue,
 	) {
 	}
@@ -46,13 +46,13 @@ export class AfterUpdateEvent {
 
 	constructor(
 		public readonly entity: Model.Entity,
-		public readonly data: (ResolvedColumnValue & { old: Value.FieldValue })[],
+		public readonly data: (ColumnValue & { old: Value.FieldValue })[],
 		public readonly id: Input.PrimaryValue,
 	) {
 	}
 	get hasChanges() {
 		// todo: deep equals
-		return this._hasChanges = this.data.some(it => it.resolvedValue !== it.old)
+		return this._hasChanges = this.data.some(it => it.value !== it.old)
 	}
 }
 

package/src/mapper/Mapper.ts

@@ -23,9 +23,9 @@ import { Mutex } from '../utils'
 import { CheckedPrimary } from './CheckedPrimary'
 import { ImplementationException } from '../exception'
 import { EventManager } from './EventManager'
+import { MapperInput } from './types'
 
 export class Mapper<ConnectionType extends Connection.ConnectionLike = Connection.ConnectionLike> {
-	private primaryKeyCache: Record<string, Promise<string> | string> = {}
 	private systemVariablesSetupDone: Promise<void> | undefined
 	public readonly deletedEntities = new DeletedEntitiesStorage()
 	public readonly mutex = new Mutex()
@@ -175,7 +175,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 
 	public async insert(
 		entity: Model.Entity,
-		data: Input.CreateDataInput,
+		data: MapperInput.CreateDataInput,
 		builderCb: (builder: InsertBuilder) => void = () => {},
 	): Promise<MutationResultList> {
 		if (entity.view) {
@@ -189,8 +189,8 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 
 	public async update(
 		entity: Model.Entity,
-		by: Input.UniqueWhere,
-		data: Input.UpdateDataInput,
+		by: Input.UniqueWhere | CheckedPrimary,
+		data: MapperInput.UpdateDataInput,
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		if (entity.view) {
@@ -198,10 +198,9 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		}
 		await this.setupSystemVariables()
 		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-			const primaryValue = await this.getPrimaryValue(entity, by)
-			if (primaryValue === undefined) {
-				return [new MutationEntryNotFoundError([], by)]
-			}
+			const [primaryValue, err] = await this.getPrimaryValue(entity, by)
+			if (err) return [err]
+
 			return await this.updater.update(this, entity, primaryValue, data, filter)
 		})
 	}
@@ -216,18 +215,17 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		}
 		await this.setupSystemVariables()
 		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-			const primaryValue = await this.getPrimaryValue(entity, by)
-			if (primaryValue === undefined) {
-				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
-			}
+			const [primaryValue, err] = await this.getPrimaryValue(entity, by)
+			if (err) return [err]
+
 			return await this.updater.updateCb(this, entity, primaryValue, builderCb)
 		})
 	}
 	public async upsert(
 		entity: Model.Entity,
-		by: Input.UniqueWhere,
-		update: Input.UpdateDataInput,
-		create: Input.CreateDataInput,
+		by: Input.UniqueWhere | CheckedPrimary,
+		update: MapperInput.UpdateDataInput,
+		create: MapperInput.CreateDataInput,
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		if (entity.view) {
@@ -235,7 +233,7 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		}
 		await this.setupSystemVariables()
 		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
-			const primaryValue = await this.getPrimaryValue(entity, by)
+			const [primaryValue] = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return await this.insertInternal(entity, create)
 			}
@@ -243,10 +241,8 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 		})
 	}
 
-	private insertInternal(entity: Model.Entity, data: Input.CreateDataInput, builderCb: (builder: InsertBuilder) => void = () => {}) {
+	private insertInternal(entity: Model.Entity, data: MapperInput.CreateDataInput, builderCb: (builder: InsertBuilder) => void = () => {}) {
 		return this.inserter.insert(this, entity, data, id => {
-			const where = { [entity.primary]: id }
-			this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
 		}, builderCb)
 	}
 
@@ -317,26 +313,12 @@ export class Mapper<ConnectionType extends Connection.ConnectionLike = Connectio
 	public async getPrimaryValue(
 		entity: Model.Entity,
 		where: Input.UniqueWhere | CheckedPrimary,
-	): Promise<Input.PrimaryValue | undefined> {
+	): Promise<[Input.PrimaryValue, undefined] | [undefined, MutationEntryNotFoundError]> {
 		if (where instanceof CheckedPrimary) {
-			return where.primaryValue
-		}
-		const hash = this.hashWhere(entity.name, where)
-		if (this.primaryKeyCache[hash]) {
-			return this.primaryKeyCache[hash]
+			return [where.primaryValue, undefined]
 		}
-		const primaryPromise = this.selectField(entity, where, entity.primary)
-		this.primaryKeyCache[hash] = primaryPromise
-		const primaryValue = await primaryPromise
-		const uniqueFields = Object.keys(where)
-		if (primaryValue && (uniqueFields.length !== 1 || uniqueFields[0] !== entity.primary)) {
-			this.primaryKeyCache[this.hashWhere(entity.name, { [entity.primary]: primaryValue })] = primaryValue
-		}
-		return primaryValue
-	}
-
-	private hashWhere(entityName: string, where: Input.UniqueWhere): string {
-		return JSON.stringify([entityName, where])
+		const result = await this.selectField(entity, where, entity.primary)
+		return result ? [result, undefined] : [undefined, new MutationEntryNotFoundError([], where)]
 	}
 
 	private async setupSystemVariables() {

package/src/mapper/Result.ts

@@ -1,4 +1,5 @@
 import { Input, Model, Value } from '@contember/schema'
+import { MapperInput } from './types'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -59,7 +60,7 @@ export class MutationUpdateOk implements MutationResultInterface {
 		public readonly paths: Path[],
 		public readonly entity: Model.Entity,
 		public readonly primary: Value.PrimaryValue,
-		public readonly input: Input.UpdateDataInput,
+		public readonly input: MapperInput.UpdateDataInput,
 		public readonly values: RowValues,
 		public readonly oldValues?: RowValues,
 	) {}
@@ -75,7 +76,7 @@ export class MutationCreateOk implements MutationResultInterface {
 		public readonly paths: Path[],
 		public readonly entity: Model.Entity,
 		public readonly primary: Value.PrimaryValue,
-		public readonly input: Input.CreateDataInput,
+		public readonly input: MapperInput.CreateDataInput,
 		public readonly values: RowValues,
 	) {}
 }

package/src/mapper/delete/DeleteExecutor.ts

@@ -50,10 +50,8 @@ export class DeleteExecutor {
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		return mapper.mutex.execute(async () => {
-			const primaryValue = await mapper.getPrimaryValue(entity, by)
-			if (!primaryValue) {
-				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
-			}
+			const [primaryValue, err] = await mapper.getPrimaryValue(entity, by)
+			if (err) return [err]
 
 			if (mapper.deletedEntities.isDeleted(entity.name, primaryValue)) {
 				return [new MutationNothingToDo([], NothingToDoReason.alreadyDeleted)]
@@ -79,8 +77,7 @@ export class DeleteExecutor {
 						columnName: Object.keys(entry.values)[0],
 						fieldName: Object.keys(entry.input)[0],
 						columnType: 'text',
-						resolvedValue: null,
-						value: Promise.resolve(null),
+						value: null,
 					}], entry.primary)
 					entryToEventMap.set(entry, beforeUpdateEvent)
 					await mapper.eventManager.fire(beforeUpdateEvent)
@@ -99,8 +96,7 @@ export class DeleteExecutor {
 						columnName: Object.keys(entry.values)[0],
 						fieldName: Object.keys(entry.input)[0],
 						columnType: 'text',
-						resolvedValue: null,
-						value: Promise.resolve(null),
+						value: null,
 						old: Object.values(entry.oldValues ?? {})[0],
 					}]
 					const afterEvent = new AfterUpdateEvent(entry.entity, data, entry.primary)

package/src/mapper/insert/InsertBuilder.ts

@@ -2,19 +2,19 @@ import { Acl, Input, Model, Value } from '@contember/schema'
 import { InsertBuilder as DbInsertBuilder, QueryBuilder, Value as DbValue } from '@contember/database'
 import { PathFactory, WhereBuilder } from '../select'
 import { getColumnName, getColumnType } from '@contember/schema-utils'
-import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
+import { ColumnValue, normalizeDbValue } from '../ColumnValue'
 import { PredicateFactory } from '../../acl'
 import { AfterInsertEvent, BeforeInsertEvent } from '../EventManager'
 import { Mapper } from '../Mapper'
 
 export interface InsertResult {
-	values: ResolvedColumnValue[]
+	values: ColumnValue[]
 	executed: boolean
 	primaryValue: Value.PrimaryValue | null
 }
 
 export class InsertBuilder {
-	private rowData: Map<string, ColumnValue<undefined>> = new Map()
+	private rowData: Map<string, ColumnValue> = new Map()
 	private where: { and: Input.OptionalWhere[] } = { and: [] }
 
 	constructor(
@@ -27,13 +27,14 @@ export class InsertBuilder {
 
 	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 addPredicates(fields: string[]): void {
@@ -45,13 +46,9 @@ export class InsertBuilder {
 		this.where.and.push(where)
 	}
 
-	public async getResolvedData(): Promise<ResolvedColumnValue[]> {
-		return resolveRowData([...this.rowData.values()])
-	}
-
 	public async execute(mapper: Mapper): Promise<InsertResult> {
 		try {
-			const resolvedData = await this.getResolvedData()
+			const resolvedData = [...this.rowData.values()]
 
 			const insertData = resolvedData.reduce<QueryBuilder.ColumnExpressionMap>(
 				(result, item) => ({ ...result, [item.columnName]: expr => expr.select(['root_', item.columnName]) }),
@@ -61,7 +58,13 @@ export class InsertBuilder {
 				.with('root_', qb => {
 					return resolvedData.reduce(
 						(qb, value) =>
-							qb.select(expr => expr.selectValue(value.resolvedValue as DbValue, value.columnType), value.columnName),
+							qb.select(
+								expr => expr.selectValue(
+									normalizeDbValue(value.value, value.columnType),
+									value.columnType,
+								),
+								value.columnName,
+							),
 						qb,
 					)
 				})
@@ -73,17 +76,17 @@ export class InsertBuilder {
 				})
 				.returning(this.entity.primaryColumn)
 
-			const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData as ResolvedColumnValue[])
+			const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData)
 			await mapper.eventManager.fire(beforeInsertEvent)
 
 			const returning = (await qb.execute(mapper.db)).map(it => it[this.entity.primaryColumn])
 			const result = returning.length === 1 ? returning[0] : null
 
-			const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData as ResolvedColumnValue[], result)
+			const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData, result)
 			beforeInsertEvent.afterEvent = afterInsertEvent
 			await mapper.eventManager.fire(afterInsertEvent)
 
-			return { values: resolvedData as ResolvedColumnValue[], executed: true, primaryValue: result }
+			return { values: resolvedData, executed: true, primaryValue: result }
 		} catch (e) {
 			throw e
 		}

package/src/mapper/insert/Inserter.ts

@@ -1,13 +1,14 @@
-import { MutationCreateOk, MutationNoResultError, MutationNothingToDo, MutationResultList, NothingToDoReason } from '../Result'
+import { MutationCreateOk, MutationNoResultError, MutationResultList } from '../Result'
 import { CreateInputVisitor } from '../../inputProcessing'
 import { SqlCreateInputProcessor, SqlCreateInputProcessorResult } from './SqlCreateInputProcessor'
 import { Mapper } from '../Mapper'
-import { Input, Model } from '@contember/schema'
+import { Model } from '@contember/schema'
 import { acceptFieldVisitor, Providers } from '@contember/schema-utils'
 import { InsertBuilderFactory } from './InsertBuilderFactory'
 import { InsertBuilder } from './InsertBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
 import { DatabaseMetadata } from '@contember/database'
+import { MapperInput } from '../types'
 
 export class Inserter {
 	constructor(
@@ -20,7 +21,7 @@ export class Inserter {
 	public async insert(
 		mapper: Mapper,
 		entity: Model.Entity,
-		data: Input.CreateDataInput,
+		data: MapperInput.CreateDataInput,
 		insertIdCallback: (id: string) => void,
 		builderCb: (builder: InsertBuilder) => void,
 	): Promise<MutationResultList> {

package/src/mapper/insert/SqlCreateInputProcessor.ts

@@ -36,9 +36,7 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<SqlCreateIn
 	public async column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<SqlCreateInputProcessorResult> {
 		this.insertBuilder.addFieldValue(
 			context.column.name,
-			((): Value.GenericValueLike<Value.AtomicValue | undefined> => {
-				return resolveColumnValue(context, this.providers)
-			})(),
+			resolveColumnValue(context, this.providers),
 		)
 		return []
 	}

package/src/mapper/insert/relations/ManyHasManyCreateInputProcessor.ts

@@ -3,6 +3,8 @@ import { getInsertPrimary, MutationEntryNotFoundError } from '../../Result'
 import { Mapper } from '../../Mapper'
 import { CreateInputProcessor } from '../../../inputProcessing'
 import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
 
 type Context = Model.ManyHasManyOwningContext | Model.ManyHasManyInverseContext
 
@@ -14,19 +16,17 @@ export class ManyHasManyCreateInputProcessor implements CreateInputProcessor.Has
 	}
 
 	public async connect(
-		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
 	): Promise<SqlCreateInputProcessorResult> {
 		return async ({ primary }) => {
-			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)
@@ -42,10 +42,10 @@ export class ManyHasManyCreateInputProcessor implements CreateInputProcessor.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)

package/src/mapper/insert/relations/ManyHasOneCreateInputProcessor.ts

@@ -4,6 +4,8 @@ import { Mapper } from '../../Mapper'
 import { CreateInputProcessor } from '../../../inputProcessing'
 import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
 import { InsertBuilder } from '../InsertBuilder'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
 
 type Context = Model.ManyHasOneContext
 
@@ -15,18 +17,16 @@ export class ManyHasOneCreateInputProcessor implements CreateInputProcessor.HasM
 	) {
 	}
 	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.insertBuilder.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)
@@ -38,9 +38,9 @@ export class ManyHasOneCreateInputProcessor implements CreateInputProcessor.HasM
 	}
 
 	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.insertBuilder.addFieldValue(relation.name, value)
 		} else {

package/src/mapper/insert/relations/OneHasManyCreateInputProcessor.ts

@@ -2,6 +2,8 @@ import { Input, Model } from '@contember/schema'
 import { Mapper } from '../../Mapper'
 import { CreateInputProcessor } from '../../../inputProcessing'
 import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
 
 type Context = Model.OneHasManyContext
 
@@ -12,33 +14,33 @@ export class OneHasManyCreateInputProcessor implements CreateInputProcessor.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, {

package/src/mapper/insert/relations/OneHasOneInverseCreateInputProcessor.ts

@@ -4,6 +4,7 @@ import { CheckedPrimary } from '../../CheckedPrimary'
 import { Input, Model } from '@contember/schema'
 import { CreateInputProcessor } from '../../../inputProcessing'
 import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneInverseContext
 
@@ -14,13 +15,11 @@ export class OneHasOneInverseCreateInputProcessor implements CreateInputProcesso
 	) {
 	}
 
-	public async connect(context: Context & { input: Input.UniqueWhere }) {
+	public async connect(context: Context & { input: Input.UniqueWhere | CheckedPrimary }) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
 			const { targetEntity, input } = context
-			const owner = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!owner) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
+			const [owner, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (err) return [err]
 
 			return await this.connectInternal({ ...context, input: new CheckedPrimary(owner) }, primary)
 		}
@@ -28,7 +27,7 @@ export class OneHasOneInverseCreateInputProcessor implements CreateInputProcesso
 
 
 	public async create(
-		{ input, targetRelation, targetEntity }: Context & { input: Input.CreateDataInput },
+		{ input, targetRelation, targetEntity }: Context & { input: MapperInput.CreateDataInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
 			return await this.mapper.insert(targetEntity, input, builder => {
@@ -39,10 +38,10 @@ export class OneHasOneInverseCreateInputProcessor implements CreateInputProcesso
 	}
 
 	public async connectOrCreate(
-		{ input, ...context }: Context & { input: Input.ConnectOrCreateInput },
+		{ input, ...context }: Context & { input: MapperInput.ConnectOrCreateInput },
 	) {
 		return async ({ primary }: { primary: Input.PrimaryValue }) => {
-			const owner = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
+			const [owner] = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
 			if (owner) {
 				return await this.connectInternal({ ...context, input: new CheckedPrimary(owner) }, primary)
 			}
@@ -80,7 +79,7 @@ export class OneHasOneInverseCreateInputProcessor implements CreateInputProcesso
 	}
 
 	private async createInternal(
-		context: Context & { input: Input.CreateDataInput },
+		context: Context & { input: MapperInput.CreateDataInput },
 		primary: Input.PrimaryValue,
 	) {
 		return await this.mapper.insert(context.targetEntity, context.input, builder => {

package/src/mapper/insert/relations/OneHasOneOwningCreateInputProcessor.ts

@@ -10,6 +10,8 @@ import { Mapper } from '../../Mapper'
 import { Input, Model } from '@contember/schema'
 import { CreateInputProcessor } from '../../../inputProcessing'
 import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
 
 type Context = Model.OneHasOneOwningContext
 
@@ -20,12 +22,10 @@ export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor
 	) {
 	}
 
-	public async connect(context: Context & { input: Input.UniqueWhere }) {
+	public async connect(context: Context & { input: Input.UniqueWhere | CheckedPrimary }) {
 		const { input, relation, targetEntity } = context
-		const inverseSide = await this.mapper.getPrimaryValue(targetEntity, input)
-		if (!inverseSide) {
-			return [new MutationEntryNotFoundError([], input)]
-		}
+		const [inverseSide, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (err) return [err]
 		const disconnectResult = await this.disconnectCurrentOwner({ ...context, input: inverseSide })
 		if (disconnectResult.some(it => it.error)) {
 			return disconnectResult
@@ -34,7 +34,7 @@ export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor
 		return disconnectResult
 	}
 
-	public async create(context: Context & { input: Input.CreateDataInput }) {
+	public async create(context: Context & { input: MapperInput.CreateDataInput }) {
 		const insertResult = await this.mapper.insert(context.targetEntity, context.input)
 		const primary = getInsertPrimary(insertResult)
 		if (!primary) {
@@ -44,8 +44,8 @@ export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor
 		return []
 	}
 
-	public async connectOrCreate({ input, ...context }: Context & { input: Input.ConnectOrCreateInput }) {
-		const inverseSide = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
+	public async connectOrCreate({ input, ...context }: Context & { input: MapperInput.ConnectOrCreateInput }) {
+		const [inverseSide] = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
 		if (inverseSide) {
 			this.insertBuilder.addFieldValue(context.relation.name, inverseSide)
 			const disconnectResult = await this.disconnectCurrentOwner({ ...context, input: inverseSide })
@@ -67,7 +67,7 @@ export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor
 	private async disconnectCurrentOwner(
 		{ entity, relation, targetEntity, input }: Context & { input: Input.PrimaryValue },
 	): Promise<MutationResultList> {
-		const currentOwnerOfInverseSide = await this.mapper.getPrimaryValue(entity, {
+		const [currentOwnerOfInverseSide] = await this.mapper.getPrimaryValue(entity, {
 			[relation.name]: { [targetEntity.primary]: input },
 		})
 		if (!currentOwnerOfInverseSide) {