@contember/engine-content-api 2.0.0-alpha.9 → 2.0.0-beta.1

package/src/mapper/insert/SqlCreateInputProcessor.ts

@@ -2,130 +2,75 @@ import { Input, Model, Value } from '@contember/schema'
 import { Mapper } from '../Mapper'
 import { InsertBuilder } from './InsertBuilder'
 import { Providers, resolveColumnValue } from '@contember/schema-utils'
-import * as Context from '../../inputProcessing'
 import { CreateInputProcessor } from '../../inputProcessing'
 import { MutationResultList } from '../Result'
 import { hasManyProcessor, hasOneProcessor } from '../MutationProcessorHelper'
-import { OneHasOneInverseCreateInputProcessor } from '../relations/OneHasOneInverseCreateInputProcessor'
-import { OneHasOneOwningCreateInputProcessor } from '../relations/OneHasOneOwningCreateInputProcessor'
-import { ManyHasManyInputProcessor } from '../relations/ManyHasManyInputProcessor'
-import { ManyHasOneInputProcessor } from '../relations/ManyHasOneInputProcessor'
-import { OneHasManyInputProcessor } from '../relations/OneHasManyInputProcessor'
+import { OneHasOneInverseCreateInputProcessor } from './relations/OneHasOneInverseCreateInputProcessor'
+import { OneHasOneOwningCreateInputProcessor } from './relations/OneHasOneOwningCreateInputProcessor'
+import { OneHasManyCreateInputProcessor } from './relations/OneHasManyCreateInputProcessor'
+import { ManyHasOneCreateInputProcessor } from './relations/ManyHasOneCreateInputProcessor'
+import { ManyHasManyCreateInputProcessor } from './relations/ManyHasManyCreateInputProcessor'
 
-export class SqlCreateInputProcessor implements CreateInputProcessor<MutationResultList> {
+
+export type SqlCreateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue }) => Promise<MutationResultList>)
+export class SqlCreateInputProcessor implements CreateInputProcessor<SqlCreateInputProcessorResult> {
 
 	private oneHasOneInverseCreateInputProcessor:  OneHasOneInverseCreateInputProcessor
 	private oneHasOneOwningCreateInputProcessor:  OneHasOneOwningCreateInputProcessor
-	private oneHasManyCreateInputProcessor:  OneHasManyInputProcessor
-	private manyHasOneCreateInputProcessor:  ManyHasOneInputProcessor
-	private manyHasManyCreateInputProcessor:  ManyHasManyInputProcessor
+	private oneHasManyCreateInputProcessor:  OneHasManyCreateInputProcessor
+	private manyHasOneCreateInputProcessor: ManyHasOneCreateInputProcessor
+	private manyHasManyCreateInputProcessor: ManyHasManyCreateInputProcessor
 
 	constructor(
 		private readonly insertBuilder: InsertBuilder,
 		private readonly mapper: Mapper,
 		private readonly providers: Providers,
 	) {
-		this.oneHasOneInverseCreateInputProcessor = new OneHasOneInverseCreateInputProcessor(this.insertBuilder, this.mapper)
-		this.oneHasOneOwningCreateInputProcessor = new OneHasOneOwningCreateInputProcessor(this.insertBuilder, this.mapper)
-		this.oneHasManyCreateInputProcessor = new OneHasManyInputProcessor(this.mapper)
-		this.manyHasOneCreateInputProcessor = new ManyHasOneInputProcessor(this.mapper)
-		this.manyHasManyCreateInputProcessor = new ManyHasManyInputProcessor(this.mapper)
+		this.oneHasOneInverseCreateInputProcessor = new OneHasOneInverseCreateInputProcessor(this.mapper)
+		this.oneHasOneOwningCreateInputProcessor = new OneHasOneOwningCreateInputProcessor(this.mapper, this.insertBuilder)
+		this.oneHasManyCreateInputProcessor = new OneHasManyCreateInputProcessor(this.mapper)
+		this.manyHasOneCreateInputProcessor = new ManyHasOneCreateInputProcessor(this.mapper, this.insertBuilder)
+		this.manyHasManyCreateInputProcessor = new ManyHasManyCreateInputProcessor(this.mapper)
 	}
 
-	public async column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<MutationResultList> {
+	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 []
 	}
 
-	manyHasManyInverse: CreateInputProcessor<MutationResultList>['manyHasManyInverse'] = {
-		connect: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.connect(ctx, primary)
-		}),
-		create: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.create(ctx, primary)
-		}),
-		connectOrCreate: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
-		}),
+	manyHasManyInverse: CreateInputProcessor<SqlCreateInputProcessorResult>['manyHasManyInverse'] = {
+		connect: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-	manyHasManyOwning: CreateInputProcessor<MutationResultList>['manyHasManyOwning'] = {
-		connect: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.connect(ctx, primary)
-		}),
-		create: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.create(ctx, primary)
-		}),
-		connectOrCreate: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
-		}),
+	manyHasManyOwning: CreateInputProcessor<SqlCreateInputProcessorResult>['manyHasManyOwning'] = {
+		connect: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-	manyHasOne: CreateInputProcessor<MutationResultList>['manyHasOne'] = {
+	manyHasOne: CreateInputProcessor<SqlCreateInputProcessorResult>['manyHasOne'] = {
 		nothing: async ctx => {
 			this.insertBuilder.addFieldValue(ctx.relation.name, null)
 			return []
 		},
-		connect: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.connect(ctx, this.insertBuilder)),
-		create: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.create(ctx, this.insertBuilder)),
-		connectOrCreate: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.connectOrCreate(ctx, this.insertBuilder)),
+		connect: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.connect(ctx)),
+		create: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-	oneHasMany: CreateInputProcessor<MutationResultList>['oneHasMany'] = {
-		connect: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.oneHasManyCreateInputProcessor.connect(ctx, primary)
-		}),
-		create: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.oneHasManyCreateInputProcessor.create(ctx, primary)
-		}),
-		connectOrCreate: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.oneHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
-		}),
+	oneHasMany: CreateInputProcessor<SqlCreateInputProcessorResult>['oneHasMany'] = {
+		connect: hasManyProcessor(ctx => this.oneHasManyCreateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.oneHasManyCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.oneHasManyCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
 
-	oneHasOneOwning: CreateInputProcessor<MutationResultList>['oneHasOneOwning'] = {
+	oneHasOneOwning: CreateInputProcessor<SqlCreateInputProcessorResult>['oneHasOneOwning'] = {
 		nothing: async ctx => {
 			this.insertBuilder.addFieldValue(ctx.relation.name, null)
 			return []
@@ -135,7 +80,7 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<MutationRes
 		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneOwningCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-	oneHasOneInverse: CreateInputProcessor<MutationResultList>['oneHasOneInverse'] = {
+	oneHasOneInverse: CreateInputProcessor<SqlCreateInputProcessorResult>['oneHasOneInverse'] = {
 		connect: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.connect(ctx)),
 		create: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.create(ctx)),
 		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.connectOrCreate(ctx)),

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

@@ -0,0 +1,59 @@
+import { Input, Model } from '@contember/schema'
+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
+
+export class ManyHasManyCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult> {
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
+	): Promise<SqlCreateInputProcessorResult> {
+		return async ({ primary }) => {
+			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: MapperInput.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const insertResult = await this.mapper.insert(targetEntity, input)
+			const insertPrimary = getInsertPrimary(insertResult)
+			if (!insertPrimary) {
+				return insertResult
+			}
+			return [
+				...insertResult,
+				...(await this.mapper.connectJunction(entity, relation, primary, insertPrimary)),
+			]
+		}
+	}
+
+	public async connectOrCreate(
+		context: Context & { input: MapperInput.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			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)
+				if (!otherPrimary) {
+					return insertResult
+				}
+			}
+			return await this.mapper.connectJunction(context.entity, context.relation, primary, otherPrimary)
+		}
+	}
+}

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

@@ -0,0 +1,57 @@
+import { Input, Model } from '@contember/schema'
+import { getInsertPrimary, MutationEntryNotFoundError } from '../../Result'
+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
+
+export class ManyHasOneCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult>  {
+
+	constructor(
+		private readonly mapper: Mapper,
+		private readonly insertBuilder: InsertBuilder,
+	) {
+	}
+	public async connect(
+		{ targetEntity, relation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
+	) {
+		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: MapperInput.CreateDataInput },
+	) {
+		const insertResult = await this.mapper.insert(targetEntity, input)
+		const value = getInsertPrimary(insertResult)
+		if (!value) {
+			return insertResult
+		}
+		this.insertBuilder.addFieldValue(relation.name, value)
+		return []
+	}
+
+	public async connectOrCreate(
+		{ input: { connect, create }, relation, targetEntity }: Context & { input: MapperInput.ConnectOrCreateInput },
+	) {
+		const [value] = await this.mapper.getPrimaryValue(targetEntity, connect)
+		if (value) {
+			this.insertBuilder.addFieldValue(relation.name, value)
+		} else {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const primary = getInsertPrimary(insertResult)
+			if (!primary) {
+				return insertResult
+			}
+
+			this.insertBuilder.addFieldValue(relation.name, primary)
+		}
+		return []
+	}
+}

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

@@ -0,0 +1,52 @@
+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
+
+export class OneHasManyCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult> {
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+	public async connect(
+		{ 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: new CheckedPrimary(primary) },
+			})
+		}
+	}
+
+	public async create(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: MapperInput.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.insert(targetEntity, {
+				...input,
+				[targetRelation.name]: { connect: new CheckedPrimary(primary) },
+			})
+		}
+	}
+
+	public async connectOrCreate(
+		{ entity, targetRelation, targetEntity, input: { connect, create } }: Context & { input: MapperInput.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const connectData = {
+				[targetRelation.name]: {
+					connect: new CheckedPrimary(primary),
+				},
+			}
+			return await this.mapper.upsert(targetEntity, connect, connectData, {
+				...create,
+				...connectData,
+			})
+		}
+	}
+}

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

@@ -0,0 +1,90 @@
+import { Mapper } from '../../Mapper'
+import { ConstraintType, MutationConstraintViolationError, MutationEntryNotFoundError, MutationResultList } from '../../Result'
+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
+
+export class OneHasOneInverseCreateInputProcessor implements CreateInputProcessor.HasOneRelationProcessor<Context, SqlCreateInputProcessorResult>  {
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(context: Context & { input: Input.UniqueWhere | CheckedPrimary }) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const { targetEntity, input } = context
+			const [owner, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (err) return [err]
+
+			return await this.connectInternal({ ...context, input: new CheckedPrimary(owner) }, primary)
+		}
+	}
+
+
+	public async create(
+		{ input, targetRelation, targetEntity }: Context & { input: MapperInput.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.insert(targetEntity, input, builder => {
+				builder.addPredicates([targetRelation.name])
+				builder.addFieldValue(targetRelation.name, primary)
+			})
+		}
+	}
+
+	public async connectOrCreate(
+		{ input, ...context }: Context & { input: MapperInput.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const [owner] = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
+			if (owner) {
+				return await this.connectInternal({ ...context, input: new CheckedPrimary(owner) }, primary)
+			}
+
+			return await this.createInternal({ input: input.create, ...context }, primary)
+		}
+	}
+
+	private async connectInternal(
+		{ entity, targetEntity, targetRelation, relation, input }: Context & { input: CheckedPrimary },
+		primary: Input.PrimaryValue,
+	) {
+
+		const currentInverseSideOfOwner = await this.mapper.selectField(targetEntity, input, targetRelation.name)
+		const orphanResult: MutationResultList = []
+		if (currentInverseSideOfOwner) {
+			if (targetRelation.orphanRemoval) {
+				const orphanUnique = { [entity.primary]: currentInverseSideOfOwner }
+				const orphanDelete = await this.mapper.delete(entity, orphanUnique)
+				orphanResult.push(...orphanDelete)
+			} else if (!relation.nullable) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+		}
+
+		const connectResult = await this.mapper.updateInternal(targetEntity, input, update => {
+			update.addPredicates([targetRelation.name])
+			update.addFieldValue(targetRelation.name, primary)
+		})
+
+		return [
+			...connectResult,
+			...orphanResult,
+		]
+	}
+
+	private async createInternal(
+		context: Context & { input: MapperInput.CreateDataInput },
+		primary: Input.PrimaryValue,
+	) {
+		return await this.mapper.insert(context.targetEntity, context.input, builder => {
+			builder.addPredicates([context.targetRelation.name])
+			builder.addFieldValue(context.targetRelation.name, primary)
+		})
+	}
+}

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

@@ -0,0 +1,87 @@
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationResultList,
+} from '../../Result'
+import { InsertBuilder } from '../../insert'
+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
+
+export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor.HasOneRelationProcessor<Context, SqlCreateInputProcessorResult>{
+	constructor(
+		private readonly mapper: Mapper,
+		private readonly insertBuilder: InsertBuilder,
+	) {
+	}
+
+	public async connect(context: Context & { input: Input.UniqueWhere | CheckedPrimary }) {
+		const { input, relation, targetEntity } = context
+		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
+		}
+		this.insertBuilder.addFieldValue(relation.name, inverseSide)
+		return disconnectResult
+	}
+
+	public async create(context: Context & { input: MapperInput.CreateDataInput }) {
+		const insertResult = await this.mapper.insert(context.targetEntity, context.input)
+		const primary = getInsertPrimary(insertResult)
+		if (!primary) {
+			return insertResult
+		}
+		this.insertBuilder.addFieldValue(context.relation.name, primary)
+		return []
+	}
+
+	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 })
+			if (disconnectResult.some(it => it.error)) {
+				return disconnectResult
+			}
+			return []
+
+		} else {
+			const insertResult = await this.mapper.insert(context.targetEntity, input.create)
+			const primary = getInsertPrimary(insertResult)
+			if (primary) {
+				this.insertBuilder.addFieldValue(context.relation.name, primary)
+			}
+			return insertResult
+		}
+	}
+
+	private async disconnectCurrentOwner(
+		{ entity, relation, targetEntity, input }: Context & { input: Input.PrimaryValue },
+	): Promise<MutationResultList> {
+		const [currentOwnerOfInverseSide] = await this.mapper.getPrimaryValue(entity, {
+			[relation.name]: { [targetEntity.primary]: input },
+		})
+		if (!currentOwnerOfInverseSide) {
+			return []
+		}
+
+		if (!relation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		const currentOwnerUnique = { [entity.primary]: currentOwnerOfInverseSide }
+		return await this.mapper.updateInternal(entity, currentOwnerUnique, builder => {
+			builder.addPredicates([relation.name])
+			builder.addFieldValue(relation.name, null)
+		})
+	}
+}

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -24,6 +24,9 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		if (column.type === Model.ColumnType.Date && this.settings.shortDateResponse) {
 			selectFrom += '::text'
 		}
+		if (column.type === Model.ColumnType.DateTime && this.settings.fullDateTimeResponse) {
+			selectFrom += '::text'
+		}
 
 		this.executionContext.addColumn({
 			query: qb => qb.select(new Literal(selectFrom), columnAlias),

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>
+
+}