@contember/engine-content-api 1.2.0-alpha.11 → 1.2.0-alpha.13

package/tests/cases/integration/graphQlRequests/query/acl/nestedPredicate.test.ts

@@ -90,17 +90,20 @@ test('querying post + author name', async () => {
 				},
 			},
 			{
-				sql: SQL`select
-                         "root_"."id" as "root_id",
-                         case when "root_country"."name" in (?) then "root_"."name" else null end as "root_name",
-                         "root_"."id" as "root_id"
-                       from "public"."author" as "root_" left join "public"."country" as "root_country" on "root_"."country_id" = "root_country"."id"
-                       where "root_"."id" in (?, ?)`,
+				sql: SQL`SELECT
+							 "root_"."id" AS "root_id",
+							 "root_country"."name" IN (?) AS "root___predicate_countryPredicate",
+							 "root_"."name" AS "root_name",
+							 "root_"."id" AS "root_id"
+						 FROM "public"."author" AS "root_"
+						 LEFT JOIN "public"."country" AS "root_country" ON "root_"."country_id" = "root_country"."id"
+						 WHERE "root_"."id" IN (?, ?)`,
 				parameters: ['Czechia', testUuid(3), testUuid(4)],
 				response: {
 					rows: [
 						{
 							root_id: testUuid(3),
+							root___predicate_countryPredicate: true,
 							root_name: 'John',
 						},
 					],

package/tests/cases/integration/graphQlRequests/query/acl/rowPredicateSubset.test.ts

@@ -0,0 +1,104 @@
+import { SchemaDefinition as def, AclDefinition as acl, createSchema } from '@contember/schema-definition'
+import { Acl } from '@contember/schema'
+import { test } from 'vitest'
+import { execute } from '../../../../../src/test'
+import { GQL, SQL } from '../../../../../src/tags'
+import { testUuid } from '../../../../../src/testUuid'
+import { PermissionFactory } from '../../../../../../src'
+
+
+namespace RowPredicateSubset {
+	export const readerRole = acl.createRole('reader')
+	@acl.allow(readerRole, {
+		when: {
+			isPublished: { eq: true },
+		},
+		read: ['isPublished', 'isUnlocked', 'title'],
+	})
+	@acl.allow(readerRole, {
+		when: {
+			and: [
+				{ isUnlocked: { eq: true } },
+				{ isPublished: { eq: true } },
+			],
+		},
+		read: ['content'],
+	})
+	export class Article {
+		isPublished = def.boolColumn()
+		isUnlocked = def.boolColumn()
+		title = def.stringColumn()
+		content = def.stringColumn()
+	}
+}
+
+
+
+test('row level predicate includes main predicate', async () => {
+	const schema = createSchema(RowPredicateSubset)
+
+	const permissions = new PermissionFactory(schema.model).create(schema.acl, ['reader'])
+
+	await execute({
+		schema: schema.model,
+		permissions: permissions,
+		variables: {},
+		query: GQL`
+        query {
+          listArticle {
+            id
+            title
+            content
+          }
+        }`,
+		executes: [
+			{
+				sql: SQL`SELECT
+							 "root_"."id" AS "root_id",
+							 TRUE AS "root___predicate_isPublished_eq_true",
+							 "root_"."title" AS "root_title",
+							 "root_"."is_unlocked" = ? AS "root___predicate_and_isUnlocked_eq_true_isPubl",
+							 "root_"."content" AS "root_content"
+						 FROM "public"."article" AS "root_"
+						 WHERE "root_"."is_published" = ?`,
+				parameters: [true, true],
+				response: {
+					rows: [
+						{
+							root_id: testUuid(1),
+							root___predicate_isPublished_eq_true: true,
+							root_title: 'Hello',
+							root___predicate_and_isUnlocked_eq_true_isPubl: false,
+							root_content: 'Foo bar',
+						},
+						{
+							root_id: testUuid(2),
+							root___predicate_isPublished_eq_true: true,
+							root_title: 'Hello 2',
+							root___predicate_and_isUnlocked_eq_true_isPubl: true,
+							root_content: 'Lorem ipsum',
+						},
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listArticle: [
+					{
+						id: testUuid(1),
+						title: 'Hello',
+						content: null,
+					},
+					{
+						id: testUuid(2),
+						title: 'Hello 2',
+						content: 'Lorem ipsum',
+					},
+				],
+			},
+		},
+	})
+})
+
+

package/tests/cases/integration/graphQlRequests/query/graphqlFeatures/alias.test.ts

@@ -77,15 +77,13 @@ test('aliases', async () => {
         }`,
 		executes: [
 			{
-				sql: SQL`select
-                     "root_"."id" as "root_idx",
-                     "root_"."name" as "root_name1",
-                     "root_"."name" as "root_name2",
-                     true as "root_meta_name1_readable1",
-                     true as "root_meta_name1_readable2",
-                     "root_"."name" = ? as "root_meta_name1_updatable1",
-                     "root_"."id" as "root_id"
-                   from "public"."author" as "root_"`,
+				sql: SQL`SELECT
+							 "root_"."id" AS "root_idx",
+							 "root_"."name" AS "root_name1",
+							 "root_"."name" AS "root_name2",
+							 "root_"."name" = ? AS "root___predicate_name_eq",
+							 "root_"."id" AS "root_id"
+						 FROM "public"."author" AS "root_"`,
 				parameters: ['John'],
 				response: {
 					rows: [
@@ -94,9 +92,7 @@ test('aliases', async () => {
 							root_idx: testUuid(1),
 							root_name1: 'John',
 							root_name2: 'John',
-							root_meta_name1_readable1: true,
-							root_meta_name1_readable2: true,
-							root_meta_name1_updatable1: false,
+							root___predicate_name_eq: true,
 						},
 					],
 				},
@@ -111,7 +107,7 @@ test('aliases', async () => {
 							name1: {
 								readable1: true,
 								readable2: true,
-								updatable1: false,
+								updatable1: true,
 							},
 						},
 						name1: 'John',

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

@@ -5,6 +5,8 @@ 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'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { testUuid } from '@contember/engine-api-tester'
 
 
 
@@ -157,14 +159,14 @@ namespace DeepFilterModel {
 
 
 describe('predicates injector elimination', () => {
-	it('eliminates predicates in where', () => {
-		const schema = createSchema(DeepFilterModel)
-		const permissions = new PermissionFactory(schema.model).create(schema.acl, ['reader'])
+	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 injector = new PredicatesInjector(
+		schema.model,
+		new PredicateFactory(permissions, schema.model, new VariableInjector(schema.model, {})),
+	)
+	it('eliminates predicates in where', () => {
 		const injected = injector.inject(schema.model.entities.Article, {
 			coverPhoto: { image: { tags: { label: { eq: 'foo' } } } },
 		})
@@ -173,4 +175,32 @@ describe('predicates injector elimination', () => {
 
 		assert.deepStrictEqual(result, { and: [{ coverPhoto: { image: { tags: { label: { eq: 'foo' } } } } }, { isPublished: { eq: true } }] })
 	})
+
+	it('eliminate back referencing predicate', () => {
+		const relation = acceptFieldVisitor(schema.model, schema.model.entities.Article, 'coverPhoto', {
+			visitColumn: () => {
+				throw new Error()
+			},
+			visitRelation: ctx => ctx,
+		})
+		const injected = injector.inject(schema.model.entities.ImageUse, {
+			articles: { id: { in: [testUuid(1)] } },
+		}, relation)
+
+		assert.deepStrictEqual(injected, {
+			and: [
+				{
+					articles: {
+						and: [
+							{ id: { in: [testUuid(1)] } },
+							{ id: { always: true } },
+						],
+					},
+				},
+				{
+					articles: { id: { always: true } },
+				},
+			],
+		})
+	})
 })

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

@@ -0,0 +1,84 @@
+import { describe, it, assert } from 'vitest'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+import { ConditionBuilder, JoinBuilder, PathFactory, WhereBuilder } from '../../../src/mapper'
+import { Compiler, SelectBuilder } from '@contember/database'
+import { Input, Schema } from '@contember/schema'
+
+namespace WhereBuilderModel {
+	export class Author {
+		name = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		articles = def.oneHasMany(Article, 'author')
+	}
+
+	export class Article {
+		title = def.stringColumn()
+		isPublic = def.boolColumn().notNull()
+		author = def.manyHasOne(Author, 'articles')
+	}
+}
+
+const createWhere = (schema: Schema, where: Input.Where) => {
+	const pathFactory = new PathFactory()
+	const joinBuilder = new JoinBuilder(schema.model)
+	const conditionBuilder = new ConditionBuilder()
+	const whereOptimizer = new WhereOptimizer(schema.model, new ConditionOptimizer())
+	const whereBuilder = new WhereBuilder(schema.model, joinBuilder, conditionBuilder, pathFactory, whereOptimizer)
+
+	const qb = SelectBuilder.create()
+		.from('author', 'root_')
+
+	return whereBuilder.build(qb, schema.model.entities.Author, pathFactory.create([]), where).options.where.compile().sql
+}
+
+describe('where builder', () => {
+	it('where on has-many relation with AND outside', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			and: [
+				{
+					articles: { isPublic: { eq: true } },
+				},
+				{
+					articles: { title: { eq: 'Hello' } },
+				},
+			],
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from "__SCHEMA__"."article" as "sub_"  where "root_"."id" = "sub_"."author_id" and "sub_"."is_public" = ?) and exists (select 1  from "__SCHEMA__"."article" as "sub_"  where "root_"."id" = "sub_"."author_id" and "sub_"."title" = ?)',
+		)
+	})
+
+	it('where on has-many relation with AND inside', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			articles: {
+				and: [
+					{ isPublic: { eq: true } },
+					{ title: { eq: 'Hello' } },
+				],
+			},
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from "__SCHEMA__"."article" as "sub_"  where "root_"."id" = "sub_"."author_id" and "sub_"."is_public" = ? and "sub_"."title" = ?)',
+		)
+	})
+
+
+	it('where on has-many relation with isNull', () => {
+		const schema = createSchema(WhereBuilderModel)
+		const where = createWhere(schema, {
+			articles: {
+				id: { isNull: true },
+			},
+		})
+		assert.equal(
+			where,
+			' where exists (select 1  from (select "root_"."id") as "sub2_" left join  "__SCHEMA__"."article" as "sub_" on  "sub2_"."id" = "sub_"."author_id"  where "sub_"."id" is null)',
+		)
+	})
+})

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

@@ -200,14 +200,15 @@ describe('where optimized', () => {
 	describe('remove id predicates', () => {
 
 		it('remove ID predicate when traversing from a relation - always', () => {
-			assert.deepStrictEqual(whereOptimizer.optimize({
-				image: { id: { isNull: false } },
-			}, model.entities.Author, [acceptFieldVisitor(model, 'Image', 'authors', {
+			const relationPath = [acceptFieldVisitor(model, 'Image', 'authors', {
 				visitColumn: () => {
 					throw new Error()
 				},
 				visitRelation: context => context,
-			})]), {
+			})]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				image: { id: { isNull: false } },
+			}, model.entities.Author, { relationPath }), {
 				id: { always: true },
 			})
 		})
@@ -216,12 +217,12 @@ describe('where optimized', () => {
 		it('remove ID predicate when traversing from a relation - never', () => {
 			assert.deepStrictEqual(whereOptimizer.optimize({
 				image: { id: { isNull: true } },
-			}, model.entities.Author, [acceptFieldVisitor(model, 'Image', 'authors', {
+			}, model.entities.Author, { relationPath: [acceptFieldVisitor(model, 'Image', 'authors', {
 				visitColumn: () => {
 					throw new Error()
 				},
 				visitRelation: context => context,
-			})]), {
+			})] }), {
 				id: { never: true },
 			})
 		})
@@ -229,28 +230,27 @@ describe('where optimized', () => {
 		it('remove ID predicate when traversing in where', () => {
 			assert.deepStrictEqual(whereOptimizer.optimize({
 				authors: { image: { id: { isNull: false } } },
-			}, model.entities.Image, []), {
+			}, model.entities.Image), {
 				id: { always: true },
 			})
 		})
 
 		it('do not remove ID predicate when traversing from a has-many relation', () => {
-			assert.deepStrictEqual(whereOptimizer.optimize({
-				authors: { id: { isNull: false } },
-			}, model.entities.Image, [acceptFieldVisitor(model, 'Author', 'image', {
+			const relationPath = [acceptFieldVisitor(model, 'Author', 'image', {
 				visitColumn: () => {
 					throw new Error()
 				},
 				visitRelation: context => context,
-			})]), {
+			})]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				authors: { id: { isNull: false } },
+			}, model.entities.Image, { relationPath }), {
 				authors: { id: { isNull: false } },
 			})
 		})
 
 		it('do not remove ID predicate when traversing from a nested has-many relation', () => {
-			assert.deepStrictEqual(whereOptimizer.optimize({
-				articles: { author: { id: { isNull: false } } },
-			}, model.entities.Image, [
+			const relationPath = [
 				acceptFieldVisitor(model, 'Author', 'articles', {
 					visitColumn: () => {
 						throw new Error()
@@ -263,7 +263,10 @@ describe('where optimized', () => {
 					},
 					visitRelation: context => context,
 				}),
-			]), {
+			]
+			assert.deepStrictEqual(whereOptimizer.optimize({
+				articles: { author: { id: { isNull: false } } },
+			}, model.entities.Image, { relationPath }), {
 				articles: { author: { id: { isNull: false } } },
 			})
 		})
@@ -271,7 +274,7 @@ describe('where optimized', () => {
 		it('do not remove ID predicate when traversing in where over has-many relation', () => {
 			assert.deepStrictEqual(whereOptimizer.optimize({
 				image: { authors: { id: { isNull: false } } },
-			}, model.entities.Author, []), {
+			}, model.entities.Author), {
 				image: { authors: { id: { isNull: false } } },
 			})
 		})
@@ -280,7 +283,7 @@ describe('where optimized', () => {
 		it('do not remove ID predicate when traversing in where over has-many relation - nested', () => {
 			assert.deepStrictEqual(whereOptimizer.optimize({
 				image: { authors: { image: { id: { isNull: false } } } },
-			}, model.entities.Author, []), {
+			}, model.entities.Author), {
 				image: { authors: { image: { id: { isNull: false } } } },
 			})
 		})