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

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

@@ -18,35 +18,12 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 
 	visitColumn({ entity, column }: Model.ColumnContext): void {
 		const columnPath = this.executionContext.path
-		this.executionContext.addColumn(qb => {
-			const tableAlias = columnPath.back().alias
-			const columnAlias = columnPath.alias
+		const tableAlias = columnPath.back().alias
+		const columnAlias = columnPath.alias
 
-			const fieldPredicate = this.predicateFactory.shouldApplyCellLevelPredicate(
-				entity,
-				Acl.Operation.read,
-				column.name,
-			)
-				? this.predicateFactory.create(entity, Acl.Operation.read, [column.name])
-				: undefined
-
-			if (!fieldPredicate || Object.keys(fieldPredicate).length === 0) {
-				return qb.select([tableAlias, column.columnName], columnAlias)
-			}
-			return this.whereBuilder.buildAdvanced(entity, columnPath.back(), fieldPredicate, cb =>
-				qb.select(
-					expr =>
-						expr.case(caseExpr =>
-							caseExpr
-								.when(
-									whenExpr => whenExpr.selectCondition(cb),
-									thenExpr => thenExpr.select([tableAlias, column.columnName]),
-								)
-								.else(elseExpr => elseExpr.raw('null')),
-						),
-					columnAlias,
-				),
-			)
+		this.executionContext.addColumn({
+			query: qb => qb.select([tableAlias, column.columnName], columnAlias),
+			predicate: this.getRequiredPredicate(entity, column),
 		})
 	}
 
@@ -55,20 +32,19 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 		if (!field) {
 			throw new Error()
 		}
-		this.executionContext.addData(
-			relationContext.entity.primary,
-			async ids =>
-				this.relationFetcher.fetchManyHasManyGroups(
-					{
-						mapper: this.mapper,
-						field: field,
-						relationContext,
-						relationPath: this.relationPath,
-						ids: ids,
-					},
-				),
-			[],
-		)
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
+				this.relationFetcher.fetchManyHasManyGroups({
+					mapper: this.mapper,
+					field: field,
+					relationContext,
+					relationPath: this.relationPath,
+					ids: ids,
+				}),
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitManyHasManyOwning(relationContext: Model.ManyHasManyOwningContext): void {
@@ -77,9 +53,9 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 			throw new Error()
 		}
 
-		this.executionContext.addData(
-			relationContext.entity.primary,
-			async ids =>
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
 				this.relationFetcher.fetchManyHasManyGroups({
 					mapper: this.mapper,
 					field: field,
@@ -87,8 +63,9 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationPath: this.relationPath,
 					ids: ids,
 				}),
-			[],
-		)
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitOneHasMany(relationContext: Model.OneHasManyContext): void {
@@ -97,9 +74,9 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 			throw new Error()
 		}
 
-		this.executionContext.addData(
-			relationContext.entity.primary,
-			async ids =>
+		this.executionContext.addData({
+			field: relationContext.entity.primary,
+			dataProvider: async ids =>
 				this.relationFetcher.fetchOneHasManyGroups({
 					mapper: this.mapper,
 					objectNode: field,
@@ -107,15 +84,16 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationPath: this.relationPath,
 					ids: ids,
 				}),
-			[],
-		)
+			defaultValue: [],
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitOneHasOneInverse(relationContext: Model.OneHasOneInverseContext): void {
 		const { entity, targetRelation, targetEntity } = relationContext
-		this.executionContext.addData(
-			entity.primary,
-			async ids => {
+		this.executionContext.addData({
+			field: entity.primary,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetRelation.name]: {
 						[entity.primary]: {
@@ -137,15 +115,16 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationContext,
 				], targetRelation.name)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitOneHasOneOwning(relationContext: Model.OneHasOneOwningContext): void {
 		const { relation, targetEntity } = relationContext
-		this.executionContext.addData(
-			relation.name,
-			async ids => {
+		this.executionContext.addData({
+			field: relation.name,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetEntity.primary]: {
 						in: ids,
@@ -165,15 +144,16 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationContext,
 				], targetEntity.primary)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
 	}
 
 	public visitManyHasOne(relationContext: Model.ManyHasOneContext): void {
 		const { relation, targetEntity } = relationContext
-		this.executionContext.addData(
-			relation.name,
-			async ids => {
+		this.executionContext.addData({
+			field: relation.name,
+			dataProvider: async ids => {
 				const idsWhere: Input.Where = {
 					[targetEntity.primary]: {
 						in: ids,
@@ -193,7 +173,13 @@ export class FieldsVisitor implements Model.RelationByTypeVisitor<void>, Model.C
 					relationContext,
 				], targetEntity.primary)
 			},
-			null,
-		)
+			defaultValue: null,
+			predicate: this.getRequiredPredicate(relationContext.entity, relationContext.relation),
+		})
+	}
+
+	private getRequiredPredicate(entity: Model.Entity, field: Model.AnyField): Acl.Predicate | undefined {
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, Acl.Operation.read, field.name)
+		return fieldPredicate.isSameAsPrimary ? undefined : fieldPredicate.predicate
 	}
 }

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

@@ -32,25 +32,14 @@ export class MetaHandler implements SelectExecutionHandler<{}> {
 		metaPath: Path,
 		operation: Acl.Operation.read | Acl.Operation.update,
 	): void {
-		const { entity, path } = context
+		const { entity } = context
 		if (entity.primary === fieldName) {
 			return
 		}
-		const fieldPredicate = this.predicateFactory.create(entity, operation, [fieldName])
-		context.addColumn(qb => {
-			return this.whereBuilder.buildAdvanced(entity, path.back(), fieldPredicate, cb =>
-				qb.select(
-					expr =>
-						expr.selectCondition(condition => {
-							condition = cb(condition)
-							if (condition.isEmpty()) {
-								return condition.raw('true')
-							}
-							return condition
-						}),
-					metaPath.alias,
-				),
-			)
-		}, metaPath)
+		const fieldPredicate = this.predicateFactory.getFieldPredicate(entity, operation, fieldName)
+		context.addColumn({
+			path: metaPath,
+			valueGetter: context.addPredicate(fieldPredicate.predicate),
+		})
 	}
 }

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

@@ -5,12 +5,19 @@ import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
 import { replaceWhere } from './WhereReplacer'
 
 type ExtendedRelationContext =
-	& Model.AnyRelationContext
 	& {
+		context: Model.AnyRelationContext
 		canEliminate: boolean
 		isLast: boolean
 	}
 
+export interface WhereOptimizationHints {
+	relationPath?: Model.AnyRelationContext[]
+	evaluatedPredicates?: Input.OptionalWhere[]
+}
+
+type OptimizedOperand = Input.OptionalWhere | undefined | boolean
+
 export class WhereOptimizer {
 	private static eliminableRelations = new Set<Model.AnyRelationContext['type']>(['oneHasMany', 'oneHasOneInverse', 'oneHasOneOwning'])
 
@@ -20,79 +27,127 @@ export class WhereOptimizer {
 	) {
 	}
 
-	public optimize(where: Input.OptionalWhere, entity: Model.Entity, relationPath: Model.AnyRelationContext[] = []): Input.Where {
+	public optimize(where: Input.OptionalWhere, entity: Model.Entity, { relationPath = [], evaluatedPredicates = [] }: WhereOptimizationHints = {}): Input.OptionalWhere {
 		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({ context: 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)
+		let result = this.optimizeWhere(where, entity, processedRelationPath)
 
 		if (typeof result === 'boolean') {
 			return { [entity.primary]: { [result ? 'always' : 'never']: true } }
 		}
+		let changed = false
+		for (const evaluated of evaluatedPredicates) {
+			const evaluatedPredicate = this.optimize(evaluated, entity)
+			const newResult = replaceWhere(result, evaluatedPredicate, { [entity.primary]: { always: true } })
+			if (newResult !== result) {
+				result = newResult
+				changed = true
+			}
+		}
+		if (changed) {
+			return this.optimize(result, entity)
+		}
 
 		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
+	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
+		const operands: OptimizedOperand[] = []
+
+		for (const key in where) {
+			const value = where[key]
+			let operand: OptimizedOperand = undefined
+			if (value === undefined || value === null) {
+				continue
+			} else if (key === 'and') {
+				const innerOperands: (Input.OptionalWhere | boolean)[] = []
+				for (const innerValue of value as readonly Input.OptionalWhere[]) {
+					const innerOperand = this.optimizeWhere(innerValue, entity, relationPath)
+					if (innerOperand === false) {
+						return false
+					}
+					innerOperands.push(innerOperand)
+				}
+				operand = this.optimizeAnd(innerOperands, entity, relationPath)
+			} else if (key === 'or') {
+				const innerOperands: (Input.OptionalWhere | boolean)[] = []
+				for (const innerValue of value as readonly Input.OptionalWhere[]) {
+					const innerOperand = this.optimizeWhere(innerValue, entity, relationPath)
+					if (innerOperand === true) {
+						operand = true
+						break
+					}
+					innerOperands.push(innerOperand)
+				}
+				if (operand !== true) {
+					operand = this.optimizeOr(innerOperands, entity, relationPath)
+				}
 
-				} else if (key === 'and') {
-					return this.optimizeAnd((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
+			} else if (key === 'not') {
+				operand = optimizeNot(this.optimizeWhere(value as Input.OptionalWhere, entity, relationPath))
 
-				} else if (key === 'or') {
-					return this.optimizeOr((value as readonly Input.Where[]).map(it => this.optimizeWhere(it, entity, relationPath)), entity, relationPath)
+			} else {
+				operand = this.resolveFieldValue(entity, key, value, relationPath)
+			}
 
-				} else if (key === 'not') {
-					return optimizeNot(this.optimizeWhere(value as Input.Where, entity, relationPath))
+			if (operand === false) {
+				return false
 
-				} else {
-					return this.resolveFieldValue(entity, key, value, relationPath)
-				}
-			}),
-			entity,
-			relationPath,
-		)
+			} else if (operand !== undefined) {
+				operands.push(operand)
+			}
+		}
+		return this.optimizeAnd(operands, entity, relationPath)
 	}
 
-	private optimizeOr(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
+	private optimizeOr(operands: readonly OptimizedOperand[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | 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)
+		if (result === optimized.or) {
+			return optimized
+		}
 		return optimizeOr(result)
 	}
 
-	private optimizeAnd(operands: readonly (Input.Where | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.Where | boolean {
+	private optimizeAnd(operands: readonly OptimizedOperand[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | 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)
+		if (result === optimized.and) {
+			return optimized
+		}
 		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]
+	private crossOptimize(operands: Input.OptionalWhere[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.OptionalWhere | boolean)[] {
+		let result: (Input.OptionalWhere | boolean)[] = operands
+		let copied = false
 		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
+					const elResult = replaceWhere(a, b, { [entity.primary]: replacement })
+					if (elResult !== a) {
+						if (!copied) {
+							result = [...result]
+							copied = true
+						}
+						result[j] = this.optimizeWhere(elResult, entity, relationPath)
+					}
 				}
 			}
 		}
@@ -100,7 +155,7 @@ export class WhereOptimizer {
 	}
 
 	private resolveFieldValue(entity: Model.Entity, key: string, value: Input.OptionalWhere[string], relationPath: ExtendedRelationContext[]) {
-		return acceptFieldVisitor<Input.Where | boolean>(this.model, entity, key, {
+		return acceptFieldVisitor<Input.OptionalWhere | boolean>(this.model, entity, key, {
 			visitColumn: () => {
 				const optimizedCondition = this.conditionOptimizer.optimize(value as Input.Condition)
 
@@ -111,21 +166,22 @@ export class WhereOptimizer {
 				return { [key]: optimizedCondition }
 			},
 			visitRelation: context => {
-				const { targetEntity, relation } = context
-				let where = value as Input.Where
+				let where = value as Input.OptionalWhere
 				const newRelationPath: ExtendedRelationContext[] = [...relationPath]
-				if (relationPath.length && relationPath[relationPath.length - 1].targetRelation?.name === relation.name) {
+				const length = relationPath.length
+				if (length > 0 && relationPath[length - 1].context.targetRelation?.name === context.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 } })
+					const type = item!.context.type
+					if (item?.canEliminate && (type === 'oneHasMany' || type === 'oneHasOneOwning' || type === 'oneHasOneInverse')) {
+						where = replaceWhere(where, { [context.targetEntity.primary]: { isNull: true } }, { [context.targetEntity.primary]: { never: true } })
+						where = replaceWhere(where, { [context.targetEntity.primary]: { isNull: false } }, { [context.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 canEliminate = length === 0 || relationPath[length - 1].isLast
+					newRelationPath.push({ context, isLast: false, canEliminate })
 				}
-				const optimizedWhere = this.optimizeWhere(where, targetEntity, newRelationPath)
+				const optimizedWhere = this.optimizeWhere(where, context.targetEntity, newRelationPath)
 
 				if (typeof optimizedWhere === 'boolean') {
 					return optimizedWhere

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

@@ -1,27 +1,39 @@
 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 => {
+export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere): Input.OptionalWhere => {
 	if (deepEqual(subject, find)) {
-		resultTracker.count++
 		return replace
 	}
-	const result: Writable<Input.Where> = {}
-	for (const [key, value] of Object.entries(subject)) {
+	let result: Writable<Input.OptionalWhere> = subject
+	let copied = false
+	for (const key in subject) {
+		const value = subject[key]
 		if (key === 'not') {
-			result['not'] = replaceWhere(value as Input.Where, find, replace, resultTracker)
-
+			const newNot = replaceWhere(value as Input.OptionalWhere, find, replace)
+			if (newNot !== value) {
+				if (!copied) {
+					result = { ...result }
+				}
+				result['not'] = newNot
+			}
 		} else if (key === 'and' || key === 'or') {
-			result[key] = (value as Input.Where[]).map(it => replaceWhere(it, find, replace, resultTracker))
-
-		} else {
-			result[key] = value
+			const items: Input.OptionalWhere[] = []
+			let itemChanged = false
+			for (const el of value as Input.OptionalWhere[]) {
+				const newEl = replaceWhere(el, find, replace)
+				if (newEl !== el) {
+					itemChanged = true
+				}
+				items.push(newEl)
+			}
+			if (itemChanged) {
+				if (!copied) {
+					result = { ...result }
+				}
+				result[key] = items
+			}
 		}
-
 	}
 	return result
 }

package/tests/cases/integration/graphQlRequests/query/acl/differentRowAndFieldPredicate.test.ts

@@ -41,16 +41,18 @@ test('different predicate on row and field level', async () => {
 		executes: [
 			{
 				sql: SQL`
-					select "root_"."id" as "root_id",
-						case when "root_"."username" = ? then "root_"."username" else null end as "root_username"
-					from "public"."author" as "root_"
-					where not("root_"."username" is null)
+					select
+					    "root_"."id" as "root_id",
+					    "root_"."username" = ? as "root___predicate_authorPredicate",
+					    "root_"."username" as "root_username"
+					from "public"."author" as "root_" where not("root_"."username" is null)
 				`,
 				parameters: ['johndoe'],
 				response: {
 					rows: [
 						{
 							root_id: testUuid(1),
+							root___predicate_authorPredicate: true,
 							root_username: 'johndoe',
 						},
 					],
@@ -71,3 +73,51 @@ test('different predicate on row and field level', async () => {
 })
 
 
+
+test('different predicate on row and field level - false', async () => {
+	await execute({
+		schema: schema,
+		permissions: permissions,
+		variables: {},
+		query: GQL`
+        query {
+          listAuthor {
+            id
+            username
+          }
+        }`,
+		executes: [
+			{
+				sql: SQL`
+					select
+					    "root_"."id" as "root_id",
+					    "root_"."username" = ? as "root___predicate_authorPredicate",
+					    "root_"."username" as "root_username"
+					from "public"."author" as "root_" where not("root_"."username" is null)
+				`,
+				parameters: ['johndoe'],
+				response: {
+					rows: [
+						{
+							root_id: testUuid(1),
+							root___predicate_authorPredicate: false,
+							root_username: 'johndoe',
+						},
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listAuthor: [
+					{
+						id: testUuid(1),
+						username: null,
+					},
+				],
+			},
+		},
+	})
+})
+
+