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

package/graphql.codegen.yml

@@ -10,9 +10,6 @@ generates:
     plugins:
       - "typescript"
       - "typescript-operations"
-      - "typescript-resolvers"
-require:
-  - "ts-node/register"
 hooks:
   afterAllFileWrite:
     - eslint --fix

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.1.1",
+  "version": "1.2.0-alpha.10",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,25 +10,25 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.1.1",
-    "@contember/dic": "^1.1.1",
-    "@contember/engine-common": "^1.1.1",
-    "@contember/graphql-utils": "^1.1.1",
-    "@contember/schema": "^1.1.1",
-    "@contember/schema-utils": "^1.1.1",
+    "@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",
     "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.1.1",
-    "@contember/engine-api-tester": "^1.1.1",
-    "@contember/schema-definition": "^1.1.1",
-    "@graphql-codegen/cli": "^1.15.2",
-    "@graphql-codegen/typescript": "^1.15.2",
-    "@graphql-codegen/typescript-operations": "^1.15.2",
-    "@graphql-codegen/typescript-resolvers": "^1.15.2",
-    "@types/node": "^17.0.5",
-    "graphql": "^15.4.0",
+    "@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",
+    "@graphql-codegen/cli": "^2.6.2",
+    "@graphql-codegen/typescript": "^2.5.1",
+    "@graphql-codegen/typescript-operations": "^2.4.2",
+    "@graphql-codegen/typescript-resolvers": "^2.6.6",
+    "@types/node": "^18",
+    "graphql": "^16.5.0",
     "pg": "^8.5.0"
   },
   "peerDependencies": {

package/src/acl/EvaluatedPredicateReplacer.ts

@@ -0,0 +1,32 @@
+import { Input, Model, Writable } from '@contember/schema'
+import { replaceWhere } from '../mapper/select/optimizer/WhereReplacer'
+
+export class EvaluatedPredicateReplacer {
+	constructor(
+		private readonly evaluatedPredicate: Input.Where,
+		private readonly sourceEntity: Model.Entity,
+		private readonly relation: Model.AnyRelation,
+	) {
+	}
+
+	public replace(where: Input.Where): Input.Where {
+		const result: Writable<Input.Where> = {}
+		for (const [key, value] of Object.entries(where)) {
+			if (key === 'not') {
+				result['not'] = this.replace(value as Input.Where)
+
+			} else if (key === 'and' || key === 'or') {
+				result[key] = (value as Input.Where[]).map(it => this.replace(it))
+
+			} else if (key === this.relation.name) {
+				result[key] = replaceWhere(value as Input.Where, this.evaluatedPredicate, { [this.sourceEntity.primary]: { always: true } })
+
+			} else {
+				result[key] = value
+			}
+
+		}
+		return result
+	}
+
+}

package/src/acl/PermissionFactory.ts

@@ -17,7 +17,7 @@ export class PermissionFactory {
 			}
 			result = this.mergePermissions(result, rolePermissions)
 		}
-		this.makePrimaryPredicatesUnionOfAllFields(result)
+		result = this.makePrimaryPredicatesUnionOfAllFields(result)
 
 		return result
 	}
@@ -45,18 +45,20 @@ export class PermissionFactory {
 		}))
 	}
 
-	private makePrimaryPredicatesUnionOfAllFields(permissions: Acl.Permissions): void {
-		for (let entityName in permissions) {
+	private makePrimaryPredicatesUnionOfAllFields(permissions: Acl.Permissions): Acl.Permissions {
+		return mapObject(permissions, (permission, entityName): Acl.EntityPermissions => {
 			const entity = getEntity(this.schema, entityName)
-			const entityPermissions: Acl.EntityPermissions = permissions[entityName]
-			const entityPredicates: Writable<Acl.PredicateMap> = entityPermissions.predicates
+			const entityPredicates: Writable<Acl.PredicateMap> = { ...permission.predicates }
+			const entityOperations: Writable<Acl.EntityOperations> = { ...permission.operations }
 
 			const operationNames = ['read', 'create', 'update'] as const
 			for (let operation of operationNames) {
-				const fieldPermissions: Writable<Acl.FieldPermissions> | undefined = entityPermissions.operations[operation]
-				if (fieldPermissions === undefined) {
+				if (!entityOperations[operation]) {
 					continue
 				}
+				const fieldPermissions: Writable<Acl.FieldPermissions> = { ...entityOperations[operation] }
+				entityOperations[operation] = fieldPermissions
+
 				if (Object.values(fieldPermissions).some(it => it === true)) {
 					fieldPermissions[entity.primary] = true
 				}
@@ -70,25 +72,28 @@ export class PermissionFactory {
 					.filter((value, index, array): value is string => array.indexOf(value) === index)
 
 				let idPermissions: Acl.Predicate = fieldPermissions[entity.primary] || false
-				const predicates = { ...entityPermissions.predicates }
 
 				for (let predicateReference of predicateReferences) {
 					const [predicateDefinition, predicate] = this.mergePredicates(
-						predicates,
+						entityPredicates,
 						idPermissions,
-						predicates,
+						entityPredicates,
 						predicateReference,
 					)
 					if (typeof predicate !== 'string' || predicateDefinition === undefined) {
 						throw new Error('should not happen')
 					}
 					idPermissions = predicate
-					predicates[predicate] = predicateDefinition
+					entityPredicates[predicate] = predicateDefinition
 				}
 				fieldPermissions[entity.primary] = idPermissions
-				entityPredicates[idPermissions as Acl.PredicateReference] = predicates[idPermissions as Acl.PredicateReference]
+				entityPredicates[idPermissions as Acl.PredicateReference] = entityPredicates[idPermissions as Acl.PredicateReference]
 			}
-		}
+			return {
+				operations: entityOperations,
+				predicates: entityPredicates,
+			}
+		})
 	}
 
 	private mergePermissions(left: Acl.Permissions, right: Acl.Permissions): Acl.Permissions {

package/src/acl/PredicateFactory.ts

@@ -1,10 +1,17 @@
 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
 
 export class PredicateFactory {
-	constructor(private readonly permissions: Acl.Permissions, private readonly variableInjector: VariableInjector) {}
+	constructor(
+		private readonly permissions: Acl.Permissions,
+		private readonly model: Model.Schema,
+		private readonly variableInjector: VariableInjector,
+	) {}
 
 	public shouldApplyCellLevelPredicate(
 		entity: Model.Entity,
@@ -16,13 +23,22 @@ export class PredicateFactory {
 		return permissions?.[fieldName] !== permissions?.[rowLevelField]
 	}
 
-	public create(entity: Model.Entity, operation: Acl.Operation.delete): Input.Where
+	public create(
+		entity: Model.Entity,
+		operation: Acl.Operation.delete,
+	): Input.Where
 	public create(
 		entity: Model.Entity,
 		operation: Acl.Operation.update | Acl.Operation.read | Acl.Operation.create,
 		fieldNames?: string[],
+		overRelation?: Model.AnyRelation,
 	): Input.Where
-	public create(entity: Model.Entity, operation: Acl.Operation, fieldNames?: string[]): Input.Where {
+	public create(
+		entity: Model.Entity,
+		operation: Acl.Operation,
+		fieldNames?: string[],
+		overRelation?: Model.AnyRelation,
+	): Input.Where {
 		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name]
 		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
 
@@ -68,11 +84,8 @@ export class PredicateFactory {
 		if (predicatesWhere.length === 0) {
 			return {}
 		}
-		if (predicatesWhere.length === 1) {
-			return predicatesWhere[0]
-		}
-
-		return { and: predicatesWhere }
+		const where: Input.Where = predicatesWhere.length === 1 ? predicatesWhere[0] : { and: predicatesWhere }
+		return this.optimizePredicates(where, overRelation)
 	}
 
 	private getRequiredPredicates(
@@ -94,4 +107,22 @@ export class PredicateFactory {
 		}
 		return predicates
 	}
+
+	private optimizePredicates(where: Input.Where, overRelation?: Model.AnyRelation) {
+		if (!overRelation) {
+			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])
+		if (Object.keys(sourcePredicate).length === 0) {
+			return where
+		}
+
+		const replacer = new EvaluatedPredicateReplacer(sourcePredicate, sourceEntity, overRelation)
+		return replacer.replace(where)
+	}
 }

package/src/acl/PredicatesInjector.ts

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

package/src/acl/VariableInjector.ts

@@ -10,29 +10,16 @@ export class VariableInjector {
 		return predicateDefinitionProcessor.process(entity, where, {
 			handleColumn: ({ value }) => {
 				if (typeof value === 'string') {
-					return this.createCondition(this.variables[value] || undefined)
+					return this.variables[value] ?? { never: true }
 				}
 				return value as Input.Condition
 			},
 			handleRelation: ({ value, targetEntity }) => {
 				if (typeof value === 'string') {
-					return { [targetEntity.primary]: this.createCondition(this.variables[value] || undefined) }
+					return { [targetEntity.primary]: this.variables[value] ?? { never: true } }
 				}
 				return value
 			},
 		})
 	}
-
-	private createCondition(variable: Acl.VariableValue | undefined): Input.Condition {
-		if (variable === undefined) {
-			return { never: true }
-		}
-		if (Array.isArray(variable)) {
-			return { in: variable }
-		}
-		if (typeof variable === 'string' || typeof variable === 'number') {
-			return { eq: variable }
-		}
-		throw new Error('not implemented')
-	}
 }

package/src/acl/VariableUtils.ts

@@ -1,36 +1,20 @@
-import { Acl } from '@contember/schema'
-import { getRoleVariables } from '@contember/schema-utils'
+import { Acl, Input } from '@contember/schema'
+import { getRoleVariables, ParsedMembership } from '@contember/schema-utils'
 
-type Memberships = readonly { role: string; variables: readonly { name: string; values: readonly string[] }[] }[]
 
 export const createAclVariables = (
 	aclSchema: Acl.Schema,
-	identity: {
-		identityId: string
-		personId: string | null
-		memberships: Memberships
-	},
+	memberships: readonly ParsedMembership[],
 ): Acl.VariablesMap => {
 
-	const variablesEntries = identity.memberships.flatMap(
+	const variablesEntries = memberships.flatMap(
 		membership => {
 			const roleVariables = getRoleVariables(membership.role, aclSchema)
-			const membershipVariablesMap = Object.fromEntries(membership.variables.map(it => [it.name, it.values]))
+			const membershipVariablesMap = Object.fromEntries(membership.variables.map(it => [it.name, it.condition]))
 
-			return Object.entries(roleVariables).map(([name, def]) => {
+			return Object.keys(roleVariables).map((name): [string, Input.Condition] => {
 				const prefixed = prefixVariable(membership.role, name)
-
-				switch (def.type) {
-					case Acl.VariableType.entity:
-						return [prefixed, membershipVariablesMap[name] ?? []]
-					case Acl.VariableType.predefined:
-						switch (def.value) {
-							case 'identityID':
-								return [prefixed, [identity.identityId]]
-							case 'personID':
-								return [prefixed, identity.personId ? [identity.personId] : []]
-						}
-				}
+				return [prefixed, membershipVariablesMap[name] ?? { never: true }]
 			})
 		},
 	)

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducerExecutionHandler.ts

@@ -31,7 +31,7 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 				}
 				const newObjectNode = objectNode.withArgs<Input.ListQueryInput>({ filter: whereWithParentId })
 
-				return context.mapper.select(targetEntity, newObjectNode, targetRelation.name)
+				return context.mapper.select(targetEntity, newObjectNode, targetRelation, targetRelation.name)
 			},
 			null,
 		)
@@ -40,7 +40,7 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 	private getRelationTarget(
 		entity: Model.Entity,
 		relationName: string,
-	): [Model.Entity, Model.Relation & Model.JoiningColumnRelation] {
+	): [Model.Entity, Model.AnyRelation & Model.JoiningColumnRelation] {
 		return acceptFieldVisitor(this.schema, entity, relationName, {
 			visitColumn: (): never => {
 				throw new ImplementationException('HasManyToHasOneReducerExecutionHandler: Not applicable for a column')
@@ -50,7 +50,7 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 				relation,
 				targetEntity,
 				targetRelation,
-			): [Model.Entity, Model.Relation & Model.JoiningColumnRelation] => {
+			): [Model.Entity, Model.AnyRelation & Model.JoiningColumnRelation] => {
 				if (!targetRelation || !isIt<Model.JoiningColumnRelation>(targetRelation, 'joiningColumn')) {
 					throw new Error('HasManyToHasOneReducerExecutionHandler: only applicable for relations with joiningColumn')
 				}

package/src/extensions/paginatedHasMany/PaginatedHasManyCountVisitor.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { GroupedCounts, JoiningColumns, Mapper, RelationFetcher } from '../../mapper'
+import { GroupedCounts, Mapper, RelationFetcher } from '../../mapper'
 import { ObjectNode } from '../../inputProcessing'
 
 export class PaginatedHasManyCountVisitor implements
@@ -20,11 +20,13 @@ export class PaginatedHasManyCountVisitor implements
 		targetRelation: Model.ManyHasOneRelation,
 	): Promise<GroupedCounts> {
 		return await this.relationFetcher.countOneHasManyGroups(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			targetRelation,
-			this.ids,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				targetEntity: targetEntity,
+				targetRelation: targetRelation,
+				ids: this.ids,
+			},
 		)
 	}
 
@@ -34,18 +36,16 @@ export class PaginatedHasManyCountVisitor implements
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyInverseRelation | null,
 	): Promise<GroupedCounts> {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
 		return await this.relationFetcher.countManyHasManyGroups(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			relation,
-			this.ids,
-			columns,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				targetEntity: targetEntity,
+				sourceRelation: relation,
+				targetRelation,
+				directionFrom: 'owning',
+				ids: this.ids,
+			},
 		)
 	}
 
@@ -55,18 +55,16 @@ export class PaginatedHasManyCountVisitor implements
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyOwningRelation,
 	): Promise<GroupedCounts> {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			targetColumn: joiningTable.joiningColumn,
-			sourceColumn: joiningTable.inverseJoiningColumn,
-		}
 		return await this.relationFetcher.countManyHasManyGroups(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			targetRelation,
-			this.ids,
-			columns,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				targetEntity: targetEntity,
+				sourceRelation: relation,
+				targetRelation,
+				directionFrom: 'inverse',
+				ids: this.ids,
+			},
 		)
 	}
 

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
@@ -20,12 +20,14 @@ export class PaginatedHasManyNodesVisitor implements
 		targetRelation: Model.ManyHasOneRelation,
 	): Promise<SelectGroupedObjects> {
 		return await this.relationFetcher.fetchOneHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			targetRelation,
-			this.ids,
+			{
+				mapper: this.mapper,
+				objectNode: this.objectNode,
+				targetEntity: targetEntity,
+				relation: relation,
+				targetRelation: targetRelation,
+				ids: this.ids,
+			},
 		)
 	}
 
@@ -35,19 +37,16 @@ export class PaginatedHasManyNodesVisitor implements
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyInverseRelation | null,
 	): Promise<SelectGroupedObjects> {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
 		return await this.relationFetcher.fetchManyHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			relation,
-			columns,
-			this.ids,
+			{
+				mapper: this.mapper,
+				field: this.objectNode,
+				targetEntity: targetEntity,
+				sourceRelation: relation,
+				targetRelation,
+				directionFrom: 'owning',
+				ids: this.ids,
+			},
 		)
 	}
 
@@ -57,19 +56,16 @@ export class PaginatedHasManyNodesVisitor implements
 		targetEntity: Model.Entity,
 		targetRelation: Model.ManyHasManyOwningRelation,
 	): Promise<SelectGroupedObjects> {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			targetColumn: joiningTable.joiningColumn,
-			sourceColumn: joiningTable.inverseJoiningColumn,
-		}
 		return await this.relationFetcher.fetchManyHasManyGroups(
-			this.mapper,
-			this.objectNode,
-			targetEntity,
-			relation,
-			targetRelation,
-			columns,
-			this.ids,
+			{
+				mapper: this.mapper,
+				field: this.objectNode,
+				targetEntity: targetEntity,
+				sourceRelation: relation,
+				targetRelation,
+				directionFrom: 'inverse',
+				ids: this.ids,
+			},
 		)
 	}
 

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, null)
 		if (!node) {
 			return null
 		}