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

package/src/mapper/select/SelectBuilder.ts

@@ -1,6 +1,6 @@
-import { Input, Model } from '@contember/schema'
+import { Acl, Input, Model } from '@contember/schema'
 import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
-import { SelectHydrator, SelectRow } from './SelectHydrator'
+import { ColumnValueGetter, SelectHydrator, SelectRow } from './SelectHydrator'
 import { Path, PathFactory } from './Path'
 import { WhereBuilder } from './WhereBuilder'
 import { Client, LimitByGroupWrapper, SelectBuilder as DbSelectBuilder } from '@contember/database'
@@ -11,6 +11,7 @@ import { MetaHandler } from './handlers'
 import { Mapper } from '../Mapper'
 import { FieldNode, ObjectNode } from '../../inputProcessing'
 import { assertNever } from '../../utils'
+import { PredicateFactory } from '../../acl'
 
 export class SelectBuilder {
 	private resolver: (value: SelectRow[]) => void = () => {
@@ -30,6 +31,8 @@ export class SelectBuilder {
 		private readonly fieldsVisitorFactory: FieldsVisitorFactory,
 		private readonly selectHandlers: { [key: string]: SelectExecutionHandler<any> },
 		private readonly pathFactory: PathFactory,
+		private readonly relationPath: Model.AnyRelationContext[],
+		private readonly predicateFactory: PredicateFactory,
 	) {}
 
 	public async execute(db: Client): Promise<SelectRow[]> {
@@ -53,7 +56,7 @@ export class SelectBuilder {
 		this.selectInternal(mapper, entity, path, input)
 		const where = input.args.filter
 		if (where) {
-			this.qb = this.whereBuilder.build(this.qb, entity, path, where)
+			this.qb = this.whereBuilder.build(this.qb, entity, path, where, { relationPath: this.relationPath })
 		}
 		const orderBy = input.args.orderBy || []
 
@@ -83,6 +86,40 @@ export class SelectBuilder {
 			input = input.withField(new FieldNode(entity.primary, entity.primary, {}))
 		}
 
+		const fetchedPredicates = new Set()
+		const addPredicate = (predicate: Acl.Predicate): ColumnValueGetter<boolean> => {
+			if (typeof predicate === 'boolean') {
+				return () => predicate
+			}
+			const predicatePath = path.for('__predicate').for(predicate)
+
+			if (!fetchedPredicates.has(predicate)) {
+				const relationContext = this.relationPath[this.relationPath.length - 1]
+
+				const primaryPredicate = this.predicateFactory.create(entity, Acl.Operation.read, undefined, relationContext)
+				const fieldPredicate = this.predicateFactory.buildPredicates(entity, [predicate], relationContext)
+
+				this.qb = this.whereBuilder.buildAdvanced(
+					entity,
+					path.back(),
+					fieldPredicate,
+					apply => this.qb.select(expr =>
+						expr.selectCondition(condition => {
+							condition = apply(condition)
+							if (condition.isEmpty()) {
+								return condition.raw('true')
+							}
+							return condition
+						}),
+					predicatePath.alias,
+					),
+					{ relationPath: this.relationPath, evaluatedPredicates: [primaryPredicate] },
+				)
+				fetchedPredicates.add(predicate)
+			}
+			return row => row[predicatePath.alias] === true
+		}
+
 		for (let field of input.fields) {
 			const fieldPath = path.for(field.alias)
 			const fieldProperty = (() => {
@@ -94,19 +131,38 @@ export class SelectBuilder {
 				}
 				return assertNever(field)
 			})()
+
+
 			const executionContext: SelectExecutionHandlerContext = {
 				mapper,
-				addData: async (fieldName, cb, defaultValue = null) => {
-					const columnName = getColumnName(this.schema, entity, fieldName)
-					const ids = (await this.getColumnValues(path.for(fieldName), columnName)).filter(it => it !== null)
+				relationPath: this.relationPath,
+				addData: async ({ field, dataProvider, defaultValue, predicate }) => {
+					if (predicate === false) {
+						this.hydrator.addPromise(fieldPath, path.for(field), Promise.resolve({}), defaultValue ?? null)
+						return
+					}
+					const predicateGetter = predicate !== undefined && predicate !== true ? addPredicate(predicate) : null
+					const columnName = getColumnName(this.schema, entity, field)
+					let ids = await this.getColumnValues(path.for(field), columnName, predicateGetter)
 
-					const data = (async () => (ids.length > 0 ? cb(ids) : {}))()
-					this.hydrator.addPromise(fieldPath, path.for(fieldName), data, defaultValue)
+					const data = ids.length > 0 ? dataProvider(ids) : Promise.resolve({})
+					this.hydrator.addPromise(fieldPath, path.for(field), data, defaultValue ?? null)
 				},
-				addColumn: (qbCallback, path) => {
-					this.qb = qbCallback(this.qb)
-					this.hydrator.addColumn(path || fieldPath)
+				addColumn: ({ path = fieldPath, predicate, query, valueGetter }) => {
+					if (predicate === false) {
+						this.hydrator.addColumn(path, () => null)
+						return
+					}
+					const predicateGetter = predicate !== undefined && predicate !== true ? addPredicate(predicate) : null
+					if (query) {
+						this.qb = query(this.qb)
+					}
+					this.hydrator.addColumn(
+						path,
+						valueGetter ?? (row => predicateGetter === null || predicateGetter(row) ? row[path.alias] : null),
+					)
 				},
+				addPredicate: addPredicate,
 				path: fieldPath,
 				entity: entity,
 				...fieldProperty,
@@ -136,10 +192,12 @@ export class SelectBuilder {
 		}
 	}
 
-	private async getColumnValues(columnPath: Path, columnName: string): Promise<Input.PrimaryValue[]> {
+	private async getColumnValues(columnPath: Path, columnName: string, predicateGetter: null | ColumnValueGetter<boolean>): Promise<Input.PrimaryValue[]> {
 		this.qb = this.qb.select([columnPath.back().alias, columnName], columnPath.alias)
 		const rows = await this.rows
+		const filteredRows = predicateGetter === null ? rows : rows.filter(predicateGetter)
 		const columnAlias = columnPath.alias
-		return Array.from(new Set(rows.map((it): Input.PrimaryValue => it[columnAlias] as Input.PrimaryValue)))
+		const ids = filteredRows.map((it): Input.PrimaryValue => it[columnAlias] as Input.PrimaryValue).filter(it => it !== null)
+		return Array.from(new Set(ids))
 	}
 }

package/src/mapper/select/SelectBuilderFactory.ts

@@ -1,7 +1,8 @@
 import { SelectBuilder } from './SelectBuilder'
 import { SelectHydrator } from './SelectHydrator'
 import { SelectBuilder as DbSelectBuilder } from '@contember/database'
+import { Model } from '@contember/schema'
 
 export interface SelectBuilderFactory {
-	create(qb: DbSelectBuilder<DbSelectBuilder.Result>, hydrator: SelectHydrator): SelectBuilder
+	create(qb: DbSelectBuilder<DbSelectBuilder.Result>, hydrator: SelectHydrator, relationPath: Model.AnyRelationContext[]): SelectBuilder
 }

package/src/mapper/select/SelectExecutionHandler.ts

@@ -1,6 +1,6 @@
 import { Path } from './Path'
-import { Input, Model } from '@contember/schema'
-import { SelectNestedData, SelectNestedDefaultValue } from './SelectHydrator'
+import { Acl, Input, Model } from '@contember/schema'
+import { ColumnValueGetter, SelectNestedData, SelectNestedDefaultValue, SelectRow } from './SelectHydrator'
 import { SelectBuilder } from '@contember/database'
 import { Mapper } from '../Mapper'
 import { FieldNode, ObjectNode } from '../../inputProcessing'
@@ -21,12 +21,20 @@ export type SelectExecutionHandlerContext<
 	mapper: Mapper
 	path: Path
 	entity: Model.Entity
-
-	addColumn: (
-		queryCallback: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>,
-		path?: Path,
-	) => void
-	addData: (parentField: string, cb: DataCallback, defaultValue?: SelectNestedDefaultValue) => void
+	relationPath: Model.AnyRelationContext[]
+	addPredicate: (predicate: Acl.Predicate) => (row: SelectRow) => boolean
+	addColumn: (args: {
+		predicate?: Acl.Predicate
+		query?: (qb: SelectBuilder<SelectBuilder.Result>) => SelectBuilder<SelectBuilder.Result>
+		path?: Path
+		valueGetter?: ColumnValueGetter
+	}) => void
+	addData: (args: {
+		field: string
+		dataProvider: DataCallback
+		predicate?: Acl.Predicate
+		defaultValue?: SelectNestedDefaultValue
+	}) => void
 } & (
 	| {
 		fieldNode: FieldNode<FieldExtensions>

package/src/mapper/select/SelectHydrator.ts

@@ -1,6 +1,7 @@
 import { Path } from './Path'
 import { Value } from '@contember/schema'
 import { getFulfilledValues, getRejections } from '../../utils'
+import { logger } from '@contember/logger'
 
 type DataPromises = {
 	path: Path
@@ -16,12 +17,19 @@ type ResolvedData = {
 	defaultValue: SelectNestedDefaultValue
 }
 
+export type ColumnValueGetter<T extends Value.FieldValue = Value.FieldValue> = (row: SelectRow) => T
+
+type Column = {
+	path: Path
+	getValue: ColumnValueGetter
+}
+
 export class SelectHydrator {
-	private columns: Path[] = []
+	private columns: Column[] = []
 	private promises: DataPromises[] = []
 
-	public addColumn(path: Path) {
-		this.columns.push(path)
+	public addColumn(path: Path, getValue: ColumnValueGetter) {
+		this.columns.push({ path, getValue })
 	}
 
 	public addPromise(
@@ -72,12 +80,11 @@ export class SelectHydrator {
 		const result: SelectResultObject = {}
 
 		for (let columnPath of this.columns) {
-			const path = [...columnPath.path]
+			const path = [...columnPath.path.path]
 			const last: string = path.pop() as string
 			const currentObject = path.reduce<any>((obj, part) => (obj[part] = obj[part] || {}), result)
 
-			const field = row[columnPath.alias]
-			currentObject[last] = this.formatValue(field)
+			currentObject[last] = this.formatValue(columnPath.getValue(row))
 		}
 
 		for (let { path, parentKeyPath, data, defaultValue } of resolvedData) {
@@ -103,10 +110,7 @@ export class SelectHydrator {
 		const failures = getRejections(results)
 		if (failures.length > 0) {
 			if (failures.length > 1) {
-				// eslint-disable-next-line no-console
-				console.error('Multiple error has occurred, printing them & rethrowing the first one')
-				// eslint-disable-next-line no-console
-				failures.slice(1).map(e => console.error(e))
+				failures.slice(1).map(e => logger.error(e, { loc: 'SelectHydrator' }))
 			}
 			throw failures[0]
 		}
@@ -122,7 +126,7 @@ export class SelectHydrator {
 	}
 }
 
-export type SelectRow = { [key: string]: Value.AtomicValue }
+export type SelectRow = { [key: string]: Value.FieldValue }
 export type SelectResultObject = Value.Object
 export type SelectIndexedResultObjects = { [key: string]: SelectResultObject }
 export type SelectGroupedObjects = { [groupingKey: string]: SelectResultObject[] }

package/src/mapper/select/WhereBuilder.ts

@@ -1,11 +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 { WhereOptimizer } from './optimizer/WhereOptimizer'
+import {
+	ConditionBuilder as SqlConditionBuilder,
+	Literal,
+	Operator,
+	QueryBuilder,
+	SelectBuilder, wrapIdentifier,
+} from '@contember/database'
+import { WhereOptimizationHints, WhereOptimizer } from './optimizer/WhereOptimizer'
 
 export class WhereBuilder {
 	constructor(
@@ -14,6 +20,7 @@ export class WhereBuilder {
 		private readonly conditionBuilder: ConditionBuilder,
 		private readonly pathFactory: PathFactory,
 		private readonly whereOptimizer: WhereOptimizer,
+		private readonly useExistsInHasManyFilter: boolean,
 	) {}
 
 	public build(
@@ -21,35 +28,62 @@ export class WhereBuilder {
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
-		allowManyJoin: boolean = false,
+		optimizationHints: WhereOptimizationHints = {},
 	) {
-		return this.buildAdvanced(entity, path, where, cb => qb.where(clause => cb(clause)), allowManyJoin)
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity, optimizationHints)
+		return this.buildInternal({
+			entity,
+			path,
+			where: optimizedWhere,
+			callback: cb => qb.where(clause => cb(clause)),
+			allowManyJoin: false,
+		})
 	}
 
+
 	public buildAdvanced(
 		entity: Model.Entity,
 		path: Path,
 		where: Input.OptionalWhere,
 		callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>,
-		allowManyJoin: boolean = false,
+		optimizationHints: WhereOptimizationHints = {},
+	) {
+		const optimizedWhere = this.whereOptimizer.optimize(where, entity, optimizationHints)
+		return this.buildInternal({
+			entity,
+			path,
+			where: optimizedWhere,
+			callback,
+			allowManyJoin: false,
+		})
+	}
+
+	private buildInternal({
+		callback,
+		...args
+	}: { entity: Model.Entity; path: Path; where: Input.OptionalWhere; callback: (clauseCb: (clause: SqlConditionBuilder) => SqlConditionBuilder) => SelectBuilder<SelectBuilder.Result>; allowManyJoin: boolean },
 	) {
-		const optimizedWhere = this.whereOptimizer.optimize(where, entity)
 		const joinList: WhereJoinDefinition[] = []
 
-		const qbWithWhere = callback(clause => this.buildInternal(clause, entity, path, optimizedWhere, allowManyJoin, joinList))
+		const qbWithWhere = callback(clause => this.buildRecursive({
+			conditionBuilder: clause,
+			joinList: joinList,
+			...args,
+		}))
 		return joinList.reduce<SelectBuilder<SelectBuilder.Result>>(
 			(qb, { path, entity, relationName }) => this.joinBuilder.join(qb, path, entity, relationName),
 			qbWithWhere,
 		)
 	}
 
-	private buildInternal(
-		conditionBuilder: SqlConditionBuilder,
-		entity: Model.Entity,
-		path: Path,
-		where: Input.Where,
-		allowManyJoin: boolean,
-		joinList: WhereJoinDefinition[],
+	private buildRecursive({
+		conditionBuilder,
+		entity,
+		path,
+		where,
+		joinList,
+		allowManyJoin,
+	}: { conditionBuilder: SqlConditionBuilder; entity: Model.Entity; path: Path; where: Input.OptionalWhere; joinList: WhereJoinDefinition[]; allowManyJoin: boolean },
 	): SqlConditionBuilder {
 		const tableName = path.alias
 
@@ -58,7 +92,14 @@ 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({
+							conditionBuilder: clause2,
+							entity,
+							path,
+							where,
+							joinList,
+							allowManyJoin,
+						}),
 					clause,
 				),
 			)
@@ -70,7 +111,14 @@ export class WhereBuilder {
 					(clause2, where) =>
 						!where
 							? clause2
-							: clause2.and(clause3 => this.buildInternal(clause3, entity, path, where, allowManyJoin, joinList)),
+							: clause2.and(clause3 => this.buildRecursive({
+								conditionBuilder: clause3,
+								entity,
+								path,
+								where,
+								joinList,
+								allowManyJoin,
+							})),
 					clause,
 				),
 			)
@@ -78,7 +126,14 @@ 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({
+					conditionBuilder: clause,
+					entity,
+					path,
+					where: expr,
+					joinList,
+					allowManyJoin,
+				}),
 			)
 		}
 
@@ -87,12 +142,9 @@ export class WhereBuilder {
 				continue
 			}
 
-			const joinedWhere = (
-				entity: Model.Entity,
-				relation: Model.Relation,
-				targetEntity: Model.Entity,
-			): SqlConditionBuilder => {
-				const targetPath = path.for(fieldName)
+			const targetPath = path.for(fieldName)
+
+			const joinedWhere = ({ targetEntity, relation, entity }: Model.AnyRelationContext): SqlConditionBuilder => {
 				const relationWhere = where[fieldName] as Input.Where
 				if (Object.keys(relationWhere).length === 0) {
 					return conditionBuilder
@@ -112,36 +164,45 @@ export class WhereBuilder {
 
 				joinList.push({ path: targetPath, entity, relationName: relation.name })
 
-				return this.buildInternal(conditionBuilder, targetEntity, targetPath, relationWhere, allowManyJoin, joinList)
+				return this.buildRecursive({
+					conditionBuilder,
+					entity: targetEntity,
+					path: targetPath,
+					where: relationWhere,
+					joinList,
+					allowManyJoin,
+				})
 			}
 
 			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) => {
-					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+				visitManyHasManyInverse: context => {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
+						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',
+							targetPath,
 						),
 					)
 				},
-				visitManyHasManyOwning: (entity, relation, targetEntity) => {
-					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+				visitManyHasManyOwning: context => {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
+						return joinedWhere(context)
 					}
 
 					const relationWhere = where[fieldName] as Input.Where
@@ -150,30 +211,40 @@ export class WhereBuilder {
 						this.createManyHasManySubquery(
 							[tableName, entity.primaryColumn],
 							relationWhere,
-							targetEntity,
-							relation.joiningTable,
+							context.targetEntity,
+							context.relation.joiningTable,
 							'owning',
+							targetPath,
 						),
 					)
 				},
-				visitOneHasMany: (entity, relation, targetEntity, targetRelation) => {
-					if (allowManyJoin) {
-						return joinedWhere(entity, relation, targetEntity)
+				visitOneHasMany: context => {
+					if (allowManyJoin && !this.useExistsInHasManyFilter) {
+						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)})`), targetPath.for('tmp_').alias)
+							.leftJoin(context.targetEntity.tableName, targetPath.alias, it =>
+								it.columnsEq([targetPath.for('tmp_').alias, entity.primaryColumn], [targetPath.alias, context.targetRelation.joiningColumn.columnName]),
+							)
+						: SelectBuilder.create()
+							.select(it => it.raw('1'))
+							.from(context.targetEntity.tableName, targetPath.alias)
+							.where(it => it.columnsEq([tableName, entity.primaryColumn], [targetPath.alias, 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.pathFactory.create([], 'sub_'),
-							relationWhere,
-							true,
-						),
+						this.buildInternal({
+							entity: context.targetEntity,
+							path: targetPath,
+							where: relationWhere,
+							callback: cb => qb.where(clause => cb(clause)),
+							allowManyJoin: true,
+						}),
 					)
 				},
 			})
@@ -181,19 +252,22 @@ export class WhereBuilder {
 		return conditionBuilder
 	}
 
+
 	private createManyHasManySubquery(
 		outerColumn: QueryBuilder.ColumnIdentifier,
 		relationWhere: Input.Where,
 		targetEntity: Model.Entity,
 		joiningTable: Model.JoiningTable,
 		fromSide: 'owning' | 'inverse',
+		path: Path,
 	) {
 		const fromColumn = fromSide === 'owning' ? joiningTable.joiningColumn.columnName : joiningTable.inverseJoiningColumn.columnName
 		const toColumn = fromSide === 'owning' ? joiningTable.inverseJoiningColumn.columnName : joiningTable.joiningColumn.columnName
+		const junctionPath = path.for('junction_')
 		const qb = SelectBuilder.create<SelectBuilder.Result>()
-			.from(joiningTable.tableName, 'junction_')
+			.from(joiningTable.tableName, junctionPath.alias)
 			.select(it => it.raw('1'))
-			.where(it => it.columnsEq(outerColumn, ['junction_', fromColumn]))
+			.where(it => it.columnsEq(outerColumn, [junctionPath.alias, fromColumn]))
 
 		const primaryCondition = this.transformWhereToPrimaryCondition(relationWhere, targetEntity.primary)
 		if (primaryCondition !== null) {
@@ -201,20 +275,20 @@ export class WhereBuilder {
 			const columnType = (targetEntity.fields[targetEntity.primary] as Model.AnyColumn).columnType
 
 			return qb.where(condition =>
-				this.conditionBuilder.build(condition, 'junction_', toColumn, columnType, primaryCondition),
+				this.conditionBuilder.build(condition, junctionPath.alias, toColumn, columnType, primaryCondition),
 			)
 		}
 
-		const qbJoined = qb.join(targetEntity.tableName, 'sub_', clause =>
-			clause.compareColumns(['junction_', toColumn], Operator.eq, ['sub_', targetEntity.primary]),
-		)
-		return this.buildAdvanced(
-			targetEntity,
-			this.pathFactory.create([], 'sub_'),
-			relationWhere,
-			cb => qbJoined.where(clause => cb(clause)),
-			true,
+		const qbJoined = qb.join(targetEntity.tableName, path.alias, clause =>
+			clause.compareColumns([junctionPath.alias, toColumn], Operator.eq, [path.alias, targetEntity.primary]),
 		)
+		return this.buildInternal({
+			entity: targetEntity,
+			path: this.pathFactory.create([], path.fullAlias),
+			where: relationWhere,
+			callback: cb => qbJoined.where(clause => cb(clause)),
+			allowManyJoin: true,
+		})
 	}
 
 	private transformWhereToPrimaryCondition(where: Input.Where, primaryField: string): Input.Condition<never> | null {
@@ -260,6 +334,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 }