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

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.2",
+  "version": "1.2.0-alpha.11",
   "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.2",
-    "@contember/dic": "^1.1.2",
-    "@contember/engine-common": "^1.1.2",
-    "@contember/graphql-utils": "^1.1.2",
-    "@contember/schema": "^1.1.2",
-    "@contember/schema-utils": "^1.1.2",
+    "@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.1.2",
-    "@contember/engine-api-tester": "^1.1.2",
-    "@contember/schema-definition": "^1.1.2",
-    "@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.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",
+    "@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,15 @@
 import { Acl, Input, Model } from '@contember/schema'
 import { VariableInjector } from './VariableInjector'
+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 +21,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[],
+		relationContext?: Model.AnyRelationContext,
 	): Input.Where
-	public create(entity: Model.Entity, operation: Acl.Operation, fieldNames?: string[]): Input.Where {
+	public create(
+		entity: Model.Entity,
+		operation: Acl.Operation,
+		fieldNames?: string[],
+		relationContext?: Model.AnyRelationContext,
+	): Input.Where {
 		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name]
 		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
 
@@ -68,11 +82,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, relationContext)
 	}
 
 	private getRequiredPredicates(
@@ -94,4 +105,17 @@ export class PredicateFactory {
 		}
 		return predicates
 	}
+
+	private optimizePredicates(where: Input.Where, relationContext?: Model.AnyRelationContext) {
+		if (!relationContext || !relationContext.targetRelation) {
+			return where
+		}
+		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, relationContext.entity, relationContext.targetRelation)
+		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, relationContext?: Model.AnyRelationContext): Input.OptionalWhere {
+		const restrictedWhere = this.injectToWhere(where, entity, true)
+		return this.createWhere(entity, undefined, restrictedWhere, relationContext)
 	}
 
 	private createWhere(
 		entity: Model.Entity,
 		fieldNames: string[] | undefined,
 		where: Input.OptionalWhere,
+		relationContext?: Model.AnyRelationContext,
 	): 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, relationContext)
 
 		const and = [where, predicatesWhere].filter(it => Object.keys(it).length > 0)
 		if (and.length === 0) {
@@ -27,32 +28,39 @@ 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,
+		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))
+			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))
+			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)
+			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext)
 		}
+
 		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, {
-				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)
-			} 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, relationContext)
 	}
+
 }

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

@@ -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.name)
+				return context.mapper.selectAssoc(targetEntity, newObjectNode, [
+					...context.relationPath,
+					relationContext,
+				], targetRelation.name)
 			},
 			null,
 		)
 	}
-
-	private getRelationTarget(
-		entity: Model.Entity,
-		relationName: string,
-	): [Model.Entity, Model.Relation & 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.Relation & 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

@@ -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
@@ -11,62 +11,42 @@ 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(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			targetRelation,
-			this.ids,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				relationContext,
+				relationPath: this.relationPath,
+				ids: this.ids,
+			},
 		)
 	}
 
-	async visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyInverseRelation | null,
-	): Promise<GroupedCounts> {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
+	async visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext): Promise<GroupedCounts> {
 		return await this.relationFetcher.countManyHasManyGroups(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			relation,
-			this.ids,
-			columns,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				relationContext,
+				relationPath: this.relationPath,
+				ids: this.ids,
+			},
 		)
 	}
 
-	async visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): Promise<GroupedCounts> {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			targetColumn: joiningTable.joiningColumn,
-			sourceColumn: joiningTable.inverseJoiningColumn,
-		}
+	async visitManyHasManyInverse(relationContext: Model.ManyHasManyInverseContext): Promise<GroupedCounts> {
 		return await this.relationFetcher.countManyHasManyGroups(
-			this.mapper,
-			this.objectNode.args.filter,
-			targetEntity,
-			targetRelation,
-			this.ids,
-			columns,
+			{
+				mapper: this.mapper,
+				filter: this.objectNode.args.filter,
+				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),