@contember/engine-content-api 2.1.0-alpha.9 → 2.1.0-beta.2

package/src/acl/PermissionFactory.ts

@@ -7,17 +7,33 @@ export interface Identity {
 	projectRoles: readonly string[]
 }
 
+export interface ContextualPermissions {
+	root: Acl.Permissions
+	all: Acl.Permissions
+}
+
 export class PermissionFactory {
 	public create(schema: Schema, roles: readonly string[], prefix?: string): Acl.Permissions {
+		return this.createInternal(schema, roles, false, prefix)
+	}
+
+	public createContextual(schema: Schema, roles: readonly string[]): ContextualPermissions {
+		return {
+			root: this.createInternal(schema, roles, false),
+			all: this.createInternal(schema, roles, true),
+		}
+	}
+
+	private createInternal(schema: Schema, roles: readonly string[], includeThrough: boolean, prefix?: string): Acl.Permissions {
 		let result: Acl.Permissions = {}
 		for (let role of roles) {
 			const roleDefinition = schema.acl.roles[role] || { entities: {} }
 			let rolePermissions: Acl.Permissions = this.prefixPredicatesWithRole(schema.model, roleDefinition.entities, prefix || role)
 			if (roleDefinition.inherits) {
-				const inheritedPermissions = this.create(schema, roleDefinition.inherits, prefix || role)
-				rolePermissions = this.mergePermissions(inheritedPermissions, rolePermissions)
+				const inheritedPermissions = this.createInternal(schema, roleDefinition.inherits, includeThrough, prefix || role)
+				rolePermissions = this.mergePermissions(inheritedPermissions, rolePermissions, includeThrough)
 			}
-			result = this.mergePermissions(result, rolePermissions)
+			result = this.mergePermissions(result, rolePermissions, includeThrough)
 		}
 		result = this.makePrimaryPredicatesUnionOfAllFields(schema.model, result)
 
@@ -98,11 +114,11 @@ export class PermissionFactory {
 		})
 	}
 
-	private mergePermissions(left: Acl.Permissions, right: Acl.Permissions): Acl.Permissions {
+	private mergePermissions(left: Acl.Permissions, right: Acl.Permissions, includeThrough = false): Acl.Permissions {
 		const result = { ...left }
 		for (let entityName in right) {
 			if (result[entityName] !== undefined) {
-				result[entityName] = this.mergeEntityPermissions(result[entityName], right[entityName])
+				result[entityName] = this.mergeEntityPermissions(result[entityName], right[entityName], includeThrough)
 			} else {
 				result[entityName] = right[entityName]
 			}
@@ -110,7 +126,7 @@ export class PermissionFactory {
 		return result
 	}
 
-	private mergeEntityPermissions(left: Acl.EntityPermissions, right: Acl.EntityPermissions): Acl.EntityPermissions {
+	private mergeEntityPermissions(left: Acl.EntityPermissions, right: Acl.EntityPermissions, includeThrough = false): Acl.EntityPermissions {
 		let predicates: Writable<Acl.PredicateMap> = {}
 		const operations: Writable<Acl.EntityOperations> = {}
 		if (left.operations.customPrimary || right.operations.customPrimary) {
@@ -118,13 +134,19 @@ export class PermissionFactory {
 		}
 		const noRoot: `${Acl.Operation}`[] = []
 
-		for (let operation of [
-			'create',
-			'read',
-			'update',
-		] as const) {
-
-			const { predicates: opPredicates, permissions: fieldPermissions, noRoot: opNoRoot } = this.mergeOperationPermissions(left, right, operation)
+		for (
+			let operation of [
+				'create',
+				'read',
+				'update',
+			] as const
+		) {
+			const { predicates: opPredicates, permissions: fieldPermissions, noRoot: opNoRoot } = this.mergeOperationPermissions(
+				left,
+				right,
+				operation,
+				includeThrough,
+			)
 
 			if (opNoRoot) {
 				noRoot.push(operation)
@@ -136,7 +158,7 @@ export class PermissionFactory {
 			}
 		}
 
-		const { predicateDefinition, predicate, noRoot: opNoRoot } = this.mergeDeletePermissions(left, right)
+		const { predicateDefinition, predicate, noRoot: opNoRoot } = this.mergeDeletePermissions(left, right, includeThrough)
 		if (opNoRoot) {
 			noRoot.push('delete')
 		}
@@ -147,7 +169,6 @@ export class PermissionFactory {
 			operations.delete = predicate
 		}
 
-
 		if (noRoot.length > 0) {
 			operations.noRoot = noRoot
 		}
@@ -158,13 +179,17 @@ export class PermissionFactory {
 		}
 	}
 
-
-	private mergeOperationPermissions(left: Acl.EntityPermissions, right: Acl.EntityPermissions, operation: 'create' | 'read' | 'update'): {
+	private mergeOperationPermissions(
+		left: Acl.EntityPermissions,
+		right: Acl.EntityPermissions,
+		operation: 'create' | 'read' | 'update',
+		includeThrough = false,
+	): {
 		noRoot: boolean
 		predicates: Acl.PredicateMap
 		permissions: Acl.FieldPermissions
 	} {
-		const { noRoot, leftPermissions, rightPermissions } = this.resolveNoRoot(left, right, operation)
+		const { noRoot, leftPermissions, rightPermissions } = this.resolveNoRoot(left, right, operation, includeThrough)
 		return {
 			noRoot,
 			...this.mergeFieldPermissions(
@@ -176,12 +201,12 @@ export class PermissionFactory {
 		}
 	}
 
-	private mergeDeletePermissions(left: Acl.EntityPermissions, right: Acl.EntityPermissions): {
+	private mergeDeletePermissions(left: Acl.EntityPermissions, right: Acl.EntityPermissions, includeThrough = false): {
 		noRoot: boolean
 		predicate: Acl.PredicateReference | boolean
 		predicateDefinition: Acl.PredicateDefinition | undefined
 	} {
-		const { noRoot, leftPermissions, rightPermissions } = this.resolveNoRoot(left, right, 'delete')
+		const { noRoot, leftPermissions, rightPermissions } = this.resolveNoRoot(left, right, 'delete', includeThrough)
 
 		return {
 			noRoot,
@@ -194,7 +219,12 @@ export class PermissionFactory {
 		}
 	}
 
-	private resolveNoRoot<const Op extends`${Acl.Operation}`>(left: Acl.EntityPermissions, right: Acl.EntityPermissions, operation: Op): {
+	private resolveNoRoot<const Op extends `${Acl.Operation}`>(
+		left: Acl.EntityPermissions,
+		right: Acl.EntityPermissions,
+		operation: Op,
+		includeThrough = false,
+	): {
 		noRoot: boolean
 		leftPermissions: Acl.EntityPermissions['operations'][Op] | undefined
 		rightPermissions: Acl.EntityPermissions['operations'][Op] | undefined
@@ -208,8 +238,10 @@ export class PermissionFactory {
 			|| (leftRootForbidden && !rightPermissions)
 			|| (rightRootForbidden && !leftPermissions)
 
-		const resolvedLeftPermissions = !rootForbidden && leftRootForbidden ? undefined : leftPermissions
-		const resolvedRightPermissions = !rootForbidden && rightRootForbidden ? undefined : rightPermissions
+		// When includeThrough is true, keep all permissions regardless of noRoot
+		// (used for "all" permissions that apply when accessing through relations)
+		const resolvedLeftPermissions = !includeThrough && !rootForbidden && leftRootForbidden ? undefined : leftPermissions
+		const resolvedRightPermissions = !includeThrough && !rootForbidden && rightRootForbidden ? undefined : rightPermissions
 
 		return {
 			noRoot: rootForbidden,
@@ -223,7 +255,7 @@ export class PermissionFactory {
 		leftFieldPermissions: Acl.FieldPermissions | undefined = {},
 		rightPredicates: Acl.PredicateMap,
 		rightFieldPermissions: Acl.FieldPermissions | undefined = {},
-	): {predicates: Acl.PredicateMap; permissions: Acl.FieldPermissions} {
+	): { predicates: Acl.PredicateMap; permissions: Acl.FieldPermissions } {
 		const permissions: Writable<Acl.FieldPermissions> = {}
 		const predicates: Writable<Acl.PredicateMap> = {}
 

package/src/acl/PredicateFactory.ts

@@ -14,14 +14,32 @@ export class PredicateFactory {
 		private readonly permissions: Acl.Permissions,
 		private readonly model: Model.Schema,
 		private readonly variableInjector: VariableInjector,
+		private readonly allPermissions?: Acl.Permissions,
 	) {}
 
+	/**
+	 * Selects the appropriate permission set based on query context:
+	 * - `isRoot === false` (nested/relation context): uses allPermissions (includes through-only permissions)
+	 * - `isRoot === true` or `isRoot === undefined` (root or unknown context): uses root-only permissions
+	 *
+	 * The `undefined` vs `true` distinction matters: `undefined` is the default for callers
+	 * that don't track root context, and must fall through to root permissions for safety.
+	 */
+	private getPermissionsForContext(isRoot?: boolean): Acl.Permissions {
+		if (isRoot === false && this.allPermissions) {
+			return this.allPermissions
+		}
+		return this.permissions
+	}
+
 	public getFieldPredicate(
 		entity: Model.Entity,
 		operation: Acl.Operation.update | Acl.Operation.read | Acl.Operation.create,
 		fieldName: string,
+		isRoot?: boolean,
 	): FieldRequiredPredicate {
-		const permissions = this.permissions[entity.name]?.operations?.[operation]
+		const perms = this.getPermissionsForContext(isRoot)
+		const permissions = perms[entity.name]?.operations?.[operation]
 		const predicate = permissions?.[fieldName] ?? false
 		const rowLevelField = getRowLevelPredicatePseudoField(entity)
 
@@ -38,12 +56,15 @@ export class PredicateFactory {
 		entity: Model.Entity,
 		operation: Acl.Operation.read,
 		fieldName: string,
+		isRoot?: boolean,
 	): boolean {
+		const perms = this.getPermissionsForContext(isRoot)
 		const rowLevelField = getRowLevelPredicatePseudoField(entity)
-		const permissions = this.permissions[entity.name]?.operations?.[operation]
+		const permissions = perms[entity.name]?.operations?.[operation]
 		return permissions?.[fieldName] !== permissions?.[rowLevelField]
 	}
 
+	/** Delete predicates are not context-aware — through-permission support is scoped to read operations only. */
 	public createDeletePredicate(entity: Model.Entity) {
 		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
 		const entityPermissions = this.permissions[entity.name]
@@ -65,8 +86,10 @@ export class PredicateFactory {
 		operation: Acl.Operation.update | Acl.Operation.read | Acl.Operation.create,
 		fieldNames: string[] = [getRowLevelPredicatePseudoField(entity)],
 		relationContext?: Model.AnyRelationContext,
+		isRoot?: boolean,
 	): Input.OptionalWhere {
-		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name]
+		const perms = this.getPermissionsForContext(isRoot)
+		const entityPermissions: Acl.EntityPermissions = perms[entity.name]
 		const neverCondition: Input.Where = { [entity.primary]: { never: true } }
 
 		if (!entityPermissions) {
@@ -85,11 +108,17 @@ export class PredicateFactory {
 			return neverCondition
 		}
 
-		return this.buildPredicates(entity, operationPredicates, relationContext)
+		return this.buildPredicates(entity, operationPredicates, relationContext, isRoot)
 	}
 
-	public buildPredicates(entity: Model.Entity, predicates: Acl.PredicateReference[], relationContext?: Model.AnyRelationContext): Input.OptionalWhere {
-		const entityPermissions: Acl.EntityPermissions = this.permissions[entity.name] ?? {}
+	public buildPredicates(
+		entity: Model.Entity,
+		predicates: Acl.PredicateReference[],
+		relationContext?: Model.AnyRelationContext,
+		isRoot?: boolean,
+	): Input.OptionalWhere {
+		const perms = this.getPermissionsForContext(isRoot)
+		const entityPermissions: Acl.EntityPermissions = perms[entity.name] ?? {}
 
 		const predicatesWhere: Input.Where[] = predicates.reduce(
 			(result: Input.Where[], name: Acl.PredicateReference): Input.Where[] => {
@@ -105,8 +134,7 @@ export class PredicateFactory {
 			return {}
 		}
 		const where: Input.Where = predicatesWhere.length === 1 ? predicatesWhere[0] : { and: predicatesWhere }
-		return this.optimizePredicates(where, relationContext)
-
+		return this.optimizePredicates(where, relationContext, isRoot)
 	}
 
 	private getRequiredPredicates(
@@ -129,11 +157,11 @@ export class PredicateFactory {
 		return predicates
 	}
 
-	public optimizePredicates(where: Input.OptionalWhere, relationContext?: Model.AnyRelationContext) {
+	public optimizePredicates(where: Input.OptionalWhere, relationContext?: Model.AnyRelationContext, isRoot?: boolean) {
 		if (!relationContext || !relationContext.targetRelation) {
 			return where
 		}
-		const sourcePredicate = this.create(relationContext.entity, Acl.Operation.read, [relationContext.relation.name])
+		const sourcePredicate = this.create(relationContext.entity, Acl.Operation.read, [relationContext.relation.name], undefined, isRoot)
 		if (Object.keys(sourcePredicate).length === 0) {
 			return where
 		}

package/src/acl/PredicatesInjector.ts

@@ -5,9 +5,33 @@ 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, relationContext?: Model.AnyRelationContext): Input.OptionalWhere {
-		const restrictedWhere = this.injectToWhere(where, entity, true)
-		return this.createWhere(entity, undefined, restrictedWhere, relationContext)
+	public inject(
+		entity: Model.Entity,
+		where: Input.OptionalWhere,
+		relationContext?: Model.AnyRelationContext,
+		ancestorPath?: readonly Model.AnyRelationContext[],
+	): Input.OptionalWhere {
+		const isQueryRoot = !relationContext && (!ancestorPath || ancestorPath.length === 0)
+		const restrictedWhere = this.injectToWhere(where, entity, true, relationContext, false, ancestorPath ?? [], isQueryRoot)
+		return this.createWhere(entity, undefined, restrictedWhere, relationContext, false, ancestorPath ?? [], isQueryRoot)
+	}
+
+	/**
+	 * Finds an ancestor in the path that matches the given relation as a back-reference.
+	 * A match occurs when:
+	 * 1. The relation we're traversing has the same name as the inverse (targetRelation) of a relation in the ancestor path
+	 * 2. AND the entity where our relation is defined matches the targetEntity in the path
+	 *    (to prevent false positives when different entities have relations with the same name)
+	 */
+	private findBackReferencedAncestor(
+		ancestorPath: readonly Model.AnyRelationContext[],
+		relationName: string,
+		relationSourceEntityName: string,
+	): Model.AnyRelationContext | undefined {
+		return ancestorPath.find(ctx =>
+			ctx.targetRelation?.name === relationName
+			&& ctx.targetEntity.name === relationSourceEntityName
+		)
 	}
 
 	private createWhere(
@@ -15,9 +39,34 @@ export class PredicatesInjector {
 		fieldNames: string[] | undefined,
 		where: Input.OptionalWhere,
 		relationContext?: Model.AnyRelationContext,
+		isBackReferenceContext?: boolean,
+		ancestorPath?: readonly Model.AnyRelationContext[],
+		isQueryRoot?: boolean,
 	): Input.OptionalWhere {
-		const predicatesWhere = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext)
-		where = this.predicateFactory.optimizePredicates(where, relationContext)
+		// Simplify predicates when:
+		// 1. We're in a back-reference context (inside a filter that traverses back)
+		// 2. AND the relation we traversed to get here corresponds to a relation in our query path
+		// This ensures we only simplify when the traversed relation actually corresponds
+		// to a relation in our query path (not just any relation to the same entity type)
+		const shouldSimplify = isBackReferenceContext === true
+			&& ancestorPath !== undefined
+			&& relationContext !== undefined
+			&& this.findBackReferencedAncestor(ancestorPath, relationContext.relation.name, relationContext.entity.name) !== undefined
+
+		let predicatesWhere: Input.OptionalWhere
+		if (shouldSimplify) {
+			predicatesWhere = { [entity.primary]: { always: true } }
+		} else {
+			const rawPredicate = this.predicateFactory.create(entity, Acl.Operation.read, fieldNames, relationContext, isQueryRoot)
+			// Process the predicate to inject nested entity predicates
+			predicatesWhere = this.injectPredicatesToPredicate(
+				rawPredicate,
+				entity,
+				isBackReferenceContext ?? false,
+				ancestorPath ?? [],
+				isQueryRoot,
+			)
+		}
 
 		const and = [where, predicatesWhere].filter(it => Object.keys(it).length > 0)
 		if (and.length === 0) {
@@ -29,21 +78,123 @@ export class PredicatesInjector {
 		return { and: and }
 	}
 
+	/**
+	 * Processes a predicate and injects nested entity predicates for any relation traversals.
+	 * This ensures that when a predicate like { department: { company: { name: 'Acme' } } }
+	 * is used, the predicates of Department and Company are also applied.
+	 */
+	private injectPredicatesToPredicate(
+		where: Input.OptionalWhere,
+		entity: Model.Entity,
+		isBackReferenceContext: boolean,
+		ancestorPath: readonly Model.AnyRelationContext[],
+		isQueryRoot?: boolean,
+	): Input.OptionalWhere {
+		const resultWhere: Writable<Input.OptionalWhere> = {}
+
+		if (where.and) {
+			resultWhere.and = where.and
+				.filter((it): it is Input.Where => !!it)
+				.map(it => this.injectPredicatesToPredicate(it, entity, isBackReferenceContext, ancestorPath, isQueryRoot))
+		}
+		if (where.or) {
+			resultWhere.or = where.or
+				.filter((it): it is Input.Where => !!it)
+				.map(it => this.injectPredicatesToPredicate(it, entity, isBackReferenceContext, ancestorPath, isQueryRoot))
+		}
+		if (where.not) {
+			resultWhere.not = this.injectPredicatesToPredicate(where.not, entity, isBackReferenceContext, ancestorPath, isQueryRoot)
+		}
+
+		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
+
+		for (const field of fields) {
+			resultWhere[field] = acceptFieldVisitor(this.schema, entity, field, {
+				visitColumn: () => where[field],
+				visitRelation: context => {
+					const relationWhere = where[field] as Input.OptionalWhere | null
+					if (relationWhere === null) {
+						return null
+					}
+
+					// Check if this relation is a back-reference to somewhere in our ancestor path
+					const isBackReference = this.findBackReferencedAncestor(
+						ancestorPath,
+						context.relation.name,
+						context.entity.name,
+					) !== undefined
+					const nestedIsBackReferenceContext = isBackReference || isBackReferenceContext
+					const nestedAncestorPath: readonly Model.AnyRelationContext[] = [...ancestorPath, context]
+
+					// Recursively process the nested where (always do this to handle deeper nesting)
+					const processedNestedWhere = this.injectPredicatesToPredicate(
+						relationWhere,
+						context.targetEntity,
+						nestedIsBackReferenceContext,
+						nestedAncestorPath,
+						isQueryRoot,
+					)
+
+					// Check if we should simplify the target entity's predicate
+					const shouldSimplifyNested = nestedIsBackReferenceContext
+						&& this.findBackReferencedAncestor(nestedAncestorPath, context.relation.name, context.entity.name) !== undefined
+
+					// Get target entity's predicate (simplified if back-reference)
+					const targetPredicate = shouldSimplifyNested
+						? { [context.targetEntity.primary]: { always: true } }
+						: this.predicateFactory.create(context.targetEntity, Acl.Operation.read, undefined, context, isQueryRoot)
+
+					// Optimization: avoid duplicate { id: always } when both are simplified
+					const primaryKey = context.targetEntity.primary
+					const nestedIsAlwaysTrue = Object.keys(processedNestedWhere).length === 1
+						&& (processedNestedWhere as Record<string, unknown>)[primaryKey] !== undefined
+						&& (processedNestedWhere as Record<string, Record<string, unknown>>)[primaryKey]?.always === true
+					const targetIsAlwaysTrue = Object.keys(targetPredicate).length === 1
+						&& (targetPredicate as Record<string, unknown>)[primaryKey] !== undefined
+						&& (targetPredicate as Record<string, Record<string, unknown>>)[primaryKey]?.always === true
+
+					if (nestedIsAlwaysTrue && targetIsAlwaysTrue) {
+						return processedNestedWhere
+					}
+
+					// Combine the processed nested where with target entity's predicate
+					const parts = [processedNestedWhere, targetPredicate].filter(it => Object.keys(it).length > 0)
+					if (parts.length === 0) {
+						return {}
+					}
+					if (parts.length === 1) {
+						return parts[0]
+					}
+					return { and: parts }
+				},
+			})
+		}
+
+		return resultWhere
+	}
+
 	private injectToWhere(
 		where: Input.OptionalWhere,
 		entity: Model.Entity,
 		isRoot: boolean,
-		relationContext?: Model.AnyRelationContext,
+		relationContext: Model.AnyRelationContext | undefined,
+		isBackReferenceContext: boolean,
+		ancestorPath: readonly Model.AnyRelationContext[],
+		isQueryRoot?: boolean,
 	): 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, relationContext))
+			resultWhere.and = where.and.filter((it): it is Input.Where => !!it).map(it =>
+				this.injectToWhere(it, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath, isQueryRoot)
+			)
 		}
 		if (where.or) {
-			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it => this.injectToWhere(it, entity, isRoot, relationContext))
+			resultWhere.or = where.or.filter((it): it is Input.Where => !!it).map(it =>
+				this.injectToWhere(it, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath, isQueryRoot)
+			)
 		}
 		if (where.not) {
-			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext)
+			resultWhere.not = this.injectToWhere(where.not, entity, isRoot, relationContext, isBackReferenceContext, ancestorPath, isQueryRoot)
 		}
 
 		const fields = Object.keys(where).filter(it => !['and', 'or', 'not'].includes(it))
@@ -59,15 +210,20 @@ export class PredicatesInjector {
 					if (relationWhere === null) {
 						return null
 					}
-					return this.injectToWhere(relationWhere, context.targetEntity, false, context)
+					// Check if this relation is a back-reference to somewhere in our ancestor path
+					const isBackReference = this.findBackReferencedAncestor(ancestorPath, context.relation.name, context.entity.name) !== undefined
+					// Once we enter a back-reference context, stay in it for nested relations
+					const nestedIsBackReferenceContext = isBackReference || isBackReferenceContext
+					// Build extended ancestor path for nested traversal
+					const nestedAncestorPath: Model.AnyRelationContext[] = [...ancestorPath, context]
+					return this.injectToWhere(relationWhere, context.targetEntity, false, context, nestedIsBackReferenceContext, nestedAncestorPath, isQueryRoot)
 				},
 			})
 		}
 		const fieldsForPredicate = !isRoot
 			? fields
-			: fields.filter(it => this.predicateFactory.shouldApplyCellLevelPredicate(entity, Acl.Operation.read, it))
+			: fields.filter(it => this.predicateFactory.shouldApplyCellLevelPredicate(entity, Acl.Operation.read, it, isQueryRoot))
 
-		return this.createWhere(entity, fieldsForPredicate, resultWhere, relationContext)
+		return this.createWhere(entity, fieldsForPredicate, resultWhere, relationContext, isBackReferenceContext, ancestorPath, isQueryRoot)
 	}
-
 }

package/src/acl/VariableUtils.ts

@@ -1,12 +1,10 @@
 import { Acl, Input } from '@contember/schema'
 import { getRoleVariables, ParsedMembership } from '@contember/schema-utils'
 
-
 export const createAclVariables = (
 	aclSchema: Acl.Schema,
 	memberships: readonly ParsedMembership[],
 ): Acl.VariablesMap => {
-
 	const variablesEntries = memberships.flatMap(
 		membership => {
 			const roleVariables = getRoleVariables(membership.role, aclSchema)

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneReducerExecutionHandler.ts

@@ -7,7 +7,6 @@ import { UniqueWhereExpander } from '../../inputProcessing'
 import { HasManyToHasOneReducerExtension } from './HasManyToHasOneReducer'
 
 export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHandler<Input.UniqueQueryInput, HasManyToHasOneReducerExtension> {
-
 	constructor(private readonly schema: Model.Schema, private readonly uniqueWhereExpander: UniqueWhereExpander) {}
 
 	process(context: SelectExecutionHandlerContext<Input.UniqueQueryInput, HasManyToHasOneReducerExtension>): void {
@@ -18,7 +17,6 @@ export class HasManyToHasOneReducerExecutionHandler implements SelectExecutionHa
 		addData({
 			field: entity.primary,
 			dataProvider: async (ids: Input.PrimaryValue[]) => {
-
 				const relationContext = acceptFieldVisitor(this.schema, entity, objectNode.extensions.relationName, {
 					visitRelation: context => context,
 					visitColumn: (): never => {

package/src/extensions/hasManyToHasOneReducer/HasManyToHasOneRelationReducerVisitor.ts

@@ -11,13 +11,10 @@ type Result = [
 	string,
 	GraphQLFieldConfig<any, any> & {
 		extensions: HasManyToHasOneReducerExtension
-	}
+	},
 ]
 
-export class HasManyToHasOneRelationReducerFieldVisitor implements
-	Model.ColumnVisitor<Result[]>,
-	Model.RelationByTypeVisitor<Result[]> {
-
+export class HasManyToHasOneRelationReducerFieldVisitor implements Model.ColumnVisitor<Result[]>, Model.RelationByTypeVisitor<Result[]> {
 	constructor(
 		private readonly schema: Model.Schema,
 		private readonly authorizator: Authorizator,
@@ -58,10 +55,10 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 		const uniqueKeys: (readonly string[])[] = uniqueConstraints
 			.map(it => it.filter(it => it !== targetRelation.name))
 			.filter(it => it.length > 0)
-			.filter(uniqueKey => uniqueKey
-				.every(it =>
-					acceptFieldVisitor(this.schema, targetEntity.name, it, new FieldAccessVisitor(Acl.Operation.read, this.authorizator)),
-				))
+			.filter(uniqueKey =>
+				uniqueKey
+					.every(it => acceptFieldVisitor(this.schema, targetEntity.name, it, new FieldAccessVisitor(Acl.Operation.read, this.authorizator)))
+			)
 
 		const graphQlName = relation.name + 'By'
 		const uniqueWhere: GraphQLInputObjectType = new GraphQLInputObjectType({
@@ -89,7 +86,7 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 		]
 
 		const composedUnique = uniqueConstraints
-			.filter(fields => fields.length === 2) //todo support all uniques
+			.filter(fields => fields.length === 2) // todo support all uniques
 			.filter(fields => fields.includes(targetRelation.name))
 			.map(fields => fields.filter(it => it !== targetRelation.name))
 			.map(fields => fields[0])
@@ -98,7 +95,6 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 			.map(fields => fields[0])
 			.filter(it => it !== targetRelation.name)
 
-
 		const existing = new Set<string>()
 		return [...composedUnique, ...singleUnique]
 			.filter(field =>
@@ -107,7 +103,7 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 					targetEntity.name,
 					field,
 					new FieldAccessVisitor(Acl.Operation.read, this.authorizator),
-				),
+				)
 			)
 			.map<Result | null>(fieldName => {
 				if (existing.has(fieldName)) {
@@ -116,7 +112,7 @@ export class HasManyToHasOneRelationReducerFieldVisitor implements
 				existing.add(fieldName)
 				const graphQlName = relation.name + GqlTypeName`By${fieldName}`
 				const uniqueWhere: GraphQLInputObjectType = new GraphQLInputObjectType({
-					//todo this can be simplified to ${targetEntity.name}By${fieldName}, but singleton must be used
+					// todo this can be simplified to ${targetEntity.name}By${fieldName}, but singleton must be used
 					name: GqlTypeName`${entity.name}${relation.name}By${fieldName}UniqueWhere`,
 					fields: () => {
 						return this.whereTypeProvider.getUniqueWhereFields(targetEntity, [[fieldName]])

package/src/extensions/paginatedHasMany/PaginatedHasManyCountVisitor.ts

@@ -2,10 +2,9 @@ import { Input, Model } from '@contember/schema'
 import { GroupedCounts, Mapper, RelationFetcher } from '../../mapper'
 import { ObjectNode } from '../../inputProcessing'
 
-export class PaginatedHasManyCountVisitor implements
-	Model.ColumnVisitor<Promise<GroupedCounts>>,
-	Model.RelationByTypeVisitor<Promise<GroupedCounts>> {
-
+export class PaginatedHasManyCountVisitor
+	implements Model.ColumnVisitor<Promise<GroupedCounts>>, Model.RelationByTypeVisitor<Promise<GroupedCounts>>
+{
 	constructor(
 		private readonly ids: Input.PrimaryValue[],
 		private readonly objectNode: ObjectNode<Input.PaginationQueryInput>,

package/src/extensions/paginatedHasMany/PaginatedHasManyExecutionHandler.ts

@@ -29,7 +29,7 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 						entity,
 						objectNode.extensions.relationName,
 						new PaginatedHasManyCountVisitor(ids, objectNode, this.relationFetcher, mapper, context.relationPath),
-					  )
+					)
 					: {}
 
 				const nodes = pagination.nodeField
@@ -38,7 +38,7 @@ export class PaginatedHasManyExecutionHandler implements SelectExecutionHandler<
 						entity,
 						objectNode.extensions.relationName,
 						new PaginatedHasManyNodesVisitor(ids, pagination.nodeField, this.relationFetcher, mapper, context.relationPath),
-					  )
+					)
 					: undefined
 				const result = new Map<Input.PrimaryValue, any>()
 				for (const id of ids) {

package/src/extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor.ts

@@ -9,13 +9,10 @@ type Result = [
 	string,
 	GraphQLFieldConfig<any, any> & {
 		extensions: PaginatedHasManyFieldProviderExtension
-	}
+	},
 ]
 
-export class PaginatedHasManyFieldProviderVisitor implements
-	Model.ColumnVisitor<Result[]>,
-	Model.RelationByTypeVisitor<Result[]> {
-
+export class PaginatedHasManyFieldProviderVisitor implements Model.ColumnVisitor<Result[]>, Model.RelationByTypeVisitor<Result[]> {
 	constructor(private readonly paginatedFieldFactory: PaginatedFieldConfigFactory) {}
 
 	visitOneHasMany({ targetEntity, relation }: Model.OneHasManyContext) {

package/src/extensions/paginatedHasMany/PaginatedHasManyNodesVisitor.ts

@@ -2,10 +2,9 @@ import { Input, Model } from '@contember/schema'
 import { Mapper, RelationFetcher, SelectGroupedObjects } from '../../mapper'
 import { ObjectNode } from '../../inputProcessing'
 
-export class PaginatedHasManyNodesVisitor implements
-	Model.ColumnVisitor<Promise<SelectGroupedObjects>>,
-	Model.RelationByTypeVisitor<Promise<SelectGroupedObjects>> {
-
+export class PaginatedHasManyNodesVisitor
+	implements Model.ColumnVisitor<Promise<SelectGroupedObjects>>, Model.RelationByTypeVisitor<Promise<SelectGroupedObjects>>
+{
 	constructor(
 		private readonly ids: Input.PrimaryValue[],
 		private readonly objectNode: ObjectNode<Input.PaginationQueryInput>,