@contember/engine-content-api 1.2.0-alpha.12 → 1.2.0-alpha.14

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

@@ -63,26 +63,23 @@ test('querying id and title', async () => {
         }`,
 		executes: [
 			{
-				sql: SQL`select
-                         "root_"."id" as "root_id",
-                         case when "root_"."locale" in (?) then "root_"."title" else null end as "root_title",
-                         "root_"."locale" in (?) as "root__meta_title_readable",
-                         false as "root__meta_title_updatable"
-                       from "public"."post_locale" as "root_"`,
-				parameters: ['cs', 'cs'],
+				sql: SQL`SELECT
+							 "root_"."id" AS "root_id",
+							 "root_"."locale" IN (?) AS "root___predicate_localePredicate",
+							 "root_"."title" AS "root_title"
+						 FROM "public"."post_locale" AS "root_"`,
+				parameters: ['cs'],
 				response: {
 					rows: [
 						{
 							root_id: testUuid(1),
 							root_title: null,
-							root__meta_title_readable: false,
-							root__meta_title_updatable: false,
+							root___predicate_localePredicate: false,
 						},
 						{
 							root_id: testUuid(2),
 							root_title: 'bar',
-							root__meta_title_readable: true,
-							root__meta_title_updatable: false,
+							root___predicate_localePredicate: true,
 						},
 					],
 				},
@@ -134,8 +131,9 @@ test('querying with extra where', async () => {
 		executes: [
 			{
 				sql: SQL`select
-                         "root_"."id" as "root_id",
-                         case when "root_"."locale" in (?) then "root_"."title" else null end as "root_title"
+							 "root_"."id" as "root_id",
+							 "root_"."locale" in (?) as "root___predicate_localePredicate",
+							 "root_"."title" as "root_title"
                        from "public"."post_locale" as "root_"
                        where "root_"."title" = ? and "root_"."locale" in (?)`,
 				parameters: ['cs', 'foo', 'cs'],
@@ -144,7 +142,7 @@ test('querying with extra where', async () => {
 						{
 							root_id: testUuid(1),
 							root_title: 'foo',
-							root_title__readable: true,
+							root___predicate_localePredicate: true,
 						},
 					],
 				},
@@ -217,10 +215,11 @@ test('not defined acl variable', async () => {
         }`,
 		executes: [
 			{
-				sql: SQL`select
-                         "root_"."id" as "root_id",
-                         case when false then "root_"."title" else null end as "root_title"
-                       from "public"."post_locale" as "root_"`,
+				sql: SQL`
+					select "root_"."id" as "root_id",
+					       false as "root___predicate_localePredicate",
+					       "root_"."title" as "root_title"
+					from "public"."post_locale" as "root_"`,
 				parameters: [],
 				response: {
 					rows: [],
@@ -270,23 +269,25 @@ test('querying on nested field', async () => {
 				},
 			},
 			{
-				sql: SQL`select
-                         "root_"."post_id" as "__grouping_key",
-                         "root_"."id" as "root_id",
-                         case when "root_"."locale" in (?) then "root_"."title" else null end as "root_title"
-                       from "public"."post_locale" as "root_"
-                       where "root_"."post_id" in (?, ?)`,
+				sql: SQL`
+					select "root_"."post_id" as "__grouping_key",
+					       "root_"."id" as "root_id",
+					       "root_"."locale" in (?) as "root___predicate_localePredicate",
+					       "root_"."title" as "root_title"
+					from "public"."post_locale" as "root_" where "root_"."post_id" in (?, ?)`,
 				parameters: ['cs', testUuid(1), testUuid(2)],
 				response: {
 					rows: [
 						{
 							__grouping_key: testUuid(1),
 							root_id: testUuid(3),
-							root_title: null,
+							root___predicate_localePredicate: false,
+							root_title: 'foo',
 						},
 						{
 							__grouping_key: testUuid(2),
 							root_id: testUuid(4),
+							root___predicate_localePredicate: true,
 							root_title: 'bar',
 						},
 					],

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/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 } } } },
 			})
 		})