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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-alpha.13",
+  "version": "1.2.0-alpha.14",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,19 +10,19 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.0-alpha.13",
-    "@contember/dic": "^1.2.0-alpha.13",
-    "@contember/engine-common": "^1.2.0-alpha.13",
-    "@contember/graphql-utils": "^1.2.0-alpha.13",
-    "@contember/schema": "^1.2.0-alpha.13",
-    "@contember/schema-utils": "^1.2.0-alpha.13",
+    "@contember/database": "^1.2.0-alpha.14",
+    "@contember/dic": "^1.2.0-alpha.14",
+    "@contember/engine-common": "^1.2.0-alpha.14",
+    "@contember/graphql-utils": "^1.2.0-alpha.14",
+    "@contember/schema": "^1.2.0-alpha.14",
+    "@contember/schema-utils": "^1.2.0-alpha.14",
     "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-alpha.13",
-    "@contember/engine-api-tester": "^1.2.0-alpha.13",
-    "@contember/schema-definition": "^1.2.0-alpha.13",
+    "@contember/database-tester": "^1.2.0-alpha.14",
+    "@contember/engine-api-tester": "^1.2.0-alpha.14",
+    "@contember/schema-definition": "^1.2.0-alpha.14",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",

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

@@ -5,8 +5,8 @@ import { optimizeAnd, optimizeNot, optimizeOr } from './helpers'
 import { replaceWhere } from './WhereReplacer'
 
 type ExtendedRelationContext =
-	& Model.AnyRelationContext
 	& {
+		context: Model.AnyRelationContext
 		canEliminate: boolean
 		isLast: boolean
 	}
@@ -16,6 +16,8 @@ export interface WhereOptimizationHints {
 	evaluatedPredicates?: Input.OptionalWhere[]
 }
 
+type OptimizedOperand = Input.OptionalWhere | undefined | boolean
+
 export class WhereOptimizer {
 	private static eliminableRelations = new Set<Model.AnyRelationContext['type']>(['oneHasMany', 'oneHasOneInverse', 'oneHasOneOwning'])
 
@@ -32,7 +34,7 @@ export class WhereOptimizer {
 			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 })
 			}
 		}
 		let result = this.optimizeWhere(where, entity, processedRelationPath)
@@ -40,12 +42,16 @@ export class WhereOptimizer {
 		if (typeof result === 'boolean') {
 			return { [entity.primary]: { [result ? 'always' : 'never']: true } }
 		}
-		const resultTracker = { count: 0 }
+		let changed = false
 		for (const evaluated of evaluatedPredicates) {
 			const evaluatedPredicate = this.optimize(evaluated, entity)
-			result = replaceWhere(result, evaluatedPredicate, { [entity.primary]: { always: true } }, resultTracker)
+			const newResult = replaceWhere(result, evaluatedPredicate, { [entity.primary]: { always: true } })
+			if (newResult !== result) {
+				result = newResult
+				changed = true
+			}
 		}
-		if (resultTracker.count > 0) {
+		if (changed) {
 			return this.optimize(result, entity)
 		}
 
@@ -53,58 +59,95 @@ export class WhereOptimizer {
 	}
 
 	private optimizeWhere(where: Input.OptionalWhere, entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | boolean {
-		return this.optimizeAnd(
-			Object.entries(where).map(([key, value]) => {
-				if (value === undefined || value === null) {
-					return undefined
+		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.OptionalWhere[]).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.OptionalWhere[]).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.OptionalWhere, 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.OptionalWhere | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | 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.OptionalWhere | undefined | boolean)[], entity: Model.Entity, relationPath: ExtendedRelationContext[]): Input.OptionalWhere | 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.OptionalWhere[], entity: Model.Entity, replacement: Input.Condition, relationPath: ExtendedRelationContext[]): (Input.OptionalWhere | boolean)[] {
-		const result: (Input.OptionalWhere | boolean)[] = [...operands]
+		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)
+					}
 				}
 			}
 		}
@@ -123,21 +166,22 @@ export class WhereOptimizer {
 				return { [key]: optimizedCondition }
 			},
 			visitRelation: context => {
-				const { targetEntity, relation } = context
 				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.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere, resultTracker: ReplaceWhereResult = { count: 0 }): Input.OptionalWhere => {
+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.OptionalWhere> = {}
-	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.OptionalWhere, 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.OptionalWhere[]).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
 }