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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "v1.2.0-alpha.8",
+  "version": "1.2.0-beta.1",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,24 +10,26 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^v1.2.0-alpha.8",
-    "@contember/dic": "^v1.2.0-alpha.8",
-    "@contember/engine-common": "^v1.2.0-alpha.8",
-    "@contember/graphql-utils": "^v1.2.0-alpha.8",
-    "@contember/schema": "^v1.2.0-alpha.8",
-    "@contember/schema-utils": "^v1.2.0-alpha.8",
+    "@contember/database": "^1.2.0-beta.1",
+    "@contember/dic": "^1.2.0-beta.1",
+    "@contember/logger": "^1.2.0-beta.1",
+    "@contember/graphql-utils": "^1.2.0-beta.1",
+    "@contember/schema": "^1.2.0-beta.1",
+    "@contember/schema-definition": "^1.2.0-beta.1",
+    "@contember/schema-utils": "^1.2.0-beta.1",
     "@graphql-tools/schema": "^8.3.5",
+    "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^v1.2.0-alpha.8",
-    "@contember/engine-api-tester": "^v1.2.0-alpha.8",
-    "@contember/schema-definition": "^v1.2.0-alpha.8",
+    "@contember/database-tester": "^1.2.0-beta.1",
+    "@contember/engine-api-tester": "^1.2.0-beta.1",
+    "@contember/schema-definition": "^1.2.0-beta.1",
     "@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": "^16",
+    "@types/node": "^18",
     "graphql": "^16.5.0",
     "pg": "^8.5.0"
   },

package/src/acl/EvaluatedPredicateReplacer.ts

@@ -1,32 +1,25 @@
 import { Input, Model, Writable } from '@contember/schema'
-import deepEqual from 'fast-deep-equal'
+import { replaceWhere } from '../mapper/select/optimizer/WhereReplacer'
 
 export class EvaluatedPredicateReplacer {
 	constructor(
-		private readonly evaluatedPredicate: Input.Where,
+		private readonly evaluatedPredicate: Input.OptionalWhere,
 		private readonly sourceEntity: Model.Entity,
 		private readonly relation: Model.AnyRelation,
 	) {
 	}
 
-	public replace(where: Input.Where): Input.Where {
-		return this.replaceInternal(where, false)
-	}
-
-	private replaceInternal(where: Input.Where, onRelation: boolean): Input.Where {
-		if (onRelation && deepEqual(where, this.evaluatedPredicate)) {
-			return { [this.sourceEntity.primary]: { always: true } }
-		}
-		const result: Writable<Input.Where> = {}
+	public replace(where: Input.OptionalWhere): Input.OptionalWhere {
+		const result: Writable<Input.OptionalWhere> = {}
 		for (const [key, value] of Object.entries(where)) {
 			if (key === 'not') {
-				result['not'] = this.replaceInternal(value as Input.Where, onRelation)
+				result['not'] = this.replace(value as Input.OptionalWhere)
 
 			} else if (key === 'and' || key === 'or') {
-				result[key] = (value as Input.Where[]).map(it => this.replaceInternal(it, onRelation))
+				result[key] = (value as Input.Where[]).map(it => this.replace(it))
 
-			} else if (key === this.relation.name && !onRelation) {
-				result[key] = this.replaceInternal(value as Input.Where, true)
+			} else if (key === this.relation.name) {
+				result[key] = replaceWhere(value as Input.Where, this.evaluatedPredicate, { [this.sourceEntity.primary]: { always: true } })
 
 			} else {
 				result[key] = value
@@ -35,4 +28,5 @@ export class EvaluatedPredicateReplacer {
 		}
 		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,11 +1,14 @@
 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 interface FieldRequiredPredicate {
+	predicate: Acl.Predicate
+	isSameAsPrimary: boolean
+}
+
 export class PredicateFactory {
 	constructor(
 		private readonly permissions: Acl.Permissions,
@@ -13,6 +16,24 @@ export class PredicateFactory {
 		private readonly variableInjector: VariableInjector,
 	) {}
 
+	public getFieldPredicate(
+		entity: Model.Entity,
+		operation: Acl.Operation.update | Acl.Operation.read | Acl.Operation.create,
+		fieldName: string,
+	): FieldRequiredPredicate {
+		const permissions = this.permissions[entity.name]?.operations?.[operation]
+		const predicate = permissions?.[fieldName] ?? false
+		const rowLevelField = getRowLevelPredicatePseudoField(entity)
+
+		const primaryPredicate = permissions?.[rowLevelField] ?? false
+		const isSameAsPrimary = predicate === primaryPredicate
+
+		return {
+			isSameAsPrimary,
+			predicate,
+		}
+	}
+
 	public shouldApplyCellLevelPredicate(
 		entity: Model.Entity,
 		operation: Acl.Operation.read,
@@ -23,14 +44,28 @@ export class PredicateFactory {
 		return permissions?.[fieldName] !== permissions?.[rowLevelField]
 	}
 
-	public create(entity: Model.Entity, operation: Acl.Operation.delete): Input.Where
+	public createDeletePredicate(entity: Model.Entity) {
+		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
+		const entityPermissions = this.permissions[entity.name]
+		if (!entityPermissions) {
+			return neverCondition
+		}
+		const deletePredicate = entityPermissions.operations.delete
+		if (deletePredicate === undefined || deletePredicate === false) {
+			return neverCondition
+		}
+		if (deletePredicate === true) {
+			return {}
+		}
+		return this.buildPredicates(entity, [deletePredicate])
+	}
+
 	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[], overRelation?: Model.AnyRelation): Input.Where {
+		fieldNames: string[] = [getRowLevelPredicatePseudoField(entity)],
+		relationContext?: Model.AnyRelationContext,
+	): Input.OptionalWhere {
 		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name]
 		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
 
@@ -38,31 +73,24 @@ export class PredicateFactory {
 			return neverCondition
 		}
 
-		let predicates: Acl.PredicateReference[]
-		if (operation === Acl.Operation.delete) {
-			const deletePredicate = entityPermissions.operations.delete
-			if (deletePredicate === undefined || deletePredicate === false) {
-				return neverCondition
-			}
-			if (deletePredicate === true) {
-				return {}
-			}
-			predicates = [deletePredicate]
-		} else {
-			if (fieldNames === undefined) {
-				fieldNames = [getRowLevelPredicatePseudoField(entity)]
-			}
-			const fieldPermissions = entityPermissions.operations[operation]
-			if (fieldPermissions === undefined) {
-				return neverCondition
-			}
-			const operationPredicates = this.getRequiredPredicates(fieldNames, fieldPermissions)
-			if (operationPredicates === false) {
-				return neverCondition
-			}
-			predicates = operationPredicates
+		if (fieldNames === undefined) {
+			fieldNames = [getRowLevelPredicatePseudoField(entity)]
+		}
+		const fieldPermissions = entityPermissions.operations[operation]
+		if (fieldPermissions === undefined) {
+			return neverCondition
+		}
+		const operationPredicates = this.getRequiredPredicates(fieldNames, fieldPermissions)
+		if (operationPredicates === false) {
+			return neverCondition
 		}
 
+		return this.buildPredicates(entity, operationPredicates, relationContext)
+	}
+
+	public buildPredicates(entity: Model.Entity, predicates: Acl.PredicateReference[], relationContext?: Model.AnyRelationContext): Input.OptionalWhere {
+		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name] ?? {}
+
 		const predicatesWhere: Input.Where[] = predicates.reduce(
 			(result: Input.Where[], name: Acl.PredicateReference): Input.Where[] => {
 				if (!entityPermissions.predicates[name]) {
@@ -77,7 +105,8 @@ 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(
@@ -100,21 +129,16 @@ export class PredicateFactory {
 		return predicates
 	}
 
-	private optimizePredicates(where: Input.Where, overRelation?: Model.AnyRelation) {
-		if (!overRelation) {
+	public optimizePredicates(where: Input.OptionalWhere, 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,19 @@ 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 = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext)
+		where = this.predicateFactory.optimizePredicates(where, relationContext)
 
 		const and = [where, predicatesWhere].filter(it => Object.keys(it).length > 0)
 		if (and.length === 0) {
@@ -28,16 +29,21 @@ export class PredicatesInjector {
 		return { and: and }
 	}
 
-	private injectToWhere(where: Input.OptionalWhere, entity: Model.Entity, isRoot: boolean): Input.OptionalWhere {
+	private injectToWhere(
+		where: Input.OptionalWhere,
+		entity: Model.Entity,
+		isRoot: boolean,
+		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))
+			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))
+			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)
+			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext)
 		}
 
 		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
@@ -46,21 +52,16 @@ export class PredicatesInjector {
 			return resultWhere
 		}
 		for (let field of fields) {
-			const targetEntity = acceptFieldVisitor(this.schema, entity, field, {
-				visitColumn: () => null,
-				visitRelation: (_a, _b, targetEntity) => targetEntity,
+			resultWhere[field] = acceptFieldVisitor(this.schema, entity, field, {
+				visitColumn: () => where[field],
+				visitRelation: context => this.injectToWhere(where[field] as Input.Where, context.targetEntity, false, context),
 			})
-			if (targetEntity) {
-				resultWhere[field] = this.injectToWhere(where[field] as Input.Where, targetEntity, false)
-			} else {
-				resultWhere[field] = where[field]
-			}
 		}
 		const fieldsForPredicate = !isRoot
 			? fields
 			: fields.filter(it => this.predicateFactory.shouldApplyCellLevelPredicate(entity, Acl.Operation.read, it))
 
-		return this.createWhere(entity, fieldsForPredicate, resultWhere)
+		return this.createWhere(entity, fieldsForPredicate, resultWhere, relationContext)
 	}
 
 }

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducerExecutionHandler.ts

@@ -15,10 +15,22 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 		if (!objectNode) {
 			throw new Error()
 		}
-		addData(
-			entity.primary,
-			async (ids: Input.PrimaryValue[]) => {
-				const [targetEntity, targetRelation] = this.getRelationTarget(entity, objectNode.extensions.relationName)
+		addData({
+			field: entity.primary,
+			dataProvider: async (ids: Input.PrimaryValue[]) => {
+
+				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)
-			},
-			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]
+				return context.mapper.selectAssoc(targetEntity, newObjectNode, [
+					...context.relationPath,
+					relationContext,
+				], targetRelation.name)
 			},
+			defaultValue: null,
 		})
 	}
 }

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>,
@@ -17,15 +20,15 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 			throw new Error()
 		}
 		const pagination = createPaginationHelper(objectNode)
-		addData(
-			context.entity.primary,
-			async ids => {
+		addData({
+			field: context.entity.primary,
+			dataProvider: async ids => {
 				const counts = pagination.requiresTotalCount
 					? await acceptFieldVisitor(
 						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>()
@@ -43,7 +46,7 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 				}
 				return Object.fromEntries(result)
 			},
-			pagination.createResponse(0, []),
-		)
+			defaultValue: pagination.createResponse(0, []),
+		})
 	}
 }

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),