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

package/src/introspection/content-schema.types.ts

@@ -1,9 +1,8 @@
-import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql'
 export type Maybe<T> = T | null
+export type InputMaybe<T> = Maybe<T>
 export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
 export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
 export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
-export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 /** All built-in and custom scalars, mapped to their actual values */
 export type Scalars = {
 	ID: string
@@ -14,30 +13,29 @@ export type Scalars = {
 	Json: any
 }
 
-
 export type Query = {
 	readonly __typename?: 'Query'
 	readonly schema?: Maybe<_Schema>
 }
 
-export type _Argument = _ValidatorArgument | _PathArgument | _LiteralArgument
+export type _Argument = _LiteralArgument | _PathArgument | _ValidatorArgument
 
 export type _Column = _Field & {
 	readonly __typename?: '_Column'
-	readonly name: Scalars['String']
-	readonly type: Scalars['String']
-	readonly enumName?: Maybe<Scalars['String']>
 	readonly defaultValue?: Maybe<Scalars['Json']>
+	readonly enumName?: Maybe<Scalars['String']>
+	readonly name: Scalars['String']
 	readonly nullable: Scalars['Boolean']
 	readonly rules: ReadonlyArray<_Rule>
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
 export type _Entity = {
 	readonly __typename?: '_Entity'
-	readonly name: Scalars['String']
 	readonly customPrimaryAllowed: Scalars['Boolean']
 	readonly fields: ReadonlyArray<_Field>
+	readonly name: Scalars['String']
 	readonly unique: ReadonlyArray<_UniqueConstraint>
 }
 
@@ -49,9 +47,9 @@ export type _Enum = {
 
 export type _Field = {
 	readonly name: Scalars['String']
-	readonly type: Scalars['String']
 	readonly nullable?: Maybe<Scalars['Boolean']>
 	readonly rules: ReadonlyArray<_Rule>
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
@@ -61,15 +59,15 @@ export type _LiteralArgument = {
 }
 
 export enum _OnDeleteBehaviour {
-	Restrict = 'restrict',
 	Cascade = 'cascade',
+	Restrict = 'restrict',
 	SetNull = 'setNull'
 }
 
 export type _OrderBy = {
 	readonly __typename?: '_OrderBy'
-	readonly path: ReadonlyArray<Scalars['String']>
 	readonly direction: _OrderByDirection
+	readonly path: ReadonlyArray<Scalars['String']>
 }
 
 export enum _OrderByDirection {
@@ -84,23 +82,23 @@ export type _PathArgument = {
 
 export type _Relation = _Field & {
 	readonly __typename?: '_Relation'
-	readonly name: Scalars['String']
-	readonly type: Scalars['String']
-	readonly side: _RelationSide
-	readonly targetEntity: Scalars['String']
-	readonly ownedBy?: Maybe<Scalars['String']>
 	readonly inversedBy?: Maybe<Scalars['String']>
+	readonly name: Scalars['String']
 	readonly nullable?: Maybe<Scalars['Boolean']>
 	readonly onDelete?: Maybe<_OnDeleteBehaviour>
-	readonly orphanRemoval?: Maybe<Scalars['Boolean']>
 	readonly orderBy?: Maybe<ReadonlyArray<_OrderBy>>
+	readonly orphanRemoval?: Maybe<Scalars['Boolean']>
+	readonly ownedBy?: Maybe<Scalars['String']>
 	readonly rules: ReadonlyArray<_Rule>
+	readonly side: _RelationSide
+	readonly targetEntity: Scalars['String']
+	readonly type: Scalars['String']
 	readonly validators: ReadonlyArray<_Validator>
 }
 
 export enum _RelationSide {
-	Owning = 'owning',
-	Inverse = 'inverse'
+	Inverse = 'inverse',
+	Owning = 'owning'
 }
 
 export type _Rule = {
@@ -116,8 +114,8 @@ export type _RuleMessage = {
 
 export type _Schema = {
 	readonly __typename?: '_Schema'
-	readonly enums: ReadonlyArray<_Enum>
 	readonly entities: ReadonlyArray<_Entity>
+	readonly enums: ReadonlyArray<_Enum>
 }
 
 export type _UniqueConstraint = {
@@ -127,276 +125,11 @@ export type _UniqueConstraint = {
 
 export type _Validator = {
 	readonly __typename?: '_Validator'
-	readonly operation: Scalars['String']
 	readonly arguments: ReadonlyArray<_Argument>
+	readonly operation: Scalars['String']
 }
 
 export type _ValidatorArgument = {
 	readonly __typename?: '_ValidatorArgument'
 	readonly validator: Scalars['Int']
 }
-
-
-
-export type ResolverTypeWrapper<T> = Promise<T> | T
-
-
-export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
-	fragment: string
-	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
-}
-
-export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
-	selectionSet: string
-	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
-}
-export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>
-export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
-  | ResolverFn<TResult, TParent, TContext, TArgs>
-  | StitchingResolver<TResult, TParent, TContext, TArgs>
-
-export type ResolverFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => Promise<TResult> | TResult
-
-export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>
-
-export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => TResult | Promise<TResult>
-
-export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
-	subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>
-	resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>
-}
-
-export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
-	subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>
-	resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>
-}
-
-export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
-  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
-  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>
-
-export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
-  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
-  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>
-
-export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
-	parent: TParent,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => Maybe<TTypes> | Promise<Maybe<TTypes>>
-
-export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>
-
-export type NextResolverFn<T> = () => Promise<T>
-
-export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
-	next: NextResolverFn<TResult>,
-	parent: TParent,
-	args: TArgs,
-	context: TContext,
-	info: GraphQLResolveInfo
-) => TResult | Promise<TResult>
-
-/** Mapping between all available schema types and the resolvers types */
-export type ResolversTypes = {
-	Json: ResolverTypeWrapper<Scalars['Json']>
-	Query: ResolverTypeWrapper<{}>
-	_Argument: ResolversTypes['_ValidatorArgument'] | ResolversTypes['_PathArgument'] | ResolversTypes['_LiteralArgument']
-	_Column: ResolverTypeWrapper<_Column>
-	String: ResolverTypeWrapper<Scalars['String']>
-	Boolean: ResolverTypeWrapper<Scalars['Boolean']>
-	_Entity: ResolverTypeWrapper<_Entity>
-	_Enum: ResolverTypeWrapper<_Enum>
-	_Field: ResolversTypes['_Column'] | ResolversTypes['_Relation']
-	_LiteralArgument: ResolverTypeWrapper<_LiteralArgument>
-	_OnDeleteBehaviour: _OnDeleteBehaviour
-	_OrderBy: ResolverTypeWrapper<_OrderBy>
-	_OrderByDirection: _OrderByDirection
-	_PathArgument: ResolverTypeWrapper<_PathArgument>
-	_Relation: ResolverTypeWrapper<_Relation>
-	_RelationSide: _RelationSide
-	_Rule: ResolverTypeWrapper<_Rule>
-	Int: ResolverTypeWrapper<Scalars['Int']>
-	_RuleMessage: ResolverTypeWrapper<_RuleMessage>
-	_Schema: ResolverTypeWrapper<_Schema>
-	_UniqueConstraint: ResolverTypeWrapper<_UniqueConstraint>
-	_Validator: ResolverTypeWrapper<Omit<_Validator, 'arguments'> & { arguments: ReadonlyArray<ResolversTypes['_Argument']> }>
-	_ValidatorArgument: ResolverTypeWrapper<_ValidatorArgument>
-}
-
-/** Mapping between all available schema types and the resolvers parents */
-export type ResolversParentTypes = {
-	Json: Scalars['Json']
-	Query: {}
-	_Argument: ResolversParentTypes['_ValidatorArgument'] | ResolversParentTypes['_PathArgument'] | ResolversParentTypes['_LiteralArgument']
-	_Column: _Column
-	String: Scalars['String']
-	Boolean: Scalars['Boolean']
-	_Entity: _Entity
-	_Enum: _Enum
-	_Field: ResolversParentTypes['_Column'] | ResolversParentTypes['_Relation']
-	_LiteralArgument: _LiteralArgument
-	_OrderBy: _OrderBy
-	_PathArgument: _PathArgument
-	_Relation: _Relation
-	_Rule: _Rule
-	Int: Scalars['Int']
-	_RuleMessage: _RuleMessage
-	_Schema: _Schema
-	_UniqueConstraint: _UniqueConstraint
-	_Validator: Omit<_Validator, 'arguments'> & { arguments: ReadonlyArray<ResolversParentTypes['_Argument']> }
-	_ValidatorArgument: _ValidatorArgument
-}
-
-export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Json'], any> {
-	name: 'Json'
-}
-
-export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
-	schema?: Resolver<Maybe<ResolversTypes['_Schema']>, ParentType, ContextType>
-}
-
-export type _ArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Argument'] = ResolversParentTypes['_Argument']> = {
-	__resolveType: TypeResolveFn<'_ValidatorArgument' | '_PathArgument' | '_LiteralArgument', ParentType, ContextType>
-}
-
-export type _ColumnResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Column'] = ResolversParentTypes['_Column']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	enumName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	defaultValue?: Resolver<Maybe<ResolversTypes['Json']>, ParentType, ContextType>
-	nullable?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _EntityResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Entity'] = ResolversParentTypes['_Entity']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	customPrimaryAllowed?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
-	fields?: Resolver<ReadonlyArray<ResolversTypes['_Field']>, ParentType, ContextType>
-	unique?: Resolver<ReadonlyArray<ResolversTypes['_UniqueConstraint']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _EnumResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Enum'] = ResolversParentTypes['_Enum']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	values?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _FieldResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Field'] = ResolversParentTypes['_Field']> = {
-	__resolveType: TypeResolveFn<'_Column' | '_Relation', ParentType, ContextType>
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	nullable?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-}
-
-export type _LiteralArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_LiteralArgument'] = ResolversParentTypes['_LiteralArgument']> = {
-	value?: Resolver<Maybe<ResolversTypes['Json']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _OrderByResolvers<ContextType = any, ParentType extends ResolversParentTypes['_OrderBy'] = ResolversParentTypes['_OrderBy']> = {
-	path?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	direction?: Resolver<ResolversTypes['_OrderByDirection'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _PathArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_PathArgument'] = ResolversParentTypes['_PathArgument']> = {
-	path?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RelationResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Relation'] = ResolversParentTypes['_Relation']> = {
-	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	type?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	side?: Resolver<ResolversTypes['_RelationSide'], ParentType, ContextType>
-	targetEntity?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	ownedBy?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	inversedBy?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	nullable?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	onDelete?: Resolver<Maybe<ResolversTypes['_OnDeleteBehaviour']>, ParentType, ContextType>
-	orphanRemoval?: Resolver<Maybe<ResolversTypes['Boolean']>, ParentType, ContextType>
-	orderBy?: Resolver<Maybe<ReadonlyArray<ResolversTypes['_OrderBy']>>, ParentType, ContextType>
-	rules?: Resolver<ReadonlyArray<ResolversTypes['_Rule']>, ParentType, ContextType>
-	validators?: Resolver<ReadonlyArray<ResolversTypes['_Validator']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RuleResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Rule'] = ResolversParentTypes['_Rule']> = {
-	message?: Resolver<Maybe<ResolversTypes['_RuleMessage']>, ParentType, ContextType>
-	validator?: Resolver<ResolversTypes['Int'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _RuleMessageResolvers<ContextType = any, ParentType extends ResolversParentTypes['_RuleMessage'] = ResolversParentTypes['_RuleMessage']> = {
-	text?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _SchemaResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Schema'] = ResolversParentTypes['_Schema']> = {
-	enums?: Resolver<ReadonlyArray<ResolversTypes['_Enum']>, ParentType, ContextType>
-	entities?: Resolver<ReadonlyArray<ResolversTypes['_Entity']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _UniqueConstraintResolvers<ContextType = any, ParentType extends ResolversParentTypes['_UniqueConstraint'] = ResolversParentTypes['_UniqueConstraint']> = {
-	fields?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _ValidatorResolvers<ContextType = any, ParentType extends ResolversParentTypes['_Validator'] = ResolversParentTypes['_Validator']> = {
-	operation?: Resolver<ResolversTypes['String'], ParentType, ContextType>
-	arguments?: Resolver<ReadonlyArray<ResolversTypes['_Argument']>, ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type _ValidatorArgumentResolvers<ContextType = any, ParentType extends ResolversParentTypes['_ValidatorArgument'] = ResolversParentTypes['_ValidatorArgument']> = {
-	validator?: Resolver<ResolversTypes['Int'], ParentType, ContextType>
-	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
-}
-
-export type Resolvers<ContextType = any> = {
-	Json?: GraphQLScalarType
-	Query?: QueryResolvers<ContextType>
-	_Argument?: _ArgumentResolvers<ContextType>
-	_Column?: _ColumnResolvers<ContextType>
-	_Entity?: _EntityResolvers<ContextType>
-	_Enum?: _EnumResolvers<ContextType>
-	_Field?: _FieldResolvers<ContextType>
-	_LiteralArgument?: _LiteralArgumentResolvers<ContextType>
-	_OrderBy?: _OrderByResolvers<ContextType>
-	_PathArgument?: _PathArgumentResolvers<ContextType>
-	_Relation?: _RelationResolvers<ContextType>
-	_Rule?: _RuleResolvers<ContextType>
-	_RuleMessage?: _RuleMessageResolvers<ContextType>
-	_Schema?: _SchemaResolvers<ContextType>
-	_UniqueConstraint?: _UniqueConstraintResolvers<ContextType>
-	_Validator?: _ValidatorResolvers<ContextType>
-	_ValidatorArgument?: _ValidatorArgumentResolvers<ContextType>
-}
-
-
-/**
- * @deprecated
- * Use "Resolvers" root object instead. If you wish to get "IResolvers", add "typesPrefix: I" to your config.
- */
-export type IResolvers<ContextType = any> = Resolvers<ContextType>

package/src/mapper/Mapper.ts

@@ -56,15 +56,17 @@ export class Mapper {
 		return result[0] !== undefined ? result[0][columnName] : undefined
 	}
 
-	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>): Promise<SelectResultObject[]>
+	public async select(entity: Model.Entity, input: ObjectNode<Input.ListQueryInput>, overRelation: Model.AnyRelation | null): Promise<SelectResultObject[]>
 	public async select(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
+		overRelation: Model.AnyRelation | null,
 		indexBy: string,
 	): Promise<SelectIndexedResultObjects>
 	public async select(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
+		overRelation: Model.AnyRelation | null,
 		indexBy?: string,
 	): Promise<SelectResultObject[] | SelectIndexedResultObjects> {
 		const hydrator = new SelectHydrator()
@@ -75,7 +77,7 @@ export class Mapper {
 			indexByAlias = path.for(indexBy).alias
 			qb = qb.select([path.alias, getColumnName(this.schema, entity, indexBy)], indexByAlias)
 		}
-		const rows = await this.selectRows(hydrator, qb, entity, input)
+		const rows = await this.selectRows(hydrator, qb, entity, input, overRelation)
 
 		return await (indexByAlias !== null ? hydrator.hydrateAll(rows, indexByAlias) : hydrator.hydrateAll(rows))
 	}
@@ -83,18 +85,19 @@ export class Mapper {
 	public async selectUnique(
 		entity: Model.Entity,
 		query: ObjectNode<Input.UniqueQueryInput>,
+		overRelation: Model.AnyRelation | null,
 	): Promise<SelectResultObject | null> {
 		const uniqueWhere = this.uniqueWhereExpander.expand(entity, query.args.by)
 		const where = query.args.filter ? { and: [uniqueWhere, query.args.filter] } : uniqueWhere
 		const queryExpanded = query.withArg<Input.ListQueryInput>('filter', where)
 
-		return (await this.select(entity, queryExpanded))[0] || null
+		return (await this.select(entity, queryExpanded, overRelation))[0] || null
 	}
 
 	public async selectGrouped(
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
-		relation: Model.JoiningColumnRelation & Model.Relation,
+		relation: Model.JoiningColumnRelation & Model.AnyRelation,
 	) {
 		const hydrator = new SelectHydrator()
 		let qb: SelectBuilder<SelectBuilder.Result> = SelectBuilder.create()
@@ -102,7 +105,7 @@ export class Mapper {
 		const groupingKey = '__grouping_key'
 		qb = qb.select([path.alias, relation.joiningColumn.columnName], groupingKey)
 
-		const rows = await this.selectRows(hydrator, qb, entity, input, relation.name)
+		const rows = await this.selectRows(hydrator, qb, entity, input, relation, relation.name)
 		return await hydrator.hydrateGroups(rows, groupingKey)
 	}
 
@@ -111,6 +114,7 @@ export class Mapper {
 		qb: SelectBuilder<SelectBuilder.Result>,
 		entity: Model.Entity,
 		input: ObjectNode<Input.ListQueryInput>,
+		overRelation: Model.AnyRelation | null,
 		groupBy?: string,
 	) {
 		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, [])
@@ -118,7 +122,7 @@ export class Mapper {
 		const augmentedBuilder = qb.from(entity.tableName, path.alias).meta('path', [...input.path, input.alias])
 
 		const selector = this.selectBuilderFactory.create(augmentedBuilder, hydrator)
-		const filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {})
+		const filterWithPredicates = this.predicatesInjector.inject(entity, inputWithOrder.args.filter || {}, overRelation ?? undefined)
 		const inputWithPredicates = inputWithOrder.withArg('filter', filterWithPredicates)
 		selector.select(this, entity, inputWithPredicates, path, groupBy)
 		return await selector.execute(this.db)

package/src/mapper/MapperContainer.ts

@@ -32,6 +32,8 @@ import { Client, SelectBuilder as DbSelectBuilder } from '@contember/database'
 import { Providers } from '@contember/schema-utils'
 import { PaginatedHasManyExecutionHandler } from '../extensions/paginatedHasMany/PaginatedHasManyExecutionHandler'
 import { PaginatedHasManyFieldProvider } from '../extensions/paginatedHasMany/PaginatedHasManyFieldProvider'
+import { WhereOptimizer } from './select/optimizer/WhereOptimizer'
+import { ConditionOptimizer } from './select/optimizer/ConditionOptimizer'
 
 type MapperContainerArgs = {
 	schema: Schema
@@ -51,7 +53,7 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 		.addService('variableInjector', () =>
 			new VariableInjector(schema.model, identityVariables))
 		.addService('predicateFactory', ({ variableInjector }) =>
-			new PredicateFactory(permissions, variableInjector))
+			new PredicateFactory(permissions, schema.model, variableInjector))
 		.addService('predicatesInjector', ({ predicateFactory }) =>
 			new PredicatesInjector(schema.model, predicateFactory))
 		.addService('joinBuilder', () =>
@@ -60,8 +62,10 @@ export const createMapperContainer = ({ permissions, schema, identityVariables,
 			new ConditionBuilder())
 		.addService('pathFactory', () =>
 			new PathFactory())
-		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory }) =>
-			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory))
+		.addService('whereOptimized', () =>
+			new WhereOptimizer(schema.model, new ConditionOptimizer()))
+		.addService('whereBuilder', ({ joinBuilder, conditionBuilder, pathFactory, whereOptimized }) =>
+			new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimized))
 		.addService('orderByBuilder', ({ joinBuilder }) =>
 			new OrderByBuilder(schema.model, joinBuilder))
 		.addService('relationFetcher', ({ whereBuilder, orderByBuilder, predicatesInjector, pathFactory }) =>

package/src/mapper/select/RelationFetcher.ts

@@ -12,6 +12,52 @@ import { Mapper } from '../Mapper'
 
 export type GroupedCounts = Record<Input.PrimaryValue, number>
 
+type CountOneHasManyGroupsArgs = {
+	mapper: Mapper
+	filter: Input.OptionalWhere | undefined
+	targetEntity: Model.Entity
+	targetRelation: Model.ManyHasOneRelation
+	ids: Input.PrimaryValue[]
+}
+
+type FetchOneHasManyGroupsArgs = {
+	mapper: Mapper
+	objectNode: ObjectNode<Input.ListQueryInput>
+	targetEntity: Model.Entity
+	relation: Model.OneHasManyRelation
+	targetRelation: Model.ManyHasOneRelation
+	ids: Input.PrimaryValue[]
+}
+
+type ManyHasManyBaseArgs =
+	& {
+		mapper: Mapper
+		targetEntity: Model.Entity
+		ids: Input.PrimaryValue[]
+	} & (
+		| {
+			directionFrom: 'owning'
+			sourceRelation: Model.ManyHasManyOwningRelation
+			targetRelation: Model.ManyHasManyInverseRelation | null
+		}
+		| {
+			directionFrom: 'inverse'
+			sourceRelation: Model.ManyHasManyInverseRelation
+			targetRelation: Model.ManyHasManyOwningRelation
+		}
+	)
+type CountManyHasManyGroupArgs =
+	& ManyHasManyBaseArgs
+	& {
+		filter: Input.OptionalWhere | undefined
+	}
+
+type FetchManyHasManyGroupsArgs =
+	& ManyHasManyBaseArgs
+	& {
+		field: ObjectNode<Input.ListQueryInput>
+	}
+
 export class RelationFetcher {
 	constructor(
 		private readonly whereBuilder: WhereBuilder,
@@ -20,25 +66,25 @@ export class RelationFetcher {
 		private readonly pathFactory: PathFactory,
 	) {}
 
-	public async countOneHasManyGroups(
-		mapper: Mapper,
-		filter: Input.OptionalWhere | undefined,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-		ids: Input.PrimaryValue[],
-	): Promise<GroupedCounts> {
+	public async countOneHasManyGroups({
+		mapper,
+		filter,
+		targetEntity,
+		targetRelation,
+		ids,
+	}: CountOneHasManyGroupsArgs): Promise<GroupedCounts> {
 		const filterWithParent = this.createOneHasManyFilter(targetEntity, targetRelation, ids, filter)
 		return mapper.countGrouped(targetEntity, filterWithParent, targetRelation)
 	}
 
-	public async fetchOneHasManyGroups(
-		mapper: Mapper,
-		objectNode: ObjectNode<Input.ListQueryInput>,
-		targetEntity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetRelation: Model.ManyHasOneRelation,
-		ids: Input.PrimaryValue[],
-	): Promise<SelectGroupedObjects> {
+	public async fetchOneHasManyGroups({
+		mapper,
+		objectNode,
+		targetEntity,
+		relation,
+		targetRelation,
+		ids,
+	}: FetchOneHasManyGroupsArgs): Promise<SelectGroupedObjects> {
 		const filter = this.createOneHasManyFilter(targetEntity, targetRelation, ids, objectNode.args.filter)
 		const objectNodeWithWhere = objectNode.withArg<Input.ListQueryInput>('filter', filter)
 		const objectNodeWithOrder = OrderByHelper.appendDefaultOrderBy(
@@ -65,14 +111,17 @@ export class RelationFetcher {
 		}
 	}
 
-	public async countManyHasManyGroups(
-		mapper: Mapper,
-		filter: Input.OptionalWhere | undefined,
-		targetEntity: Model.Entity,
-		owningRelation: Model.ManyHasManyOwningRelation,
-		ids: Input.PrimaryValue[],
-		joiningColumns: JoiningColumns,
-	): Promise<GroupedCounts> {
+	public async countManyHasManyGroups({
+		mapper,
+		filter,
+		targetEntity,
+		directionFrom,
+		sourceRelation,
+		targetRelation,
+		ids,
+	}: CountManyHasManyGroupArgs): Promise<GroupedCounts> {
+		const owningRelation = directionFrom === 'owning' ? sourceRelation : targetRelation
+		const joiningColumns = this.resolveJoiningColumns({ directionFrom, owningRelation })
 		const qb = this.buildJunctionQb(owningRelation, ids, joiningColumns, targetEntity, { filter })
 			.select(['junction_', joiningColumns.sourceColumn.columnName])
 			.select(expr => expr.raw('count(*)'), 'row_count')
@@ -85,16 +134,18 @@ export class RelationFetcher {
 		return Object.fromEntries(result)
 	}
 
-	public async fetchManyHasManyGroups(
-		mapper: Mapper,
-		field: ObjectNode<Input.ListQueryInput>,
-		targetEntity: Model.Entity,
-		fromRelation: Model.ManyHasManyOwningRelation | Model.ManyHasManyInverseRelation,
-		owningRelation: Model.ManyHasManyOwningRelation,
-		joiningColumns: JoiningColumns,
-		ids: Input.PrimaryValue[],
-	): Promise<SelectGroupedObjects> {
-		const defaultOrderBy = fromRelation.orderBy || []
+	public async fetchManyHasManyGroups({
+		mapper,
+		field,
+		sourceRelation,
+		targetEntity,
+		targetRelation,
+		directionFrom,
+		ids,
+	}: FetchManyHasManyGroupsArgs): Promise<SelectGroupedObjects> {
+		const owningRelation = directionFrom === 'owning' ? sourceRelation : targetRelation
+		const joiningColumns = this.resolveJoiningColumns({ directionFrom, owningRelation })
+		const defaultOrderBy = sourceRelation.orderBy || []
 		const objectNode = OrderByHelper.appendDefaultOrderBy(targetEntity, field, defaultOrderBy)
 
 		const junctionValues = await this.fetchJunction(
@@ -122,11 +173,21 @@ export class RelationFetcher {
 				},
 			})
 			.withField(primaryField)
-		const result = await mapper.select(targetEntity, queryWithWhere)
+		const result = await mapper.select(targetEntity, queryWithWhere, targetRelation)
 
 		return this.buildManyHasManyGroups(targetEntity, joiningColumns, result, junctionValues)
 	}
 
+	private resolveJoiningColumns({ directionFrom, owningRelation }: { owningRelation: Model.ManyHasManyOwningRelation; directionFrom: 'owning' | 'inverse' }): JoiningColumns {
+		return directionFrom === 'owning' ? {
+			sourceColumn: owningRelation.joiningTable.joiningColumn,
+			targetColumn: owningRelation.joiningTable.inverseJoiningColumn,
+		} : {
+			sourceColumn: owningRelation.joiningTable.inverseJoiningColumn,
+			targetColumn: owningRelation.joiningTable.joiningColumn,
+		}
+	}
+
 	private buildManyHasManyGroups(
 		entity: Model.Entity,
 		joiningColumns: JoiningColumns,