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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "v1.2.0-alpha.8",
+  "version": "1.2.0-alpha.9",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -10,24 +10,24 @@
     "test": "vitest --no-threads"
   },
   "dependencies": {
-    "@contember/database": "^v1.2.0-alpha.8",
-    "@contember/dic": "^v1.2.0-alpha.8",
-    "@contember/engine-common": "^v1.2.0-alpha.8",
-    "@contember/graphql-utils": "^v1.2.0-alpha.8",
-    "@contember/schema": "^v1.2.0-alpha.8",
-    "@contember/schema-utils": "^v1.2.0-alpha.8",
+    "@contember/database": "^1.2.0-alpha.9",
+    "@contember/dic": "^1.2.0-alpha.9",
+    "@contember/engine-common": "^1.2.0-alpha.9",
+    "@contember/graphql-utils": "^1.2.0-alpha.9",
+    "@contember/schema": "^1.2.0-alpha.9",
+    "@contember/schema-utils": "^1.2.0-alpha.9",
     "@graphql-tools/schema": "^8.3.5",
     "graphql-tag": "^2.12.5"
   },
   "devDependencies": {
-    "@contember/database-tester": "^v1.2.0-alpha.8",
-    "@contember/engine-api-tester": "^v1.2.0-alpha.8",
-    "@contember/schema-definition": "^v1.2.0-alpha.8",
+    "@contember/database-tester": "^1.2.0-alpha.9",
+    "@contember/engine-api-tester": "^1.2.0-alpha.9",
+    "@contember/schema-definition": "^1.2.0-alpha.9",
     "@graphql-codegen/cli": "^2.6.2",
     "@graphql-codegen/typescript": "^2.5.1",
     "@graphql-codegen/typescript-operations": "^2.4.2",
     "@graphql-codegen/typescript-resolvers": "^2.6.6",
-    "@types/node": "^16",
+    "@types/node": "^18",
     "graphql": "^16.5.0",
     "pg": "^8.5.0"
   },

package/src/acl/PermissionFactory.ts

@@ -17,7 +17,7 @@ export class PermissionFactory {
 			}
 			result = this.mergePermissions(result, rolePermissions)
 		}
-		this.makePrimaryPredicatesUnionOfAllFields(result)
+		result = this.makePrimaryPredicatesUnionOfAllFields(result)
 
 		return result
 	}
@@ -45,18 +45,20 @@ export class PermissionFactory {
 		}))
 	}
 
-	private makePrimaryPredicatesUnionOfAllFields(permissions: Acl.Permissions): void {
-		for (let entityName in permissions) {
+	private makePrimaryPredicatesUnionOfAllFields(permissions: Acl.Permissions): Acl.Permissions {
+		return mapObject(permissions, (permission, entityName): Acl.EntityPermissions => {
 			const entity = getEntity(this.schema, entityName)
-			const entityPermissions: Acl.EntityPermissions = permissions[entityName]
-			const entityPredicates: Writable<Acl.PredicateMap> = entityPermissions.predicates
+			const entityPredicates: Writable<Acl.PredicateMap> = { ...permission.predicates }
+			const entityOperations: Writable<Acl.EntityOperations> = { ...permission.operations }
 
 			const operationNames = ['read', 'create', 'update'] as const
 			for (let operation of operationNames) {
-				const fieldPermissions: Writable<Acl.FieldPermissions> | undefined = entityPermissions.operations[operation]
-				if (fieldPermissions === undefined) {
+				if (!entityOperations[operation]) {
 					continue
 				}
+				const fieldPermissions: Writable<Acl.FieldPermissions> = { ...entityOperations[operation] }
+				entityOperations[operation] = fieldPermissions
+
 				if (Object.values(fieldPermissions).some(it => it === true)) {
 					fieldPermissions[entity.primary] = true
 				}
@@ -70,25 +72,28 @@ export class PermissionFactory {
 					.filter((value, index, array): value is string => array.indexOf(value) === index)
 
 				let idPermissions: Acl.Predicate = fieldPermissions[entity.primary] || false
-				const predicates = { ...entityPermissions.predicates }
 
 				for (let predicateReference of predicateReferences) {
 					const [predicateDefinition, predicate] = this.mergePredicates(
-						predicates,
+						entityPredicates,
 						idPermissions,
-						predicates,
+						entityPredicates,
 						predicateReference,
 					)
 					if (typeof predicate !== 'string' || predicateDefinition === undefined) {
 						throw new Error('should not happen')
 					}
 					idPermissions = predicate
-					predicates[predicate] = predicateDefinition
+					entityPredicates[predicate] = predicateDefinition
 				}
 				fieldPermissions[entity.primary] = idPermissions
-				entityPredicates[idPermissions as Acl.PredicateReference] = predicates[idPermissions as Acl.PredicateReference]
+				entityPredicates[idPermissions as Acl.PredicateReference] = entityPredicates[idPermissions as Acl.PredicateReference]
 			}
-		}
+			return {
+				operations: entityOperations,
+				predicates: entityPredicates,
+			}
+		})
 	}
 
 	private mergePermissions(left: Acl.Permissions, right: Acl.Permissions): Acl.Permissions {

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

@@ -1,10 +1,12 @@
 export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly (P | boolean)[]): P | { or?: P[] } | boolean => {
 	const normalized: P[] = []
-
+	let hasNever = false
 	for (const operand of operands) {
 		if (operand === true) {
 			return true
-		} else if (operand !== false) {
+		} else if (operand === false) {
+			hasNever = true
+		} else  {
 			normalized.push(...Array.isArray(operand.or) ? operand.or : [operand])
 		}
 	}
@@ -13,6 +15,8 @@ export const optimizeOr = <P extends Record<string, unknown>>(operands: readonly
 		return { or: normalized }
 	} else if (normalized.length === 1) {
 		return normalized[0]
+	} else if (hasNever) {
+		return false
 	} else {
 		return {}
 	}

package/src/utils/object.ts

@@ -9,18 +9,18 @@ function filterObject<Input extends {}, Result extends { [Key in keyof Input]: I
 	object: Input,
 	callback: TypeGuard<Input, Result> | Filter<Input>,
 ): Result {
-	return (Object.entries(object) as any)
-		.filter(<K extends keyof Input>(it: [K, Input[K]]): it is [K, Result[K]] =>
-			(callback as any)(it[0] as K, it[1] as Input[K], object),
-		)
-		.reduce((result: Result, [key, value]: [string, any]) => ({ ...(result as any), [key]: value }), {} as Result)
+	return Object.fromEntries(Object.entries(object)
+		.filter(([key, value]) => (callback as any)(key, value, object)),
+	) as Result
 }
 
 function mapObject<Input, Result>(
 	input: { [key: string]: Input },
 	callback: (value: Input, key: string) => Result,
 ): { [key: string]: Result } {
-	return Object.keys(input).reduce((acc, key) => ({ ...acc, [key]: callback(input[key], key) }), {})
+	return Object.fromEntries(
+		Object.entries(input).map(([key, value]) => [key, callback(value, key)]),
+	)
 }
 
 export { filterObject, mapObject }

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

@@ -18,6 +18,12 @@ describe('condition optimizer', () => {
 		})
 	})
 
+	it('keep never in OR', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [{ never: true }],
+		}), false)
+	})
+
 	it('optimizes OR with never', () => {
 		assert.deepStrictEqual(optimizer.optimize({
 			or: [{ eq: 1 }, { never: true }],

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

@@ -15,8 +15,10 @@ const execute = (test: Test) => {
 		.entity('Entity2', e => e.oneHasOne('xyz', r => r.target('Entity1')))
 		.buildSchema()
 	const merger = new PermissionFactory(schema)
+	const initialAcl = JSON.parse(JSON.stringify(test.acl))
 	const result = merger.create(test.acl, test.roles)
 	assert.deepStrictEqual(result, test.result)
+	assert.deepStrictEqual(test.acl, initialAcl)
 }
 
 describe('Permission merger', () => {

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

@@ -74,4 +74,20 @@ describe('where optimized', () => {
 			},
 		})
 	})
+
+	it('keep never', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{
+					or: [
+						{ url: { never: true } },
+						{ url: { never: true } },
+					],
+				},
+			],
+		}, model.entities.Image), {
+			id: { never: true },
+		},
+		)
+	})
 })