@contember/engine-content-api 1.2.0-alpha.3 → 1.2.0-alpha.6

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

@@ -0,0 +1,97 @@
+import { PredicateFactory, VariableInjector } from '../../../src/acl'
+import { SchemaDefinition as def } from '@contember/schema-definition'
+import { Acl, Model } from '@contember/schema'
+import { assert, describe, it } from 'vitest'
+
+namespace TestModel {
+	export class Author {
+		name = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		image = def.manyHasOne(Image, 'authors')
+	}
+
+	export class Article {
+		title = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		image = def.manyHasOne(Image, 'articles')
+	}
+
+	export class Image {
+		url = def.stringColumn().notNull()
+
+		articles = def.oneHasMany(Article, 'image')
+		authors = def.oneHasMany(Author, 'image')
+	}
+}
+const permissions: Acl.Permissions = {
+	Author: {
+		predicates: {
+			authorPredicate: {
+				isPublic: { eq: true },
+			},
+		},
+		operations: {
+			read: {
+				id: 'authorPredicate',
+				name: 'authorPredicate',
+				image: 'authorPredicate',
+			},
+		},
+	},
+	Article: {
+		predicates: {
+			articlePredicate: {
+				isPublic: { eq: true },
+			},
+		},
+		operations: {
+			read: {
+				id: 'articlePredicate',
+				title: 'articlePredicate',
+				image: 'articlePredicate',
+			},
+		},
+	},
+	Image: {
+		predicates: {
+			imagePredicate: {
+				or: [
+					{ authors: { isPublic: { eq: true } } },
+					{ articles: { isPublic: { eq: true } } },
+				],
+			},
+		},
+		operations: {
+			read: {
+				id: 'imagePredicate',
+				url: 'imagePredicate',
+			},
+		},
+	},
+}
+
+describe('Predicates factory', () => {
+	const schema = def.createModel(TestModel)
+
+	it('eliminates a predicate', () => {
+		const predicateFactory = new PredicateFactory(permissions, schema, new VariableInjector(schema, {}))
+		const image = schema.entities['Image']
+		const authorRelation = image.fields['authors'] as Model.AnyRelation
+		const predicate = predicateFactory.create(image, Acl.Operation.read, undefined, authorRelation)
+		assert.deepStrictEqual(predicate, {
+			or: [
+				{
+					authors: {
+						id: { always: true },
+					},
+				},
+				{
+					articles: {
+						isPublic: { eq: true },
+					},
+				},
+			],
+		})
+	})
+})
+

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

@@ -31,11 +31,14 @@ const permissions: Acl.Permissions = {
 			localePredicate: {
 				locale: 'localeVariable',
 			},
+			localePredicate2: {
+				locale: 'localeVariable',
+			},
 		},
 		operations: {
 			read: {
 				id: 'localePredicate',
-				title: 'localePredicate',
+				title: 'localePredicate2',
 				content: 'localePredicate',
 			},
 		},
@@ -45,17 +48,12 @@ const permissions: Acl.Permissions = {
 describe('Predicates injector', () => {
 
 	const variables: Acl.VariablesMap = {
-		localeVariable: {
-			definition: {
-				type: Acl.VariableType.condition,
-			},
-			value: [{ in: ['cs'] }],
-		},
+		localeVariable: { in: ['cs'] },
 	}
 	it('injects predicate', () => {
 		const injector = new PredicatesInjector(
 			schema,
-			new PredicateFactory(permissions, new VariableInjector(schema, variables)),
+			new PredicateFactory(permissions, schema, new VariableInjector(schema, variables)),
 		)
 		const result = injector.inject(schema.entities['PostLocale'], {})
 
@@ -67,21 +65,14 @@ describe('Predicates injector', () => {
 	it('merges predicate with explicit where', () => {
 		const injector = new PredicatesInjector(
 			schema,
-			new PredicateFactory(permissions, new VariableInjector(schema, variables)),
+			new PredicateFactory(permissions, schema, new VariableInjector(schema, variables)),
 		)
 		const result = injector.inject(schema.entities['PostLocale'], { id: { in: [1, 2] } })
 
 		assert.deepStrictEqual(result, {
 			and: [
 				{
-					and: [
-						{
-							id: { in: [1, 2] },
-						},
-						{
-							locale: { in: ['cs'] },
-						},
-					],
+					id: { in: [1, 2] },
 				},
 				{
 					locale: { in: ['cs'] },
@@ -93,7 +84,7 @@ describe('Predicates injector', () => {
 	it('injects predicate to where', () => {
 		const injector = new PredicatesInjector(
 			schema,
-			new PredicateFactory(permissions, new VariableInjector(schema, variables)),
+			new PredicateFactory(permissions, schema, new VariableInjector(schema, variables)),
 		)
 
 		const result = injector.inject(schema.entities['PostLocale'], { title: { eq: 'abc' } })

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

@@ -19,19 +19,8 @@ describe('Variable injector', () => {
 
 		const ids = ['91528a5c-839b-4114-9952-d661914a607f', '1e2f3937-a0b1-4105-8aae-6da8ac9fc146']
 		const injector = new VariableInjector(schema, {
-			site: {
-				definition: {
-					type: Acl.VariableType.entity,
-					entityName: 'Site',
-				},
-				value: ids,
-			},
-			locale: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ eq: 'cs' }],
-			},
+			site: { in: ids },
+			locale: { eq: 'cs' },
 		})
 		const result = injector.inject(schema.entities['PostLocale'], {
 			or: [

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

@@ -0,0 +1,77 @@
+import { describe, it, assert } from 'vitest'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+import { SchemaDefinition as def } from '@contember/schema-definition'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+
+namespace TestModel {
+	export class Author {
+		name = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		image = def.manyHasOne(Image, 'authors')
+	}
+
+	export class Article {
+		title = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		image = def.manyHasOne(Image, 'articles')
+	}
+
+	export class Image {
+		url = def.stringColumn().notNull()
+
+		articles = def.oneHasMany(Article, 'image')
+		authors = def.oneHasMany(Author, 'image')
+	}
+}
+
+describe('where optimized', () => {
+	const conditionOptimizer = new ConditionOptimizer()
+	const model = def.createModel(TestModel)
+	const whereOptimizer = new WhereOptimizer(model, conditionOptimizer)
+
+
+	it('removes unnecessary condition', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{
+					authors: { isPublic: { eq: true } },
+				},
+				{
+					articles: { isPublic: { always: true } },
+				},
+			],
+		}, model.entities.Image), {
+			id: { always: true },
+		})
+	})
+
+	it('keep condition', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{
+					authors: { isPublic: { eq: true } },
+				},
+			],
+		}, model.entities.Image), {
+			authors: { isPublic: { eq: true } },
+		})
+	})
+
+	it('do not swap AND and a field', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			authors: {
+				and: [
+					{ isPublic: { eq: true } },
+					{ name: { eq: 'bar' } },
+				],
+			},
+		}, model.entities.Image), {
+			authors: {
+				and: [
+					{ isPublic: { eq: true } },
+					{ name: { eq: 'bar' } },
+				],
+			},
+		})
+	})
+})