@contember/engine-content-api 1.2.0-rc.3 → 1.2.0-rc.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.2.0-rc.3",
+  "version": "1.2.0-rc.4",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,21 +10,21 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^1.2.0-rc.3",
-    "@contember/dic": "^1.2.0-rc.3",
-    "@contember/logger": "^1.2.0-rc.3",
-    "@contember/graphql-utils": "^1.2.0-rc.3",
-    "@contember/schema": "^1.2.0-rc.3",
-    "@contember/schema-definition": "^1.2.0-rc.3",
-    "@contember/schema-utils": "^1.2.0-rc.3",
+    "@contember/database": "^1.2.0-rc.4",
+    "@contember/dic": "^1.2.0-rc.4",
+    "@contember/logger": "^1.2.0-rc.4",
+    "@contember/graphql-utils": "^1.2.0-rc.4",
+    "@contember/schema": "^1.2.0-rc.4",
+    "@contember/schema-definition": "^1.2.0-rc.4",
+    "@contember/schema-utils": "^1.2.0-rc.4",
     "@graphql-tools/schema": "^8.3.5",
     "fast-deep-equal": "^3.1.3",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^1.2.0-rc.3",
-    "@contember/engine-api-tester": "^1.2.0-rc.3",
-    "@contember/schema-definition": "^1.2.0-rc.3",
+    "@contember/database-tester": "^1.2.0-rc.4",
+    "@contember/engine-api-tester": "^1.2.0-rc.4",
+    "@contember/schema-definition": "^1.2.0-rc.4",
     "@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

@@ -140,7 +140,9 @@ export class WhereOptimizer {
 				const a = result[j]
 				const b = result[i]
 				if (i !== j && typeof a !== 'boolean' && typeof b !== 'boolean') {
-					const elResult = replaceWhere(a, b, { [entity.primary]: replacement })
+					const elResult = replaceWhere(a, b, { [entity.primary]: replacement }, {
+						replaceSubOperands: true,
+					})
 					if (elResult !== a) {
 						if (!copied) {
 							result = [...result]

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

@@ -1,39 +1,66 @@
 import { Input, Writable } from '@contember/schema'
 import deepEqual from 'fast-deep-equal'
 
-export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere): Input.OptionalWhere => {
+export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere, opts: { replaceSubOperands?: boolean } = {}): Input.OptionalWhere => {
 	if (deepEqual(subject, find)) {
 		return replace
 	}
 	let result: Writable<Input.OptionalWhere> = subject
 	let copied = false
+	// copy on write to preserve referential integrity, when nothing has changed
+	const write = <T extends string>(key: T, value: Input.OptionalWhere[T]) => {
+		if (!copied) {
+			result = { ...result }
+			copied = true
+		}
+		result[key] = value
+	}
+
 	for (const key in subject) {
 		const value = subject[key]
 		if (key === 'not') {
-			const newNot = replaceWhere(value as Input.OptionalWhere, find, replace)
+			const newNot = replaceWhere(value as Input.OptionalWhere, find, replace, opts)
 			if (newNot !== value) {
-				if (!copied) {
-					result = { ...result }
-				}
-				result['not'] = newNot
+				write('not', newNot)
 			}
 		} else if (key === 'and' || key === 'or') {
-			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
+			const operands = value as Input.OptionalWhere[]
+			const subOperandsToFind = opts.replaceSubOperands && Object.keys(find).length === 1 && find[key] ? (find[key] as Input.OptionalWhere[]) : null
+			if (subOperandsToFind !== null && containsAllOperands(operands, subOperandsToFind)) {
+				write(key, [replace])
+			} else {
+				const items: Input.OptionalWhere[] = []
+				let itemChanged = false
+				for (const el of operands) {
+					const newEl = replaceWhere(el, find, replace, opts)
+					if (newEl !== el) {
+						itemChanged = true
+					}
+					items.push(newEl)
 				}
-				items.push(newEl)
-			}
-			if (itemChanged) {
-				if (!copied) {
-					result = { ...result }
+				if (itemChanged) {
+					write(key, items)
 				}
-				result[key] = items
 			}
+
 		}
 	}
 	return result
 }
+
+
+const containsAllOperands = (subjectOperands: Input.OptionalWhere[], findOperands: Input.OptionalWhere[]): boolean => {
+	for (const op1 of findOperands) {
+		let found = false
+		for (const op2 of subjectOperands) {
+			if (deepEqual(op1, op2)) {
+				found = true
+				break
+			}
+		}
+		if (!found) {
+			return false
+		}
+	}
+	return true
+}

package/tests/cases/unit/whereOptimizer.test.ts

@@ -95,9 +95,11 @@ describe('where optimized', () => {
 	})
 
 
-	const A = { authors: { isPublic: { eq: true } } }
-	const B = { authors: { name: { eq: 'John' } } }
-	const C = { authors: { name: { eq: 'Jack' } } }
+	const A = { name: { eq: 'A' } }
+	const B = { name: { eq: 'B' } }
+	const C = { name: { eq: 'C' } }
+	const D = { name: { eq: 'D' } }
+	const E = { name: { eq: 'E' } }
 
 	it('minimize: A || (A && B) => A', () => {
 		assert.deepStrictEqual(whereOptimizer.optimize({
@@ -105,7 +107,7 @@ describe('where optimized', () => {
 				A,
 				{ and: [A, B] },
 			],
-		}, model.entities.Image), A)
+		}, model.entities.Author), A)
 	})
 
 	it('minimize: (A && B) || A => A', () => {
@@ -114,7 +116,7 @@ describe('where optimized', () => {
 				{ and: [A, B] },
 				A,
 			],
-		}, model.entities.Image), A)
+		}, model.entities.Author), A)
 	})
 
 	it('minimize: A && (A || B) => A', () => {
@@ -123,7 +125,7 @@ describe('where optimized', () => {
 				A,
 				{ or: [A, B] },
 			],
-		}, model.entities.Image), A)
+		}, model.entities.Author), A)
 	})
 
 	it('minimize: (A || B) && A => A', () => {
@@ -132,7 +134,7 @@ describe('where optimized', () => {
 				{ or: [A, B] },
 				A,
 			],
-		}, model.entities.Image), A)
+		}, model.entities.Author), A)
 	})
 
 	it('minimize: A && (!A || B) => A && B', () => {
@@ -141,7 +143,7 @@ describe('where optimized', () => {
 				A,
 				{ or: [{ not: A }, B] },
 			],
-		}, model.entities.Image), { and: [A, B] })
+		}, model.entities.Author), { and: [A, B] })
 	})
 
 	it('minimize: A || (!A && B) => A || B', () => {
@@ -150,7 +152,7 @@ describe('where optimized', () => {
 				A,
 				{ and: [{ not: A }, B] },
 			],
-		}, model.entities.Image), { or: [A, B] })
+		}, model.entities.Author), { or: [A, B] })
 	})
 
 
@@ -160,7 +162,7 @@ describe('where optimized', () => {
 				A,
 				{ not: A },
 			],
-		}, model.entities.Image), { id: { always: true } })
+		}, model.entities.Author), { id: { always: true } })
 	})
 
 	it('minimize: A && !A => 0', () => {
@@ -169,7 +171,7 @@ describe('where optimized', () => {
 				A,
 				{ not: A },
 			],
-		}, model.entities.Image), { id: { never: true } })
+		}, model.entities.Author), { id: { never: true } })
 	})
 
 	it('minimize: !A && !A => !A', () => {
@@ -178,7 +180,7 @@ describe('where optimized', () => {
 				{ not: A },
 				{ not: A },
 			],
-		}, model.entities.Image), { not: A })
+		}, model.entities.Author), { not: A })
 	})
 
 
@@ -188,7 +190,7 @@ describe('where optimized', () => {
 				{ and: [A, B] },
 				{ and: [A, C] },
 			],
-		}, model.entities.Image), {
+		}, model.entities.Author), {
 			or: [
 				{ and: [A, B] },
 				{ and: [A, C] },
@@ -196,6 +198,111 @@ describe('where optimized', () => {
 		})
 	})
 
+	it('minimize: (A || B) && (A || B || C) => A || B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{
+					or: [A, B],
+				},
+				{
+					or: [A, B, C],
+				},
+			],
+		}, model.entities.Author), { or: [A, B] })
+	})
+
+	it('not minimize: (A || B) && (A || C)', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{
+					or: [A, B],
+				},
+				{
+					or: [A, C],
+				},
+			],
+		}, model.entities.Author), { and: [{ or: [A, B] }, { or: [A, C] }] })
+	})
+
+	it('minimize: (A && B) || (A && B && C) => A && B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{
+					and: [A, B],
+				},
+				{
+					and: [A, B, C],
+				},
+			],
+		}, model.entities.Author), { and: [A, B] })
+	})
+
+	it('minimize: (A && B) || (A && B) || (A && B) => A && B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{
+					and: [A, B],
+				},
+				{
+					and: [A, B],
+				},
+				{
+					and: [A, B],
+				},
+			],
+		}, model.entities.Author), { and: [A, B] })
+	})
+
+	it('minimize: (a && b) || (a && b && c) || (a && c) => (a && b) || (a && c)', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{
+					and: [A, B],
+				},
+				{
+					and: [A, B, C],
+				},
+				{
+					and: [A, C],
+				},
+			],
+		}, model.entities.Author), {
+			or: [
+				{
+					and: [A, B],
+				},
+				{
+					and: [A, C],
+				},
+			],
+		})
+	})
+
+	it('minimize: (a && b) || (c && (d || (a && b && e))) => (a && b) || (c && d)', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{
+					and: [A, B],
+				},
+				{
+					and: [C, { or: [D, { and: [A, B, E] }] }],
+				},
+			],
+		}, model.entities.Author), { or: [{ and: [A, B] }, { and: [C, D] }] })
+	})
+
+	it('minimize: (a || b) && (c || (d && (a || b || e))) => (A || B) && (C || D)', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{
+					or: [A, B],
+				},
+				{
+					or: [C, { and: [D, { or: [A, B, E] }] }],
+				},
+			],
+		}, model.entities.Author), { and: [{ or: [A, B] }, { or: [C, D] }] })
+	})
 
 	describe('remove id predicates', () => {