@contember/engine-content-api 1.1.1 → 1.2.0-alpha.10

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

@@ -1,7 +1,10 @@
-import { PredicateFactory, PredicatesInjector, VariableInjector } from '../../../src/acl'
-import { SchemaBuilder } from '@contember/schema-definition'
+import { PermissionFactory, PredicateFactory, PredicatesInjector, VariableInjector } from '../../../src/acl'
+import { SchemaBuilder, SchemaDefinition as def, AclDefinition as acl, createSchema } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'
 import { describe, it, assert } from 'vitest'
+import { PermissionsFactory } from '@contember/engine-system-api/dist/src/model'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
 
 
 
@@ -31,23 +34,30 @@ const permissions: Acl.Permissions = {
 			localePredicate: {
 				locale: 'localeVariable',
 			},
+			localePredicate2: {
+				locale: 'localeVariable',
+			},
 		},
 		operations: {
 			read: {
 				id: 'localePredicate',
-				title: 'localePredicate',
+				title: 'localePredicate2',
 				content: 'localePredicate',
 			},
 		},
 	},
 }
 
+
 describe('Predicates injector', () => {
 
+	const variables: Acl.VariablesMap = {
+		localeVariable: { in: ['cs'] },
+	}
 	it('injects predicate', () => {
 		const injector = new PredicatesInjector(
 			schema,
-			new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
+			new PredicateFactory(permissions, schema, new VariableInjector(schema, variables)),
 		)
 		const result = injector.inject(schema.entities['PostLocale'], {})
 
@@ -59,23 +69,14 @@ describe('Predicates injector', () => {
 	it('merges predicate with explicit where', () => {
 		const injector = new PredicatesInjector(
 			schema,
-			new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
+			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'] },
@@ -87,7 +88,7 @@ describe('Predicates injector', () => {
 	it('injects predicate to where', () => {
 		const injector = new PredicatesInjector(
 			schema,
-			new PredicateFactory(permissions, new VariableInjector(schema, { localeVariable: ['cs'] })),
+			new PredicateFactory(permissions, schema, new VariableInjector(schema, variables)),
 		)
 
 		const result = injector.inject(schema.entities['PostLocale'], { title: { eq: 'abc' } })
@@ -110,5 +111,66 @@ describe('Predicates injector', () => {
 			],
 		})
 	})
+
+
 })
 
+namespace DeepFilterModel {
+	export const readerRole = acl.createRole('reader')
+
+	@acl.allow(readerRole, {
+		when: { isPublished: { eq: true } },
+		read: ['coverPhoto'],
+	})
+	export class Article {
+		isPublished = def.boolColumn()
+		title = def.stringColumn()
+		coverPhoto = def.manyHasOne(ImageUse, 'articles')
+	}
+
+	@acl.allow(readerRole, {
+		when: { articles: acl.canRead('coverPhoto') },
+		read: true,
+	})
+	export class ImageUse {
+		articles = def.oneHasMany(Article, 'coverPhoto')
+		image = def.manyHasOne(Image, 'uses')
+	}
+
+	@acl.allow(readerRole, {
+		when: { uses: acl.canRead('image') },
+		read: true,
+	})
+	export class Image {
+		uses = def.oneHasMany(ImageUse, 'image')
+		url = def.stringColumn()
+		tags = def.manyHasMany(Tag)
+	}
+
+	@acl.allow(readerRole, {
+		read: true,
+	})
+	export class Tag {
+		label = def.stringColumn()
+	}
+}
+
+
+describe('predicates injector elimination', () => {
+	it('eliminates predicates in where', () => {
+		const schema = createSchema(DeepFilterModel)
+		const permissions = new PermissionFactory(schema.model).create(schema.acl, ['reader'])
+
+		const injector = new PredicatesInjector(
+			schema.model,
+			new PredicateFactory(permissions, schema.model, new VariableInjector(schema.model, {})),
+		)
+		const injected = injector.inject(schema.model.entities.Article, {
+			coverPhoto: { image: { tags: { label: { eq: 'foo' } } } },
+		})
+		const optimizer = new WhereOptimizer(schema.model, new ConditionOptimizer())
+		const result = optimizer.optimize(injected, schema.model.entities.Article)
+
+		assert.deepStrictEqual(result, { and: [{ coverPhoto: { image: { tags: { label: { eq: 'foo' } } } } }, { isPublished: { eq: true } }] })
+	})
+})

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

@@ -1,7 +1,7 @@
 import { VariableInjector } from '../../../src/acl'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Model } from '@contember/schema'
-import { describe, it, assert } from 'vitest'
+import { Acl, Model } from '@contember/schema'
+import { assert, describe, it } from 'vitest'
 
 describe('Variable injector', () => {
 
@@ -17,9 +17,10 @@ describe('Variable injector', () => {
 			)
 			.buildSchema()
 
+		const ids = ['91528a5c-839b-4114-9952-d661914a607f', '1e2f3937-a0b1-4105-8aae-6da8ac9fc146']
 		const injector = new VariableInjector(schema, {
-			site: [1, 2],
-			locale: 'cs',
+			site: { in: ids },
+			locale: { eq: 'cs' },
 		})
 		const result = injector.inject(schema.entities['PostLocale'], {
 			or: [
@@ -53,7 +54,7 @@ describe('Variable injector', () => {
 					and: [
 						{
 							post: {
-								site: { id: { in: [1, 2] } },
+								site: { id: { in: ids } },
 							},
 						},
 						{

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

@@ -0,0 +1,195 @@
+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' } },
+				],
+			},
+		})
+	})
+
+	it('keep never', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{
+					or: [
+						{ url: { never: true } },
+						{ url: { never: true } },
+					],
+				},
+			],
+		}, model.entities.Image), {
+			id: { never: true },
+		},
+		)
+	})
+
+
+	const A = { authors: { isPublic: { eq: true } } }
+	const B = { authors: { name: { eq: 'John' } } }
+	const C = { authors: { name: { eq: 'Jack' } } }
+
+	it('minimize: A || (A && B) => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ and: [A, B] },
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: (A && B) || A => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{ and: [A, B] },
+				A,
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: A && (A || B) => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ or: [A, B] },
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: (A || B) && A => A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{ or: [A, B] },
+				A,
+			],
+		}, model.entities.Image), A)
+	})
+
+	it('minimize: A && (!A || B) => A && B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ or: [{ not: A }, B] },
+			],
+		}, model.entities.Image), { and: [A, B] })
+	})
+
+	it('minimize: A || (!A && B) => A || B', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ and: [{ not: A }, B] },
+			],
+		}, model.entities.Image), { or: [A, B] })
+	})
+
+
+	it('minimize: A || !A => 1', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				A,
+				{ not: A },
+			],
+		}, model.entities.Image), { id: { always: true } })
+	})
+
+	it('minimize: A && !A => 0', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				A,
+				{ not: A },
+			],
+		}, model.entities.Image), { id: { never: true } })
+	})
+
+	it('minimize: !A && !A => !A', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			and: [
+				{ not: A },
+				{ not: A },
+			],
+		}, model.entities.Image), { not: A })
+	})
+
+
+	it('not minimize: (A && B) || (A && C)', () => {
+		assert.deepStrictEqual(whereOptimizer.optimize({
+			or: [
+				{ and: [A, B] },
+				{ and: [A, C] },
+			],
+		}, model.entities.Image), {
+			or: [
+				{ and: [A, B] },
+				{ and: [A, C] },
+			],
+		})
+	})
+})

package/tests/src/testGraphql.ts

@@ -10,10 +10,17 @@ export interface Test {
 }
 
 export const executeGraphQlTest = async (test: Test) => {
-	const rawResponse = await graphql(test.schema, test.query, null, test.context, test.queryVariables)
+	const rawResponse = await graphql({
+		schema: test.schema,
+		source: test.query,
+		contextValue: test.context,
+		variableValues: test.queryVariables,
+	})
 	const response = JSON.parse(JSON.stringify(rawResponse))
 	if ('errors' in rawResponse) {
-		console.error((rawResponse.errors as any)[0])
+		if (rawResponse.errors?.length === 1 && 'originalError' in (rawResponse.errors as any)[0]) {
+			throw (rawResponse.errors as any)[0].originalError
+		}
 		rawResponse.errors = (rawResponse.errors as any).map(({ message }: any) => ({ message }))
 	}
 	assert.deepStrictEqual(response, test.return)

package/jasmine.json

@@ -1,7 +0,0 @@
-{
-	"spec_files": [
-		"dist/tests/cases/**/*.js"
-	],
-	"stopSpecOnExpectationFailure": false,
-	"random": false
-}