@contember/engine-content-api 1.2.0-alpha.1 → 1.2.0-alpha.12

package/src/extensions/paginatedHasMany/PaginatedHasManyNodesVisitor.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { GroupedCounts, JoiningColumns, Mapper, RelationFetcher, SelectGroupedObjects } from '../../mapper'
+import { Mapper, RelationFetcher, SelectGroupedObjects } from '../../mapper'
 import { ObjectNode } from '../../inputProcessing'
 
 export class PaginatedHasManyNodesVisitor implements
@@ -11,65 +11,42 @@ export class PaginatedHasManyNodesVisitor implements
 		private readonly objectNode: ObjectNode<Input.PaginationQueryInput>,
 		private readonly relationFetcher: RelationFetcher,
 		private readonly mapper: Mapper,
+		private readonly relationPath: Model.AnyRelationContext[],
 	) {}
 
-	async visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	): Promise<SelectGroupedObjects> {
+	async visitOneHasMany(relationContext: Model.OneHasManyContext) {
 		return await this.relationFetcher.fetchOneHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			targetRelation,
-			this.ids,
+			{
+				mapper: this.mapper,
+				objectNode: this.objectNode,
+				relationContext,
+				relationPath: this.relationPath,
+				ids: this.ids,
+			},
 		)
 	}
 
-	async visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	): Promise<SelectGroupedObjects> {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
+	async visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext) {
 		return await this.relationFetcher.fetchManyHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			relation,
-			columns,
-			this.ids,
+			{
+				mapper: this.mapper,
+				field: this.objectNode,
+				relationContext,
+				relationPath: this.relationPath,
+				ids: this.ids,
+			},
 		)
 	}
 
-	async visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): Promise<SelectGroupedObjects> {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			targetColumn: joiningTable.joiningColumn,
-			sourceColumn: joiningTable.inverseJoiningColumn,
-		}
+	async visitManyHasManyInverse(relationContext: Model.ManyHasManyInverseContext) {
 		return await this.relationFetcher.fetchManyHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			targetRelation,
-			columns,
-			this.ids,
+			{
+				mapper: this.mapper,
+				field: this.objectNode,
+				relationContext,
+				relationPath: this.relationPath,
+				ids: this.ids,
+			},
 		)
 	}
 

package/src/input-validation/ColumnValueResolver.ts

@@ -1,11 +1,10 @@
 import { NoDataError, Providers, resolveColumnValue } from '@contember/schema-utils'
-import * as Context from '../inputProcessing'
-import { Value } from '@contember/schema'
+import { Model, Value } from '@contember/schema'
 
 export class ColumnValueResolver {
 	constructor(private readonly providers: Providers) {}
 
-	getDefaultValidationValue(context: Context.ColumnContext): Value.AtomicValue | undefined {
+	getDefaultValidationValue(context: Model.ColumnContext & { input: Value.FieldValue | undefined }): Value.AtomicValue | undefined {
 		if (context.column.name === context.entity.primary) {
 			return '00000000-0000-0000-0000-000000000000'
 		}

package/src/input-validation/EntityRulesResolver.ts

@@ -35,7 +35,7 @@ export class EntityRulesResolver {
 
 	public getEntityRules(entityName: string): Validation.EntityRules {
 		const definedRules = this.validationSchema[entityName] || {}
-		const fieldsNotNullFlag = acceptEveryFieldVisitor(this.model, entityName, new NotNullFieldsVisitor())
+		const fieldsNotNullFlag = acceptEveryFieldVisitor(this.model, entityName, new RequiredFieldsVisitor())
 		const notNullFields = Object.keys(filterObject(fieldsNotNullFlag, (field, val) => val))
 		return notNullFields.reduce(
 			(entityRules, field) => ({
@@ -50,9 +50,9 @@ export class EntityRulesResolver {
 	}
 }
 
-class NotNullFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Model.ColumnVisitor<boolean> {
-	visitColumn(entity: Model.Entity, column: Model.AnyColumn): boolean {
-		return !column.nullable
+class RequiredFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Model.ColumnVisitor<boolean> {
+	visitColumn({ column }: Model.ColumnContext): boolean {
+		return !column.nullable && typeof column.default === 'undefined' && !column.sequence
 	}
 
 	visitManyHasManyInverse(): boolean {
@@ -63,7 +63,7 @@ class NotNullFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Mode
 		return false
 	}
 
-	visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation): boolean {
+	visitManyHasOne({ relation }: Model.ManyHasOneContext): boolean {
 		return !relation.nullable
 	}
 
@@ -71,11 +71,11 @@ class NotNullFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Mode
 		return false
 	}
 
-	visitOneHasOneInverse(entity: Model.Entity, relation: Model.OneHasOneInverseRelation, targetEntity: Model.Entity): boolean {
+	visitOneHasOneInverse({ targetEntity, relation }: Model.OneHasOneInverseContext): boolean {
 		return !relation.nullable && !targetEntity.view
 	}
 
-	visitOneHasOneOwning(entity: Model.Entity, relation: Model.OneHasOneOwningRelation): boolean {
+	visitOneHasOneOwning({ relation }: Model.OneHasOneOwningContext): boolean {
 		return !relation.nullable
 	}
 }

package/src/input-validation/QueryAstFactory.ts

@@ -22,7 +22,7 @@ export class QueryAstFactory {
 			fieldName,
 			{
 				visitColumn: () => [null, new FieldNode(fieldName, fieldName, {})],
-				visitRelation: ({}, {}, targetEntity) => [
+				visitRelation: ({ targetEntity }) => [
 					targetEntity,
 					new ObjectNode(fieldName, fieldName, [], {}, {}, []).withField(
 						new FieldNode(targetEntity.primary, targetEntity.primary, {}),

package/src/input-validation/ValidationContext.ts

@@ -10,7 +10,7 @@ namespace ValidationContext {
 	}
 
 	export type NodeType = Value.Object
-	export type ValueType = Value.FieldValue
+	export type ValueType = Value.FieldValue | undefined
 
 	export enum NodeContextType {
 		value = 'value',
@@ -69,7 +69,7 @@ namespace ValidationContext {
 
 	export const createSingleNodeContext = (
 		parent: NodeContext | ValueContext,
-		value: object | null | string | number | boolean,
+		value: ValueType,
 	): NodeContext | ValueContext => {
 		if (Array.isArray(value)) {
 			throw new Error('Nested arrays are not allowed')

package/src/input-validation/ValidationDataSelector.ts

@@ -1,6 +1,6 @@
 import { QueryAstFactory } from './QueryAstFactory'
 import { Mapper } from '../mapper'
-import { Dependencies, DependencyCollector } from './dependencies'
+import { Dependencies } from './dependencies'
 import { Input, Model, Value } from '@contember/schema'
 
 export class ValidationDataSelector {
@@ -20,7 +20,7 @@ export class ValidationDataSelector {
 			return {}
 		}
 		const queryAst = this.queryAstFactory.create(entity.name, dependencies).withArg('by', where)
-		const node = await mapper.selectUnique(entity, queryAst)
+		const node = await mapper.selectUnique(entity, queryAst, [])
 		if (!node) {
 			return null
 		}

package/src/input-validation/preValidation/CreateInputPreValidationProcessor.ts

@@ -1,5 +1,4 @@
 import { CreateInputProcessor } from '../../inputProcessing'
-import * as Context from '../../inputProcessing'
 import { Input, Model } from '@contember/schema'
 import { appendRelationToPath, ValidationPath } from '../ValidationPath'
 import { Mapper } from '../../mapper'
@@ -15,30 +14,30 @@ export class CreateInputPreValidationProcessor implements CreateInputProcessor<R
 		private readonly mapper: Mapper,
 	) {}
 
-	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Context.ManyHasManyInverseContext, Result> = {
+	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyInverseContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
 	}
 
-	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Context.ManyHasManyOwningContext, Result> = {
+	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyOwningContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
 	}
 
-	manyHasOne: CreateInputProcessor.HasOneRelationProcessor<Context.ManyHasOneContext, Result> = {
+	manyHasOne: CreateInputProcessor.HasOneRelationProcessor<Model.ManyHasOneContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
 	}
 
-	oneHasMany: CreateInputProcessor.HasManyRelationProcessor<Context.OneHasManyContext, Result> = {
+	oneHasMany: CreateInputProcessor.HasManyRelationProcessor<Model.OneHasManyContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
 	}
-	oneHasOneInverse: CreateInputProcessor.HasOneRelationProcessor<Context.OneHasOneInverseContext, Result> = {
+	oneHasOneInverse: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneInverseContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
 	}
-	oneHasOneOwning: CreateInputProcessor.HasOneRelationProcessor<Context.OneHasOneOwningContext, Result> = {
+	oneHasOneOwning: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneOwningContext, Result> = {
 		connect: NoResult,
 		create: context => this.validateCreate(context),
 	}
@@ -61,7 +60,7 @@ export class CreateInputPreValidationProcessor implements CreateInputProcessor<R
 		})
 	}
 
-	async column(context: Context.ColumnContext): Promise<Result> {
+	async column(context: Model.ColumnContext): Promise<Result> {
 		return []
 	}
 }

package/src/input-validation/preValidation/InputPreValidator.ts

@@ -78,12 +78,12 @@ export class InputPreValidator {
 
 	private createContextForCreate(entity: Model.Entity, data: Input.CreateDataInput): ValidationContext.NodeContext {
 		const nodeData = acceptEveryFieldVisitor(this.model, entity, {
-			visitColumn: (entity, column) => {
+			visitColumn: ({ entity, column }) => {
 				const value = data[column.name] as Input.ColumnValue | undefined
 				const validationValue = this.columnValueResolver.getDefaultValidationValue({ entity, column, input: value })
 				return validationValue === undefined ? null : validationValue
 			},
-			visitHasOne: (entity, relation) => {
+			visitHasOne: ({ relation }) => {
 				const value = data[relation.name] as Input.CreateOneRelationInput | undefined
 				return value ? true : null
 			},
@@ -101,10 +101,10 @@ export class InputPreValidator {
 		dependencies: Dependencies,
 	): Promise<ValidationContext.NodeContext> {
 		const inputNodeData = acceptEveryFieldVisitor(this.model, entity, {
-			visitColumn: (entity, column) => {
+			visitColumn: ({ column }) => {
 				return data[column.name] as Input.ColumnValue | undefined
 			},
-			visitHasOne: (entity, relation) => {
+			visitHasOne: ({ relation }) => {
 				const value = data[relation.name] as Input.CreateOneRelationInput | Input.UpdateOneRelationInput | undefined | null
 				if (value === undefined || value === null) {
 					return undefined

package/src/input-validation/preValidation/UpdateInputPreValidationProcessor.ts

@@ -1,5 +1,4 @@
 import { UpdateInputProcessor } from '../../inputProcessing'
-import * as Context from '../../inputProcessing'
 import { Input, Model } from '@contember/schema'
 import { appendRelationToPath, ValidationPath } from '../ValidationPath'
 import { Mapper } from '../../mapper'
@@ -16,11 +15,11 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		private readonly mapper: Mapper,
 	) {}
 
-	async column(context: Context.ColumnContext): Promise<Result> {
+	async column(context: Model.ColumnContext): Promise<Result> {
 		return []
 	}
 
-	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Context.ManyHasManyInverseContext, Result> = {
+	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyInverseContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
@@ -28,7 +27,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		disconnect: NoResult,
 		['delete']: NoResult,
 	}
-	manyHasManyOwning: UpdateInputProcessor.HasManyRelationInputProcessor<Context.ManyHasManyOwningContext, Result> = {
+	manyHasManyOwning: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyOwningContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
@@ -36,7 +35,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		disconnect: NoResult,
 		['delete']: NoResult,
 	}
-	manyHasOne: UpdateInputProcessor.HasOneRelationInputProcessor<Context.ManyHasOneContext, Result> = {
+	manyHasOne: UpdateInputProcessor.HasOneRelationInputProcessor<Model.ManyHasOneContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
@@ -44,7 +43,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		disconnect: NoResult,
 		['delete']: NoResult,
 	}
-	oneHasMany: UpdateInputProcessor.HasManyRelationInputProcessor<Context.OneHasManyContext, Result> = {
+	oneHasMany: UpdateInputProcessor.HasManyRelationInputProcessor<Model.OneHasManyContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate({ ...ctx, input: ctx.input.data }),
 		upsert: ctx => this.processUpsert(ctx),
@@ -52,7 +51,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		disconnect: NoResult,
 		['delete']: NoResult,
 	}
-	oneHasOneInverse: UpdateInputProcessor.HasOneRelationInputProcessor<Context.OneHasOneInverseContext, Result> = {
+	oneHasOneInverse: UpdateInputProcessor.HasOneRelationInputProcessor<Model.OneHasOneInverseContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),
@@ -61,7 +60,7 @@ export class UpdateInputPreValidationProcessor implements UpdateInputProcessor<R
 		['delete']: NoResult,
 	}
 
-	oneHasOneOwning: UpdateInputProcessor.HasOneRelationInputProcessor<Context.OneHasOneOwningContext, Result> = {
+	oneHasOneOwning: UpdateInputProcessor.HasOneRelationInputProcessor<Model.OneHasOneOwningContext, Result> = {
 		create: ctx => this.processCreate(ctx),
 		update: ctx => this.processUpdate(ctx),
 		upsert: ctx => this.processUpsert(ctx),

package/src/inputProcessing/CreateInputProcessor.ts

@@ -1,17 +1,16 @@
-import { Input } from '@contember/schema'
-import * as Context from './InputContext'
+import { Input, Model } from '@contember/schema'
 
 interface CreateInputProcessor<Result = void> {
-	column(context: Context.ColumnContext): Promise<Result>
+	column(context: CreateInputProcessor.ContextWithInput<Model.ColumnContext, Input.ColumnValue | undefined>): Promise<Result>
 
-	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Context.ManyHasManyInverseContext, Result>
-	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Context.ManyHasManyOwningContext, Result>
+	manyHasManyInverse: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyInverseContext, Result>
+	manyHasManyOwning: CreateInputProcessor.HasManyRelationProcessor<Model.ManyHasManyOwningContext, Result>
 
-	oneHasOneInverse: CreateInputProcessor.HasOneRelationProcessor<Context.OneHasOneInverseContext, Result>
-	oneHasOneOwning: CreateInputProcessor.HasOneRelationProcessor<Context.OneHasOneOwningContext, Result>
+	oneHasOneInverse: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneInverseContext, Result>
+	oneHasOneOwning: CreateInputProcessor.HasOneRelationProcessor<Model.OneHasOneOwningContext, Result>
 
-	oneHasMany: CreateInputProcessor.HasManyRelationProcessor<Context.OneHasManyContext, Result>
-	manyHasOne: CreateInputProcessor.HasOneRelationProcessor<Context.ManyHasOneContext, Result>
+	oneHasMany: CreateInputProcessor.HasManyRelationProcessor<Model.OneHasManyContext, Result>
+	manyHasOne: CreateInputProcessor.HasOneRelationProcessor<Model.ManyHasOneContext, Result>
 }
 
 namespace CreateInputProcessor {

package/src/inputProcessing/CreateInputVisitor.ts

@@ -1,7 +1,6 @@
 import { isIt } from '../utils'
 import { Input, Model } from '@contember/schema'
 import { CreateInputProcessor } from './CreateInputProcessor'
-import * as Context from './InputContext'
 import { filterObject } from '../utils'
 import { UserError } from '../exception'
 import { ImplementationException } from '../exception'
@@ -16,119 +15,58 @@ export class CreateInputVisitor<Result> implements
 		private readonly data: Input.CreateDataInput,
 	) {}
 
-	public visitColumn(entity: Model.Entity, column: Model.AnyColumn): Promise<Result> {
+	public visitColumn(context: Model.ColumnContext): Promise<Result> {
 		return this.createInputProcessor.column({
-			entity,
-			column,
-			input: this.data[column.name] as Input.ColumnValue,
+			...context,
+			input: this.data[context.column.name] as Input.ColumnValue,
 		})
 	}
 
-	public visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	) {
-		return this.processManyRelationInput<Context.ManyHasManyInverseContext>(
+	public visitManyHasManyInverse(context: Model.ManyHasManyInverseContext) {
+		return this.processManyRelationInput(
 			this.createInputProcessor.manyHasManyInverse,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	) {
-		return this.processManyRelationInput<Context.ManyHasManyOwningContext>(
+	public visitManyHasManyOwning(context: Model.ManyHasManyOwningContext) {
+		return this.processManyRelationInput(
 			this.createInputProcessor.manyHasManyOwning,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitManyHasOne(
-		entity: Model.Entity,
-		relation: Model.ManyHasOneRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasManyRelation | null,
-	) {
-		return this.processRelationInput<Context.ManyHasOneContext>(
+	public visitManyHasOne(context: Model.ManyHasOneContext) {
+		return this.processRelationInput(
 			this.createInputProcessor.manyHasOne,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 
-	public visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	) {
-		return this.processManyRelationInput<Context.OneHasManyContext>(
+	public visitOneHasMany(context: Model.OneHasManyContext) {
+		return this.processManyRelationInput(
 			this.createInputProcessor.oneHasMany,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateManyRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateManyRelationInput,
 		)
 	}
 
-	public visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	) {
-		return this.processRelationInput<Context.OneHasOneInverseContext>(
+	public visitOneHasOneInverse(context: Model.OneHasOneInverseContext) {
+		return this.processRelationInput(
 			this.createInputProcessor.oneHasOneInverse,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	) {
-		return this.processRelationInput<Context.OneHasOneOwningContext>(
+	public visitOneHasOneOwning(context: Model.OneHasOneOwningContext) {
+		return this.processRelationInput(
 			this.createInputProcessor.oneHasOneOwning,
-			{
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			},
-			this.data[relation.name] as Input.CreateOneRelationInput,
+			context,
+			this.data[context.relation.name] as Input.CreateOneRelationInput,
 		)
 	}
 

package/src/inputProcessing/UpdateInputProcessor.ts

@@ -1,20 +1,19 @@
-import { Input } from '@contember/schema'
-import * as Context from './InputContext'
+import { Input, Model } from '@contember/schema'
 
 interface UpdateInputProcessor<Result = void> {
-	column(context: Context.ColumnContext): Promise<Result>
+	column(context: UpdateInputProcessor.ContextWithInput<Model.ColumnContext, Input.ColumnValue | undefined>): Promise<Result>
 
-	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Context.ManyHasManyInverseContext, Result>
+	manyHasManyInverse: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyInverseContext, Result>
 
-	manyHasManyOwning: UpdateInputProcessor.HasManyRelationInputProcessor<Context.ManyHasManyOwningContext, Result>
+	manyHasManyOwning: UpdateInputProcessor.HasManyRelationInputProcessor<Model.ManyHasManyOwningContext, Result>
 
-	manyHasOne: UpdateInputProcessor.HasOneRelationInputProcessor<Context.ManyHasOneContext, Result>
+	manyHasOne: UpdateInputProcessor.HasOneRelationInputProcessor<Model.ManyHasOneContext, Result>
 
-	oneHasMany: UpdateInputProcessor.HasManyRelationInputProcessor<Context.OneHasManyContext, Result>
+	oneHasMany: UpdateInputProcessor.HasManyRelationInputProcessor<Model.OneHasManyContext, Result>
 
-	oneHasOneInverse: UpdateInputProcessor.HasOneRelationInputProcessor<Context.OneHasOneInverseContext, Result>
+	oneHasOneInverse: UpdateInputProcessor.HasOneRelationInputProcessor<Model.OneHasOneInverseContext, Result>
 
-	oneHasOneOwning: UpdateInputProcessor.HasOneRelationInputProcessor<Context.OneHasOneOwningContext, Result>
+	oneHasOneOwning: UpdateInputProcessor.HasOneRelationInputProcessor<Model.OneHasOneOwningContext, Result>
 }
 
 namespace UpdateInputProcessor {