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

package/src/mapper/select/WhereBuilder.ts

@@ -1,10 +1,17 @@
 import { isIt } from '../../utils'
-import { acceptFieldVisitor } from '@contember/schema-utils'
+import { acceptFieldVisitor, isColumn } from '@contember/schema-utils'
 import { Input, Model } from '@contember/schema'
 import { Path, PathFactory } from './Path'
 import { JoinBuilder } from './JoinBuilder'
 import { ConditionBuilder } from './ConditionBuilder'
-import { ConditionBuilder as SqlConditionBuilder, Operator, QueryBuilder, SelectBuilder } from '@contember/database'
+import {
+	ConditionBuilder as SqlConditionBuilder,
+	Literal,
+	Operator,
+	QueryBuilder,
+	SelectBuilder, wrapIdentifier,
+} from '@contember/database'
+import { WhereOptimizer } from './optimizer/WhereOptimizer'
 
 export class WhereBuilder {
 	constructor(
@@ -12,6 +19,7 @@ export class WhereBuilder {
 		private readonly joinBuilder: JoinBuilder,
 		private readonly conditionBuilder: ConditionBuilder,
 		private readonly pathFactory: PathFactory,
+		private readonly whereOptimizer: WhereOptimizer,
 	) {}
 
 	public build(
@@ -19,28 +27,41 @@ export class WhereBuilder {
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
-		allowManyJoin: boolean = false,
+		relationPath: Model.AnyRelationContext[] = [],
 	) {
-		return this.buildAdvanced(entity, path, where, cb => qb.where(clause => cb(clause)), allowManyJoin)
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity, relationPath)
+		return this.buildInternal(entity, path, optimizedWhere, cb => qb.where(clause => cb(clause)), false)
 	}
 
+
 	public buildAdvanced(
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
 		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
-		allowManyJoin: boolean = false,
+		relationPath: Model.AnyRelationContext[] = [],
+	) {
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity, relationPath)
+		return this.buildInternal(entity, path, optimizedWhere, callback, false)
+	}
+
+	private buildInternal(
+		entity: Model.Entity,
+		path: Path,
+		where: Input.OptionalWhere,
+		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
+		allowManyJoin: boolean,
 	) {
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildInternal(clause, entity, path, where, allowManyJoin, joinList))
+		const qbWithWhere = callback(clause => this.buildRecursive(clause, entity, path, where, allowManyJoin, joinList))
 		return joinList.reduce<SelectBuilder<SelectBuilder.Result>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join(qb, path, entity, relationName),
 			qbWithWhere,
 		)
 	}
 
-	private buildInternal(
+	private buildRecursive(
 		conditionBuilder: SqlConditionBuilder,
 		entity: Model.Entity,
 		path: Path,
@@ -55,7 +76,7 @@ export class WhereBuilder {
 			conditionBuilder = conditionBuilder.and(clause =>
 				expr.reduce(
 					(clause2, where) =>
-						!where ? clause2 : this.buildInternal(clause2, entity, path, where, allowManyJoin, joinList),
+						!where ? clause2 : this.buildRecursive(clause2, entity, path, where, allowManyJoin, joinList),
 					clause,
 				),
 			)
@@ -67,7 +88,7 @@ export class WhereBuilder {
 					(clause2, where) =>
 						!where
 							? clause2
-							: clause2.and(clause3 => this.buildInternal(clause3, entity, path, where, allowManyJoin, joinList)),
+							: clause2.and(clause3 => this.buildRecursive(clause3, entity, path, where, allowManyJoin, joinList)),
 					clause,
 				),
 			)
@@ -75,7 +96,7 @@ export class WhereBuilder {
 		if (where.not !== undefined) {
 			const expr = where.not
 			conditionBuilder = conditionBuilder.not(clause =>
-				this.buildInternal(clause, entity, path, expr, allowManyJoin, joinList),
+				this.buildRecursive(clause, entity, path, expr, allowManyJoin, joinList),
 			)
 		}
 
@@ -84,11 +105,7 @@ export class WhereBuilder {
 				continue
 			}
 
-			const joinedWhere = (
-				entity: Model.Entity,
-				relation: Model.Relation,
-				targetEntity: Model.Entity,
-			): SqlConditionBuilder => {
+			const joinedWhere = ({ targetEntity, relation, entity }: Model.AnyRelationContext): SqlConditionBuilder => {
 				const targetPath = path.for(fieldName)
 				const relationWhere = where[fieldName] as Input.Where
 				if (Object.keys(relationWhere).length === 0) {
@@ -109,36 +126,37 @@ export class WhereBuilder {
 
 				joinList.push({ path: targetPath, entity, relationName: relation.name })
 
-				return this.buildInternal(conditionBuilder, targetEntity, targetPath, relationWhere, allowManyJoin, joinList)
+				return this.buildRecursive(conditionBuilder, targetEntity, targetPath, relationWhere, allowManyJoin, joinList)
 			}
 
 			conditionBuilder = acceptFieldVisitor<SqlConditionBuilder>(this.schema, entity, fieldName, {
-				visitColumn: (entity, column) => {
+				visitColumn: ({ entity, column }) => {
 					const subWhere: Input.Condition<Input.ColumnValue> = where[column.name] as Input.Condition<Input.ColumnValue>
 					return this.conditionBuilder.build(conditionBuilder, tableName, column.columnName, column.columnType, subWhere)
 				},
 				visitOneHasOneInverse: joinedWhere,
 				visitOneHasOneOwning: joinedWhere,
 				visitManyHasOne: joinedWhere,
-				visitManyHasManyInverse: (entity, relation, targetEntity, targetRelation) => {
+				visitManyHasManyInverse: context => {
 					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+						return joinedWhere(context)
 					}
+
 					const relationWhere = where[fieldName] as Input.Where
 
 					return conditionBuilder.exists(
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
 							relationWhere,
-							targetEntity,
-							targetRelation.joiningTable,
+							context.targetEntity,
+							context.targetRelation.joiningTable,
 							'inverse',
 						),
 					)
 				},
-				visitManyHasManyOwning: (entity, relation, targetEntity) => {
+				visitManyHasManyOwning: context => {
 					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+						return joinedWhere(context)
 					}
 
 					const relationWhere = where[fieldName] as Input.Where
@@ -147,28 +165,37 @@ export class WhereBuilder {
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
 							relationWhere,
-							targetEntity,
-							relation.joiningTable,
+							context.targetEntity,
+							context.relation.joiningTable,
 							'owning',
 						),
 					)
 				},
-				visitOneHasMany: (entity, relation, targetEntity, targetRelation) => {
+				visitOneHasMany: context => {
 					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+						return joinedWhere(context)
 					}
 
 					const relationWhere = where[fieldName] as Input.Where
 
+					const qb = this.hasRootIsNull(relationWhere, context.targetEntity)
+						? SelectBuilder.create()
+							.select(it => it.raw('1'))
+							.from(new Literal(`(select ${wrapIdentifier(tableName)}.${wrapIdentifier(entity.primaryColumn)})`), 'sub2_')
+							.leftJoin(context.targetEntity.tableName, 'sub_', it =>
+								it.columnsEq(['sub2_', entity.primaryColumn], ['sub_', context.targetRelation.joiningColumn.columnName]),
+							)
+						: SelectBuilder.create()
+							.select(it => it.raw('1'))
+							.from(context.targetEntity.tableName, 'sub_')
+							.where(it => it.columnsEq([tableName, entity.primaryColumn], ['sub_', context.targetRelation.joiningColumn.columnName]))
+
 					return conditionBuilder.exists(
-						this.build(
-							SelectBuilder.create()
-								.select(it => it.raw('1'))
-								.from(targetEntity.tableName, 'sub_')
-								.where(it => it.columnsEq([tableName, entity.primaryColumn], ['sub_', targetRelation.joiningColumn.columnName])),
-							targetEntity,
+						this.buildInternal(
+							context.targetEntity,
 							this.pathFactory.create([], 'sub_'),
 							relationWhere,
+							cb => qb.where(clause => cb(clause)),
 							true,
 						),
 					)
@@ -178,6 +205,7 @@ export class WhereBuilder {
 		return conditionBuilder
 	}
 
+
 	private createManyHasManySubquery(
 		outerColumn: QueryBuilder.ColumnIdentifier,
 		relationWhere: Input.Where,
@@ -205,7 +233,7 @@ export class WhereBuilder {
 		const qbJoined = qb.join(targetEntity.tableName, 'sub_', clause =>
 			clause.compareColumns(['junction_', toColumn], Operator.eq, ['sub_', targetEntity.primary]),
 		)
-		return this.buildAdvanced(
+		return this.buildInternal(
 			targetEntity,
 			this.pathFactory.create([], 'sub_'),
 			relationWhere,
@@ -257,6 +285,39 @@ export class WhereBuilder {
 		}
 		return condition
 	}
+
+	private hasRootIsNull(where: Input.Where, entity: Model.Entity): boolean {
+		for (const key in where) {
+			if (key === 'and' || key === 'or') {
+				if (where[key]?.some(it => this.hasRootIsNull(it, entity))) {
+					return true
+				}
+			} else if (key === 'not') {
+				if (where.not && this.hasRootIsNull(where.not, entity)) {
+					return true
+				}
+			} else if (isColumn(entity.fields[key]) && this.conditionHasIsNull(where[key] as Input.Condition)) {
+				return true
+			}
+		}
+		return false
+	}
+
+	private conditionHasIsNull(cond: Input.Condition): boolean {
+		if (cond.isNull !== undefined) {
+			return true
+		}
+		if (cond.and && cond.and.some(it => this.conditionHasIsNull(it))) {
+			return true
+		}
+		if (cond.or && cond.or.some(it => this.conditionHasIsNull(it))) {
+			return true
+		}
+		if (cond.not && this.conditionHasIsNull(cond.not)) {
+			return true
+		}
+		return false
+	}
 }
 
 export type WhereJoinDefinition = { path: Path; entity: Model.Entity; relationName: string }

package/src/mapper/select/handlers/FieldsVisitor.ts

@@ -4,7 +4,6 @@ import { RelationFetcher } from '../RelationFetcher'
 import { SelectExecutionHandlerContext } from '../SelectExecutionHandler'
 import { PredicateFactory } from '../../../acl'
 import { WhereBuilder } from '../WhereBuilder'
-import { JoiningColumns } from '../../types'
 
 export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.ColumnVisitor<void> {
 	constructor(
@@ -14,9 +13,10 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		private readonly whereBuilder: WhereBuilder,
 		private readonly mapper: Mapper,
 		private readonly executionContext: SelectExecutionHandlerContext,
+		private readonly relationPath: Model.AnyRelationContext[],
 	) {}
 
-	visitColumn(entity: Model.Entity, column: Model.AnyColumn): void {
+	visitColumn({ entity, column }: Model.ColumnContext): void {
 		const columnPath = this.executionContext.path
 		this.executionContext.addColumn(qb => {
 			const tableAlias = columnPath.back().alias
@@ -50,85 +50,69 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		})
 	}
 
-	public visitManyHasManyInverse(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasManyOwningRelation,
-	): void {
-		const joiningTable = targetRelation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.inverseJoiningColumn,
-			targetColumn: joiningTable.joiningColumn,
-		}
+	public visitManyHasManyInverse(relationContext: Model.ManyHasManyInverseContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
 		this.executionContext.addData(
-			entity.primary,
+			relationContext.entity.primary,
 			async ids =>
 				this.relationFetcher.fetchManyHasManyGroups(
-					this.mapper,
-					field,
-					targetEntity,
-					relation,
-					targetRelation,
-					columns,
-					ids,
+					{
+						mapper: this.mapper,
+						field: field,
+						relationContext,
+						relationPath: this.relationPath,
+						ids: ids,
+					},
 				),
 			[],
 		)
 	}
 
-	public visitManyHasManyOwning(
-		entity: Model.Entity,
-		relation: Model.ManyHasManyOwningRelation,
-		targetEntity: Model.Entity,
-	): void {
-		const joiningTable = relation.joiningTable
-		const columns: JoiningColumns = {
-			sourceColumn: joiningTable.joiningColumn,
-			targetColumn: joiningTable.inverseJoiningColumn,
-		}
+	public visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
 
 		this.executionContext.addData(
-			entity.primary,
+			relationContext.entity.primary,
 			async ids =>
-				this.relationFetcher.fetchManyHasManyGroups(this.mapper, field, targetEntity, relation, relation, columns, ids),
+				this.relationFetcher.fetchManyHasManyGroups({
+					mapper: this.mapper,
+					field: field,
+					relationContext,
+					relationPath: this.relationPath,
+					ids: ids,
+				}),
 			[],
 		)
 	}
 
-	public visitOneHasMany(
-		entity: Model.Entity,
-		relation: Model.OneHasManyRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.ManyHasOneRelation,
-	): void {
+	public visitOneHasMany(relationContext: Model.OneHasManyContext): void {
 		const field = this.executionContext.objectNode
 		if (!field) {
 			throw new Error()
 		}
 
 		this.executionContext.addData(
-			entity.primary,
+			relationContext.entity.primary,
 			async ids =>
-				this.relationFetcher.fetchOneHasManyGroups(this.mapper, field, targetEntity, relation, targetRelation, ids),
+				this.relationFetcher.fetchOneHasManyGroups({
+					mapper: this.mapper,
+					objectNode: field,
+					relationContext,
+					relationPath: this.relationPath,
+					ids: ids,
+				}),
 			[],
 		)
 	}
 
-	public visitOneHasOneInverse(
-		entity: Model.Entity,
-		relation: Model.OneHasOneInverseRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneOwningRelation,
-	): void {
+	public visitOneHasOneInverse(relationContext: Model.OneHasOneInverseContext): void {
+		const { entity, targetRelation, targetEntity } = relationContext
 		this.executionContext.addData(
 			entity.primary,
 			async ids => {
@@ -148,18 +132,17 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = field.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetRelation.name)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetRelation.name)
 			},
 			null,
 		)
 	}
 
-	public visitOneHasOneOwning(
-		entity: Model.Entity,
-		relation: Model.OneHasOneOwningRelation,
-		targetEntity: Model.Entity,
-		targetRelation: Model.OneHasOneInverseRelation | null,
-	): void {
+	public visitOneHasOneOwning(relationContext: Model.OneHasOneOwningContext): void {
+		const { relation, targetEntity } = relationContext
 		this.executionContext.addData(
 			relation.name,
 			async ids => {
@@ -177,13 +160,17 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetEntity.primary)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetEntity.primary)
 			},
 			null,
 		)
 	}
 
-	public visitManyHasOne(entity: Model.Entity, relation: Model.ManyHasOneRelation, targetEntity: Model.Entity): void {
+	public visitManyHasOne(relationContext: Model.ManyHasOneContext): void {
+		const { relation, targetEntity } = relationContext
 		this.executionContext.addData(
 			relation.name,
 			async ids => {
@@ -201,7 +188,10 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 				}
 				const objectWithWhere = objectNode.withArg('filter', where)
 
-				return this.mapper.select(targetEntity, objectWithWhere, targetEntity.primary)
+				return this.mapper.selectAssoc(targetEntity, objectWithWhere, [
+					...this.relationPath,
+					relationContext,
+				], targetEntity.primary)
 			},
 			null,
 		)

package/src/mapper/select/handlers/FieldsVisitorFactory.ts

@@ -22,6 +22,7 @@ export class FieldsVisitorFactory {
 			this.whereBuilder,
 			mapper,
 			context,
+			context.relationPath,
 		)
 	}
 }

package/src/mapper/select/optimizer/ConditionOptimizer.ts

@@ -0,0 +1,41 @@
+import { Input } from '@contember/schema'
+import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
+
+type ObjectEntry<T> = { [K in keyof Required<T>]: [K, T[K]] }[keyof T]
+
+export class ConditionOptimizer {
+	public optimize(condition: Input.Condition): Omit<Input.Condition, 'always' | 'never'> | boolean {
+		if (condition.never) {
+			return false
+		}
+
+		return optimizeAnd(
+			(Object.entries(condition) as ObjectEntry<typeof condition>[]).map(([key, value]) => {
+				if (value === undefined || value === null) {
+					return undefined
+
+				} else if (key === 'always') {
+					return true
+
+				} else if (key === 'and') {
+					return optimizeAnd(value.map(it => this.optimize(it)))
+
+				} else if (key === 'or') {
+					return optimizeOr(value.map(it => this.optimize(it)))
+
+				} else if (key === 'in' && value.length === 0) {
+					return false
+
+				} else if (key === 'notIn' && value.length === 0) {
+					return true
+
+				} else if (key === 'not') {
+					return optimizeNot(this.optimize(value))
+
+				} else {
+					return { [key]: value }
+				}
+			}),
+		)
+	}
+}

package/src/mapper/select/optimizer/WhereOptimizer.ts

@@ -0,0 +1,138 @@
+import { Input, Model } from '@contember/schema'
+import { ConditionOptimizer } from './ConditionOptimizer'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
+import { replaceWhere } from './WhereReplacer'
+
+type ExtendedRelationContext =
+	& Model.AnyRelationContext
+	& {
+		canEliminate: boolean
+		isLast: boolean
+	}
+
+export class WhereOptimizer {
+	private static eliminableRelations = new Set<Model.AnyRelationContext['type']>(['oneHasMany', 'oneHasOneInverse', 'oneHasOneOwning'])
+
+	constructor(
+		private readonly model: Model.Schema,
+		private readonly conditionOptimizer: ConditionOptimizer,
+	) {
+	}
+
+	public optimize(where: Input.OptionalWhere, entity: Model.Entity, relationPath: Model.AnyRelationContext[] = []): Input.Where {
+		let processedRelationPath: ExtendedRelationContext[] = []
+		for (const i in relationPath) {
+			const el = relationPath[i]
+			if (!WhereOptimizer.eliminableRelations.has(el.type)) {
+				processedRelationPath = []
+			} else {
+				processedRelationPath.push({ ...el, canEliminate: true, isLast: Number(i) === relationPath.length })
+			}
+			processedRelationPath.push({ ...el, canEliminate: true, isLast: Number(i) === relationPath.length })
+		}
+		const result = this.optimizeWhere(where, entity, processedRelationPath)
+
+		if (typeof result === 'boolean') {
+			return { [entity.primary]: { [result ? 'always' : 'never']: true } }
+		}
+
+		return result
+	}
+
+	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
+		return this.optimizeAnd(
+			Object.entries(where).map(([key, value]) => {
+				if (value === undefined || value === null) {
+					return undefined
+
+				} else if (key === 'and') {
+					return this.optimizeAnd((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
+
+				} else if (key === 'or') {
+					return this.optimizeOr((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
+
+				} else if (key === 'not') {
+					return optimizeNot(this.optimizeWhere(value as Input.Where, entity, relationPath))
+
+				} else {
+					return this.resolveFieldValue(entity, key, value, relationPath)
+				}
+			}),
+			entity,
+			relationPath,
+		)
+	}
+
+	private optimizeOr(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
+		const optimized = optimizeOr(operands)
+		if (typeof optimized === 'boolean' || !Array.isArray(optimized.or)) {
+			return optimized
+		}
+		const result = this.crossOptimize(optimized.or, entity, { never: true }, relationPath)
+		return optimizeOr(result)
+	}
+
+	private optimizeAnd(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
+		const optimized = optimizeAnd(operands)
+		if (typeof optimized === 'boolean' || !Array.isArray(optimized.and)) {
+			return optimized
+		}
+		const result = this.crossOptimize(optimized.and, entity, { always: true }, relationPath)
+		return optimizeAnd(result)
+	}
+
+	private crossOptimize(operands: Input.Where[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.Where | boolean)[] {
+		const result: (Input.Where | boolean)[] = [...operands]
+		const count = result.length
+		for (let i = 0; i < count; i++) {
+			for (let j = 0; j < count; j++) {
+				const a = result[j]
+				const b = result[i]
+				if (i !== j && typeof a !== 'boolean' && typeof b !== 'boolean') {
+					const tracker = { count: 0 }
+					const elResult = replaceWhere(a, b, { [entity.primary]: replacement }, tracker)
+					result[j] = tracker.count > 0 ? this.optimizeWhere(elResult, entity, relationPath) : elResult
+				}
+			}
+		}
+		return result
+	}
+
+	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string], relationPath: ExtendedRelationContext[]) {
+		return acceptFieldVisitor<Input.Where | boolean>(this.model, entity, key, {
+			visitColumn: () => {
+				const optimizedCondition = this.conditionOptimizer.optimize(value as Input.Condition)
+
+				if (typeof optimizedCondition === 'boolean') {
+					return optimizedCondition
+				}
+
+				return { [key]: optimizedCondition }
+			},
+			visitRelation: context => {
+				const { targetEntity, relation } = context
+				let where = value as Input.Where
+				const newRelationPath: ExtendedRelationContext[] = [...relationPath]
+				if (relationPath.length && relationPath[relationPath.length - 1].targetRelation?.name === relation.name) {
+					const item = newRelationPath.pop()
+					if (item?.canEliminate && (item.type === 'oneHasMany' || item.type === 'oneHasOneOwning' || item.type === 'oneHasOneInverse')) {
+						where = replaceWhere(where, { [targetEntity.primary]: { isNull: true } }, { [targetEntity.primary]: { never: true } })
+						where = replaceWhere(where, { [targetEntity.primary]: { isNull: false } }, { [targetEntity.primary]: { always: true } })
+					}
+				} else {
+					// first level relation - we are sure root exists
+					const canEliminate = relationPath.length === 0 || relationPath[relationPath.length - 1].isLast
+					newRelationPath.push({ ...context, isLast: false, canEliminate })
+				}
+				const optimizedWhere = this.optimizeWhere(where, targetEntity, newRelationPath)
+
+				if (typeof optimizedWhere === 'boolean') {
+					return optimizedWhere
+				}
+
+				return { [key]: optimizedWhere }
+			},
+		})
+	}
+}

package/src/mapper/select/optimizer/WhereReplacer.ts

@@ -0,0 +1,27 @@
+import { Input, Writable } from '@contember/schema'
+import deepEqual from 'fast-deep-equal'
+
+export interface ReplaceWhereResult {
+	count: number
+}
+
+export const replaceWhere = (subject: Input.Where, find: Input.Where, replace: Input.Where, resultTracker: ReplaceWhereResult = { count: 0 }): Input.Where => {
+	if (deepEqual(subject, find)) {
+		resultTracker.count++
+		return replace
+	}
+	const result: Writable<Input.Where> = {}
+	for (const [key, value] of Object.entries(subject)) {
+		if (key === 'not') {
+			result['not'] = replaceWhere(value as Input.Where, find, replace, resultTracker)
+
+		} else if (key === 'and' || key === 'or') {
+			result[key] = (value as Input.Where[]).map(it => replaceWhere(it, find, replace, resultTracker))
+
+		} else {
+			result[key] = value
+		}
+
+	}
+	return result
+}