@contember/engine-content-api 1.2.0-alpha.10 → 1.2.0-alpha.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-alpha.10",
+  "version": "1.2.0-alpha.11",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,19 +10,19 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.0-alpha.10",
-    "@contember/dic": "^1.2.0-alpha.10",
-    "@contember/engine-common": "^1.2.0-alpha.10",
-    "@contember/graphql-utils": "^1.2.0-alpha.10",
-    "@contember/schema": "^1.2.0-alpha.10",
-    "@contember/schema-utils": "^1.2.0-alpha.10",
+    "@contember/database": "^1.2.0-alpha.11",
+    "@contember/dic": "^1.2.0-alpha.11",
+    "@contember/engine-common": "^1.2.0-alpha.11",
+    "@contember/graphql-utils": "^1.2.0-alpha.11",
+    "@contember/schema": "^1.2.0-alpha.11",
+    "@contember/schema-utils": "^1.2.0-alpha.11",
     "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-alpha.10",
-    "@contember/engine-api-tester": "^1.2.0-alpha.10",
-    "@contember/schema-definition": "^1.2.0-alpha.10",
+    "@contember/database-tester": "^1.2.0-alpha.11",
+    "@contember/engine-api-tester": "^1.2.0-alpha.11",
+    "@contember/schema-definition": "^1.2.0-alpha.11",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

package/src/acl/PredicateFactory.ts

@@ -1,7 +1,5 @@
 import { Acl, Input, Model } from '@contember/schema'
 import { VariableInjector } from './VariableInjector'
-import { isOwningRelation } from '@contember/schema-utils'
-import { ImplementationException } from '../exception'
 import { EvaluatedPredicateReplacer } from './EvaluatedPredicateReplacer'
 
 const getRowLevelPredicatePseudoField = (entity: Model.Entity) => entity.primary
@@ -31,13 +29,13 @@ export class PredicateFactory {
 		entity: Model.Entity,
 		operation: Acl.Operation.update | Acl.Operation.read | Acl.Operation.create,
 		fieldNames?: string[],
-		overRelation?: Model.AnyRelation,
+		relationContext?: Model.AnyRelationContext,
 	): Input.Where
 	public create(
 		entity: Model.Entity,
 		operation: Acl.Operation,
 		fieldNames?: string[],
-		overRelation?: Model.AnyRelation,
+		relationContext?: Model.AnyRelationContext,
 	): Input.Where {
 		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name]
 		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
@@ -85,7 +83,7 @@ export class PredicateFactory {
 			return {}
 		}
 		const where: Input.Where = predicatesWhere.length === 1 ? predicatesWhere[0] : { and: predicatesWhere }
-		return this.optimizePredicates(where, overRelation)
+		return this.optimizePredicates(where, relationContext)
 	}
 
 	private getRequiredPredicates(
@@ -108,21 +106,16 @@ export class PredicateFactory {
 		return predicates
 	}
 
-	private optimizePredicates(where: Input.Where, overRelation?: Model.AnyRelation) {
-		if (!overRelation) {
+	private optimizePredicates(where: Input.Where, relationContext?: Model.AnyRelationContext) {
+		if (!relationContext || !relationContext.targetRelation) {
 			return where
 		}
-		const otherSide = isOwningRelation(overRelation) ? overRelation.inversedBy : overRelation.ownedBy
-		if (!otherSide) {
-			throw new ImplementationException()
-		}
-		const sourceEntity = this.model.entities[overRelation.target]
-		const sourcePredicate = this.create(sourceEntity, Acl.Operation.read, [otherSide])
+		const sourcePredicate = this.create(relationContext.entity, Acl.Operation.read, [relationContext.relation.name])
 		if (Object.keys(sourcePredicate).length === 0) {
 			return where
 		}
 
-		const replacer = new EvaluatedPredicateReplacer(sourcePredicate, sourceEntity, overRelation)
+		const replacer = new EvaluatedPredicateReplacer(sourcePredicate, relationContext.entity, relationContext.targetRelation)
 		return replacer.replace(where)
 	}
 }

package/src/acl/PredicatesInjector.ts

@@ -5,18 +5,18 @@ import { PredicateFactory } from './PredicateFactory'
 export class PredicatesInjector {
 	constructor(private readonly schema: Model.Schema, private readonly predicateFactory: PredicateFactory) {}
 
-	public inject(entity: Model.Entity, where: Input.OptionalWhere, overRelation?: Model.AnyRelation): Input.OptionalWhere {
+	public inject(entity: Model.Entity, where: Input.OptionalWhere, relationContext?: Model.AnyRelationContext): Input.OptionalWhere {
 		const restrictedWhere = this.injectToWhere(where, entity, true)
-		return this.createWhere(entity, undefined, restrictedWhere, overRelation)
+		return this.createWhere(entity, undefined, restrictedWhere, relationContext)
 	}
 
 	private createWhere(
 		entity: Model.Entity,
 		fieldNames: string[] | undefined,
 		where: Input.OptionalWhere,
-		overRelation?: Model.AnyRelation,
+		relationContext?: Model.AnyRelationContext,
 	): Input.OptionalWhere {
-		const predicatesWhere: Input.Where = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, overRelation)
+		const predicatesWhere: Input.Where = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext)
 
 		const and = [where, predicatesWhere].filter(it => Object.keys(it).length > 0)
 		if (and.length === 0) {
@@ -32,17 +32,17 @@ export class PredicatesInjector {
 		where: Input.OptionalWhere,
 		entity: Model.Entity,
 		isRoot: boolean,
-		overRelation?: Model.AnyRelation,
+		relationContext?: Model.AnyRelationContext,
 	): Input.OptionalWhere {
 		const resultWhere: Writable<Input.OptionalWhere> = {}
 		if (where.and) {
-			resultWhere.and = where.and.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity, isRoot, overRelation))
+			resultWhere.and = where.and.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity, isRoot, relationContext))
 		}
 		if (where.or) {
-			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity, isRoot, overRelation))
+			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity, isRoot, relationContext))
 		}
 		if (where.not) {
-			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, overRelation)
+			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext)
 		}
 
 		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
@@ -51,21 +51,16 @@ export class PredicatesInjector {
 			return resultWhere
 		}
 		for (let field of fields) {
-			const [targetEntity, targetRelation] = acceptFieldVisitor(this.schema, entity, field, {
-				visitColumn: () => null,
-				visitRelation: (_a, _b, targetEntity, targetRelation) => [targetEntity, targetRelation ?? undefined],
-			}) ?? []
-			if (targetEntity) {
-				resultWhere[field] = this.injectToWhere(where[field] as Input.Where, targetEntity, false, targetRelation)
-			} else {
-				resultWhere[field] = where[field]
-			}
+			resultWhere[field] = acceptFieldVisitor(this.schema, entity, field, {
+				visitColumn: () => where[field],
+				visitRelation: context => this.injectToWhere(where[field] as Input.Where, context.targetEntity, false, context),
+			})
 		}
 		const fieldsForPredicate = !isRoot
 			? fields
 			: fields.filter(it => this.predicateFactory.shouldApplyCellLevelPredicate(entity, Acl.Operation.read, it))
 
-		return this.createWhere(entity, fieldsForPredicate, resultWhere, overRelation)
+		return this.createWhere(entity, fieldsForPredicate, resultWhere, relationContext)
 	}
 
 }

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducerExecutionHandler.ts

@@ -18,7 +18,19 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 		addData(
 			entity.primary,
 			async (ids: Input.PrimaryValue[]) => {
-				const [targetEntity, targetRelation] = this.getRelationTarget(entity, objectNode.extensions.relationName)
+
+				const relationContext = acceptFieldVisitor(this.schema, entity, objectNode.extensions.relationName, {
+					visitRelation: context => context,
+					visitColumn: (): never => {
+						throw new ImplementationException('HasManyToHasOneReducerExecutionHandler: Not applicable for a column')
+					},
+				})
+
+				const { targetEntity, targetRelation } = relationContext
+				if (!targetRelation || !isIt<Model.JoiningColumnRelation>(targetRelation, 'joiningColumn')) {
+					throw new Error('HasManyToHasOneReducerExecutionHandler: only applicable for relations with joiningColumn')
+				}
+
 				const uniqueWhere = this.uniqueWhereExpander.expand(targetEntity, {
 					...objectNode.args.by,
 					[targetRelation.name]: { [entity.primary]: ids },
@@ -31,31 +43,12 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 				}
 				const newObjectNode = objectNode.withArgs<Input.ListQueryInput>({ filter: whereWithParentId })
 
-				return context.mapper.select(targetEntity, newObjectNode, targetRelation, targetRelation.name)
+				return context.mapper.selectAssoc(targetEntity, newObjectNode, [
+					...context.relationPath,
+					relationContext,
+				], targetRelation.name)
 			},
 			null,
 		)
 	}
-
-	private getRelationTarget(
-		entity: Model.Entity,
-		relationName: string,
-	): [Model.Entity, Model.AnyRelation & Model.JoiningColumnRelation] {
-		return acceptFieldVisitor(this.schema, entity, relationName, {
-			visitColumn: (): never => {
-				throw new ImplementationException('HasManyToHasOneReducerExecutionHandler: Not applicable for a column')
-			},
-			visitRelation: (
-				entity,
-				relation,
-				targetEntity,
-				targetRelation,
-			): [Model.Entity, Model.AnyRelation & Model.JoiningColumnRelation] => {
-				if (!targetRelation || !isIt<Model.JoiningColumnRelation>(targetRelation, 'joiningColumn')) {
-					throw new Error('HasManyToHasOneReducerExecutionHandler: only applicable for relations with joiningColumn')
-				}
-				return [targetEntity, targetRelation]
-			},
-		})
-	}
 }

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneRelationReducerVisitor.ts

@@ -48,12 +48,7 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 		return {}
 	}
 
-	public visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.AnyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.AnyRelation | null,
-	) {
+	public visitOneHasMany({ entity, targetEntity, targetRelation, relation }: Model.OneHasManyContext) {
 		if (!targetRelation) {
 			return {}
 		}

package/src/extensions/paginatedHasMany/PaginatedHasManyCountVisitor.ts

@@ -11,58 +11,40 @@ export class PaginatedHasManyCountVisitor 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<GroupedCounts> {
+	async visitOneHasMany(relationContext: Model.OneHasManyContext): Promise<GroupedCounts> {
 		return await this.relationFetcher.countOneHasManyGroups(
 			{
 				mapper: this.mapper,
 				filter: this.objectNode.args.filter,
-				targetEntity: targetEntity,
-				targetRelation: targetRelation,
+				relationContext,
+				relationPath: this.relationPath,
 				ids: this.ids,
 			},
 		)
 	}
 
-	async visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	): Promise<GroupedCounts> {
+	async visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext): Promise<GroupedCounts> {
 		return await this.relationFetcher.countManyHasManyGroups(
 			{
 				mapper: this.mapper,
 				filter: this.objectNode.args.filter,
-				targetEntity: targetEntity,
-				sourceRelation: relation,
-				targetRelation,
-				directionFrom: 'owning',
+				relationContext,
+				relationPath: this.relationPath,
 				ids: this.ids,
 			},
 		)
 	}
 
-	async visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): Promise<GroupedCounts> {
+	async visitManyHasManyInverse(relationContext: Model.ManyHasManyInverseContext): Promise<GroupedCounts> {
 		return await this.relationFetcher.countManyHasManyGroups(
 			{
 				mapper: this.mapper,
 				filter: this.objectNode.args.filter,
-				targetEntity: targetEntity,
-				sourceRelation: relation,
-				targetRelation,
-				directionFrom: 'inverse',
+				relationContext,
+				relationPath: this.relationPath,
 				ids: this.ids,
 			},
 		)

package/src/extensions/paginatedHasMany/PaginatedHasManyExecutionHandler.ts

@@ -7,7 +7,10 @@ import { PaginatedHasManyCountVisitor } from './PaginatedHasManyCountVisitor'
 import { PaginatedHasManyNodesVisitor } from './PaginatedHasManyNodesVisitor'
 
 export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<Input.PaginationQueryInput, PaginatedHasManyFieldProviderExtension> {
-	constructor(private readonly schema: Model.Schema, private readonly relationFetcher: RelationFetcher) {}
+	constructor(
+		private readonly schema: Model.Schema,
+		private readonly relationFetcher: RelationFetcher,
+	) {}
 
 	process(
 		context: SelectExecutionHandlerContext<Input.PaginationQueryInput, PaginatedHasManyFieldProviderExtension>,
@@ -25,7 +28,7 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 						this.schema,
 						entity,
 						objectNode.extensions.relationName,
-						new PaginatedHasManyCountVisitor(ids, objectNode, this.relationFetcher, mapper),
+						new PaginatedHasManyCountVisitor(ids, objectNode, this.relationFetcher, mapper, context.relationPath),
 					  )
 					: {}
 
@@ -34,7 +37,7 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 						this.schema,
 						entity,
 						objectNode.extensions.relationName,
-						new PaginatedHasManyNodesVisitor(ids, pagination.nodeField, this.relationFetcher, mapper),
+						new PaginatedHasManyNodesVisitor(ids, pagination.nodeField, this.relationFetcher, mapper, context.relationPath),
 					  )
 					: undefined
 				const result = new Map<Input.PrimaryValue, any>()

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor.ts

@@ -11,37 +11,19 @@ export class PaginatedHasManyFieldProviderVisitor implements
 
 	constructor(private readonly paginatedFieldFactory: PaginatedFieldConfigFactory) {}
 
-	visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	): FieldMap<PaginatedHasManyFieldProviderExtension> {
+	visitOneHasMany({ targetEntity, relation }: Model.OneHasManyContext) {
 		return this.createField(targetEntity, relation)
 	}
 
-	visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	): FieldMap<PaginatedHasManyFieldProviderExtension> {
+	visitManyHasManyOwning({ targetEntity, relation }: Model.ManyHasManyOwningContext) {
 		return this.createField(targetEntity, relation)
 	}
 
-	visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): FieldMap<PaginatedHasManyFieldProviderExtension> {
+	visitManyHasManyInverse({ targetEntity, relation }: Model.ManyHasManyInverseContext) {
 		return this.createField(targetEntity, relation)
 	}
 
-	private createField(
-		entity: Model.Entity,
-		relation: Model.Relation,
-	): FieldMap<PaginatedHasManyFieldProviderExtension> {
+	private createField(entity: Model.Entity, relation: Model.Relation): FieldMap<PaginatedHasManyFieldProviderExtension> {
 		return {
 			[`paginate${capitalizeFirstLetter(relation.name)}`]: {
 				...this.paginatedFieldFactory.createFieldConfig(entity),

package/src/extensions/paginatedHasMany/PaginatedHasManyNodesVisitor.ts

@@ -11,59 +11,40 @@ 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(
 			{
 				mapper: this.mapper,
 				objectNode: this.objectNode,
-				targetEntity: targetEntity,
-				relation: relation,
-				targetRelation: targetRelation,
+				relationContext,
+				relationPath: this.relationPath,
 				ids: this.ids,
 			},
 		)
 	}
 
-	async visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	): Promise<SelectGroupedObjects> {
+	async visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext) {
 		return await this.relationFetcher.fetchManyHasManyGroups(
 			{
 				mapper: this.mapper,
 				field: this.objectNode,
-				targetEntity: targetEntity,
-				sourceRelation: relation,
-				targetRelation,
-				directionFrom: 'owning',
+				relationContext,
+				relationPath: this.relationPath,
 				ids: this.ids,
 			},
 		)
 	}
 
-	async visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): Promise<SelectGroupedObjects> {
+	async visitManyHasManyInverse(relationContext: Model.ManyHasManyInverseContext) {
 		return await this.relationFetcher.fetchManyHasManyGroups(
 			{
 				mapper: this.mapper,
 				field: this.objectNode,
-				targetEntity: targetEntity,
-				sourceRelation: relation,
-				targetRelation,
-				directionFrom: 'inverse',
+				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

@@ -51,7 +51,7 @@ export class EntityRulesResolver {
 }
 
 class RequiredFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Model.ColumnVisitor<boolean> {
-	visitColumn(entity: Model.Entity, column: Model.AnyColumn): boolean {
+	visitColumn({ column }: Model.ColumnContext): boolean {
 		return !column.nullable && typeof column.default === 'undefined' && !column.sequence
 	}
 
@@ -63,7 +63,7 @@ class RequiredFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Mod
 		return false
 	}
 
-	visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation): boolean {
+	visitManyHasOne({ relation }: Model.ManyHasOneContext): boolean {
 		return !relation.nullable
 	}
 
@@ -71,11 +71,11 @@ class RequiredFieldsVisitor implements Model.RelationByTypeVisitor<boolean>, Mod
 		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/ValidationDataSelector.ts

@@ -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, null)
+		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