@contember/engine-content-api 1.2.0-alpha.4 → 1.2.0-alpha.7

package/tests/cases/integration/graphQlRequests/query/filter/complexCondition.test.ts

@@ -25,7 +25,7 @@ test('Complex condition', async () => {
 			{
 				sql: SQL`select "root_"."id" as "root_id"
 from "public"."post" as "root_"
-where (("root_"."title" = ? or "root_"."title" = ?)
+where ("root_"."title" = ? or "root_"."title" = ?
       or not("root_"."title" < ?)
       or "root_"."title" is null and not("root_"."title" is null))`,
 				parameters: ['A', 'B', 'X'],

package/tests/cases/integration/graphQlRequests/query/filter/composedFilter.test.ts

@@ -19,7 +19,7 @@ test('Composed filter with nulls', async () => {
 			`,
 		executes: [
 			{
-				sql: SQL`select "root_"."id" as "root_id"  from "public"."post" as "root_"   where ("root_"."title" = ?)`,
+				sql: SQL`select "root_"."id" as "root_id"  from "public"."post" as "root_"   where "root_"."title" = ?`,
 				parameters: ['John'],
 				response: { rows: [{ root_id: testUuid(1) }] },
 			},

package/tests/cases/integration/graphQlRequests/query/relations/manyHasManyInverse.test.ts

@@ -171,3 +171,77 @@ test('empty many-has-many inverse relation', async () => {
 })
 
 
+test('Posts with filtered tags', async () => {
+	await execute({
+		schema: new SchemaBuilder()
+			.entity('Post', entity => entity)
+			.entity('Tag', entity => entity.column('name').manyHasMany('posts', relation => relation.target('Post').inversedBy('tags')))
+			.buildSchema(),
+		query: GQL`
+        query {
+          listPost {
+            id
+            tags(filter: {name: {eq: "Foo"}}) {
+				name
+            }
+          }
+        }
+			`,
+		executes: [
+			{
+				sql: SQL`select "root_"."id" as "root_id",
+					         "root_"."id" as "root_id"
+				         from "public"."post" as "root_"`,
+				response: {
+					rows: [{ root_id: testUuid(1) }, { root_id: testUuid(2) }],
+				},
+			},
+			{
+				sql: SQL`select "junction_"."post_id", "junction_"."tag_id"  from "public"."tag_posts" as "junction_" inner join  "public"."tag" as "root_" on  "junction_"."tag_id" = "root_"."id"  where "junction_"."post_id" in (?, ?) and "root_"."name" = ?`,
+				parameters: [testUuid(1), testUuid(2), 'Foo'],
+				response: {
+					rows: [
+						{ post_id: testUuid(1), tag_id: testUuid(3) },
+						{ post_id: testUuid(2), tag_id: testUuid(3) },
+					],
+				},
+			},
+			{
+				sql: SQL`
+					select "root_"."name" as "root_name",
+						"root_"."id" as "root_id"
+					from "public"."tag" as "root_"
+					where "root_"."id" in (?)`,
+				parameters: [testUuid(3)],
+				response: {
+					rows: [
+						{ root_id: testUuid(3), root_name: 'foo' },
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listPost: [
+					{
+						id: testUuid(1),
+						tags: [
+							{
+								name: 'foo',
+							},
+						],
+					},
+					{
+						id: testUuid(2),
+						tags: [
+							{
+								name: 'foo',
+							},
+						],
+					},
+				],
+			},
+		},
+	})
+})
+

package/tests/cases/integration/graphQlRequests/query/relations/manyHasManyOwning.test.ts

@@ -4,6 +4,83 @@ import { SchemaBuilder } from '@contember/schema-definition'
 import { GQL, SQL } from '../../../../../src/tags'
 import { testUuid } from '../../../../../src/testUuid'
 
+
+test('Posts with filtered tags', async () => {
+	await execute({
+		schema: new SchemaBuilder()
+			.entity('Post', entity => entity.manyHasMany('tags', relation => relation.target('Tag')))
+			.entity('Tag', entity => entity.column('name'))
+			.buildSchema(),
+		query: GQL`
+        query {
+          listPost {
+            id
+            tags(filter: {name: {eq: "Foo"}}) {
+				name
+            }
+          }
+        }
+			`,
+		executes: [
+			{
+				sql: SQL`select "root_"."id" as "root_id",
+					         "root_"."id" as "root_id"
+				         from "public"."post" as "root_"`,
+				response: {
+					rows: [{ root_id: testUuid(1) }, { root_id: testUuid(2) }],
+				},
+			},
+			{
+				sql: SQL`select "junction_"."tag_id", "junction_"."post_id"  from "public"."post_tags" as "junction_" inner join  "public"."tag" as "root_" on  "junction_"."tag_id" = "root_"."id"  where "junction_"."post_id" in (?, ?) and "root_"."name" = ?`,
+				parameters: [testUuid(1), testUuid(2), 'Foo'],
+				response: {
+					rows: [
+						{ post_id: testUuid(1), tag_id: testUuid(3) },
+						{ post_id: testUuid(2), tag_id: testUuid(3) },
+					],
+				},
+			},
+			{
+				sql: SQL`
+					select "root_"."name" as "root_name",
+						"root_"."id" as "root_id"
+					from "public"."tag" as "root_"
+					where "root_"."id" in (?)`,
+				parameters: [testUuid(3)],
+				response: {
+					rows: [
+						{ root_id: testUuid(3), root_name: 'foo' },
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listPost: [
+					{
+						id: testUuid(1),
+						tags: [
+							{
+								name: 'foo',
+							},
+						],
+					},
+					{
+						id: testUuid(2),
+						tags: [
+							{
+								name: 'foo',
+							},
+						],
+					},
+				],
+			},
+		},
+	})
+})
+
+
+
 test('Posts with paginated tags (many has many owning)', async () => {
 	await execute({
 		schema: new SchemaBuilder()

package/tests/cases/integration/graphQlRequests/update/acl/aclUpdate.test.ts

@@ -113,10 +113,10 @@ test('update name - denied', async () => {
                  ? :: text as "name",
                  "root_"."id"
                from "public"."author" as "root_"
-               where "root_"."id" = ? and false) update "public"."author"
+               where false) update "public"."author"
               set "name" = "newData_"."name" from "newData_"
               where "author"."id" = "newData_"."id" and false`,
-					parameters: ['John', testUuid(1)],
+					parameters: ['John'],
 					response: 0,
 				},
 			]),

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

@@ -0,0 +1,129 @@
+import { describe, it, assert } from 'vitest'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+
+describe('condition optimizer', () => {
+	const optimizer = new ConditionOptimizer()
+
+	it('remove OR when only 1', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [{ eq: 1 }],
+		}), { eq: 1 })
+	})
+
+	it('keep OR when > 1', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [{ eq: 1 }, { eq: 2 }],
+		}), {
+			or: [{ eq: 1 }, { eq: 2 }],
+		})
+	})
+
+	it('optimizes OR with never', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [{ eq: 1 }, { never: true }],
+		}), { eq: 1 })
+	})
+
+	it('optimizes OR with always', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [{ eq: 1 }, { always: true }],
+		}), true)
+	})
+
+	it('optimizes AND with never', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			and: [{ eq: 1 }, { never: true }],
+		}), false)
+	})
+
+	it('optimizes AND with always', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			and: [{ eq: 1 }, { always: true }],
+		}), { eq: 1 })
+	})
+
+	it('optimizes NOT with never', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			not: { never: true },
+		}), true)
+	})
+
+	it('optimizes NOT with always', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			not: { always: true },
+		}), false)
+	})
+
+	it('optimizes empty AND', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			and: [],
+		}), {})
+	})
+
+	it('optimizes empty OR', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [],
+		}), {})
+	})
+
+
+	it('flattens AND', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			eq: 0,
+			and: [
+				{ eq: 1 },
+				{
+					eq: 2,
+					and: [
+						{ eq: 3 },
+						{
+							eq: 4,
+							and: [{ eq: 5 }, { eq: 6 }],
+						},
+					],
+				},
+			],
+		}), { and: [{ eq: 0 }, { eq: 1 }, { eq: 2 }, { eq: 3 }, { eq: 4 }, { eq: 5 }, { eq: 6 }] })
+	})
+
+	it('flattens OR', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [
+				{ eq: 1 },
+				{
+
+					or: [
+						{ eq: 2 },
+						{ or: [{ eq: 3 }, { eq: 4 }] },
+					],
+				},
+			],
+		}), { or: [{ eq: 1 }, { eq: 2 }, { eq: 3 }, { eq: 4 }] })
+	})
+
+	it('flattens NOT', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			not: { not: { not: { eq: 1 } } },
+		}), { not: { eq: 1 } })
+	})
+
+	it('combine AND and OR', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [
+				{ and: [{ eq: 1 }, { eq: 2 }] },
+				{ and: [{ eq: 3 }, { eq: 4 }], eq: 5 },
+			],
+		}), { or: [
+			{ and: [{ eq: 1 }, { eq: 2 }] },
+			{ and: [{ eq: 3 }, { eq: 4 }, { eq: 5 }] },
+		] })
+	})
+
+	it('remove conditions with null value', () => {
+		assert.deepStrictEqual(optimizer.optimize({ eq: null }), {})
+	})
+
+	it('remove conditions with undefined value', () => {
+		assert.deepStrictEqual(optimizer.optimize({ eq: undefined }), {})
+	})
+})

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',
 			},
 		},
@@ -50,7 +53,7 @@ describe('Predicates injector', () => {
 	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'], {})
 
@@ -62,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'] },
@@ -88,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/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' } },
+				],
+			},
+		})
+	})
+})