@contember/engine-content-api 1.2.0-alpha.8 → 1.2.0-beta.1

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/filter/manyHasManyOwnerRelation.test.ts

@@ -22,11 +22,13 @@ test('Post by category name (where many has many owning)', async () => {
         }`,
 		executes: [
 			{
-				sql: SQL`select "root_"."id" as "root_id"
-                     from "public"."post" as "root_"
-                     where exists (select 1
-                                            from "public"."post_categories" as "junction_" inner join "public"."category" as "sub_" on "junction_"."category_id" = "sub_"."id"
-                                            where "root_"."id" = "junction_"."post_id"  and "sub_"."name" = ?)`,
+				sql: SQL`
+					select "root_"."id" as "root_id"
+					from "public"."post" as "root_"
+					where exists (select 1
+						from "public"."post_categories" as "root_categories_junction_"
+						inner join  "public"."category" as "root_categories" on  "root_categories_junction_"."category_id" = "root_categories"."id"
+						where "root_"."id" = "root_categories_junction_"."post_id" and "root_categories"."name" = ?)`,
 				parameters: ['Stuff'],
 				response: {
 					rows: [
@@ -73,10 +75,11 @@ test('Post by category ids (where many has many owning)', async () => {
 		executes: [
 			{
 				sql: SQL`select "root_"."id" as "root_id"
-                     from "public"."post" as "root_"
-                     where exists (select 1
-                                            from "public"."post_categories" as "junction_"
-                                            where "root_"."id" = "junction_"."post_id" and "junction_"."category_id" in (?, ?))`,
+						from "public"."post" as "root_"
+						where exists (select 1
+						              from "public"."post_categories" as "root_categories_junction_"
+						              where "root_"."id" = "root_categories_junction_"."post_id" and "root_categories_junction_"."category_id" in (?, ?))
+				`,
 				parameters: [testUuid(10), testUuid(11)],
 				response: {
 					rows: [
@@ -131,12 +134,11 @@ test('Post by category tag name (where multiple many has many owning)', async ()
 			{
 				sql: SQL`
 					select "root_"."id" as "root_id"  from "public"."post" as "root_"
-					where exists (select 1
-						from "public"."post_categories" as "junction_"
-						inner join  "public"."category" as "sub_" on  "junction_"."category_id" = "sub_"."id"
-						left join  "public"."category_tags_but_with_very_very_very_long_name_so_it_reaches_postgresql_alias_length_limit" as "sub_x_sub_tagsButWithVeryVeryVeryLongNameSoItReachesPostgresq_2" on  "sub_"."id" = "sub_x_sub_tagsButWithVeryVeryVeryLongNameSoItReachesPostgresq_2"."category_id"
-						left join  "public"."tag" as "sub_tagsButWithVeryVeryVeryLongNameSoItReachesPostgresqlAlias_1" on  "sub_x_sub_tagsButWithVeryVeryVeryLongNameSoItReachesPostgresq_2"."tag_id" = "sub_tagsButWithVeryVeryVeryLongNameSoItReachesPostgresqlAlias_1"."id"
-						where "root_"."id" = "junction_"."post_id" and "sub_tagsButWithVeryVeryVeryLongNameSoItReachesPostgresqlAlias_1"."name" = ?)`,
+					where exists (select 1  from "public"."post_categories" as "root_categories_junction_"
+					    inner join  "public"."category" as "root_categories" on  "root_categories_junction_"."category_id" = "root_categories"."id"
+					    left join  "public"."category_tags_but_with_very_very_very_long_name_so_it_reaches_postgresql_alias_length_limit" as "root_categoriesx_root_categoriestagsButWithVeryVeryVeryLongNa_3" on  "root_categories"."id" = "root_categoriesx_root_categoriestagsButWithVeryVeryVeryLongNa_3"."category_id"
+					    left join  "public"."tag" as "root_categoriestagsButWithVeryVeryVeryLongNameSoItReachesPost_1" on  "root_categoriesx_root_categoriestagsButWithVeryVeryVeryLongNa_3"."tag_id" = "root_categoriestagsButWithVeryVeryVeryLongNameSoItReachesPost_1"."id"
+					    where "root_"."id" = "root_categories_junction_"."post_id" and "root_categoriestagsButWithVeryVeryVeryLongNameSoItReachesPost_1"."name" = ?)`,
 				parameters: ['Stuff'],
 				response: {
 					rows: [

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

@@ -23,11 +23,10 @@ test('Author by post title (where one has many)', async () => {
         }`,
 		executes: [
 			{
-				sql: SQL`select "root_"."id" as "root_id"
-                     from "public"."author" as "root_"
-                     where exists (select 1
-                                            from "public"."post" as "sub_"
-                                            where "root_"."id" = "sub_"."author_id" and "sub_"."title" = ?)`,
+				sql: SQL`select "root_"."id" as "root_id" from "public"."author" as "root_"
+                                 where exists (select 1
+                                               from "public"."post" as "root_posts"
+                                               where "root_"."id" = "root_posts"."author_id" and "root_posts"."title" = ?)`,
 				parameters: ['Hello'],
 				response: {
 					rows: [

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/integration/graphQlRequests/query/unique/oneHasManyUnique.test.ts

@@ -28,9 +28,11 @@ test('Post by post locale (one-has-many unique)', async () => {
         }`,
 		executes: [
 			{
-				sql: SQL`SELECT "root_"."id" AS "root_id"
-						         FROM "public"."post" AS "root_"
-						         WHERE EXISTS (SELECT 1 FROM "public"."post_locale" AS "sub_" WHERE "root_"."id" = "sub_"."post_id" AND "sub_"."id" = ?)`,
+				sql: SQL`select "root_"."id" as "root_id"
+						from "public"."post" as "root_"
+						where exists (select 1
+						              from "public"."post_locale" as "root_locales"
+						              where "root_"."id" = "root_locales"."post_id" and "root_locales"."id" = ?)`,
 				parameters: [testUuid(1)],
 				response: { rows: [{ root_id: testUuid(2) }] },
 			},

package/tests/cases/integration/graphQlRequests/update/manyHasManyInverse/delete.test.ts

@@ -22,12 +22,12 @@ test('delete', async () => {
 					parameters: [testUuid(2)],
 					response: { rows: [{ id: testUuid(2) }] },
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."post" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."post"
               where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlRequests/update/manyHasManyOwning/delete.test.ts

@@ -22,12 +22,12 @@ test('delete', async () => {
 					parameters: [testUuid(2)],
 					response: { rows: [{ id: testUuid(2) }] },
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."category" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."category" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."category"
               where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlRequests/update/manyHasOne/delete.test.ts

@@ -31,12 +31,12 @@ test('delete', async () => {
 						rows: [{ author_id: testUuid(1) }],
 					},
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."author" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."author" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."author"
               where "id" in (select "root_"."id"
@@ -99,12 +99,12 @@ test('delete with cascade', async () => {
 						rows: [{ author_id: testUuid(1) }],
 					},
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."author" as "root_" where "root_"."id" = ?`,
+					parameters: [testUuid(1)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."author" as "root_" where "root_"."id" = ?`,
-						parameters: [testUuid(1)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."author"
               where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlRequests/update/oneHasMany/combination.test.ts

@@ -22,12 +22,12 @@ test('delete and create', async () => {
 					parameters: [testUuid(2)],
 					response: { rows: [{ id: testUuid(2) }] },
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."post_locale" as "root_" where "root_"."locale" = ? and "root_"."post_id" = ?`,
+					parameters: ['cs', testUuid(2)],
+					response: { rows: [{ id: testUuid(9) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."post_locale" as "root_" where "root_"."locale" = ? and "root_"."post_id" = ?`,
-						parameters: ['cs', testUuid(2)],
-						response: { rows: [{ id: testUuid(9) }] },
-					},
 					{
 						sql: SQL`delete from "public"."post_locale"
               where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlRequests/update/oneHasMany/delete.test.ts

@@ -22,12 +22,12 @@ test('delete', async () => {
 					parameters: [testUuid(2)],
 					response: { rows: [{ id: testUuid(2) }] },
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."post_locale" as "root_" where "root_"."locale" = ? and "root_"."post_id" = ?`,
+					parameters: ['cs', testUuid(2)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."post_locale" as "root_" where "root_"."locale" = ? and "root_"."post_id" = ?`,
-						parameters: ['cs', testUuid(2)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."post_locale"
               where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlRequests/update/oneHasOneInverse/delete.test.ts

@@ -22,12 +22,12 @@ test('delete', async () => {
 					parameters: [testUuid(2)],
 					response: { rows: [{ id: testUuid(2) }] },
 				},
+				{
+					sql: SQL`select "root_"."id" from "public"."site" as "root_" where "root_"."setting_id" = ?`,
+					parameters: [testUuid(2)],
+					response: { rows: [{ id: testUuid(1) }] },
+				},
 				...sqlDeferred([
-					{
-						sql: SQL`select "root_"."id" from "public"."site" as "root_" where "root_"."setting_id" = ?`,
-						parameters: [testUuid(2)],
-						response: { rows: [{ id: testUuid(1) }] },
-					},
 					{
 						sql: SQL`delete from "public"."site"
               where "id" in (select "root_"."id"

package/tests/cases/integration/graphQlSchema/graphQlSchemaBuilder.test.ts

@@ -1,7 +1,7 @@
 import { graphql, printSchema } from 'graphql'
 import { Acl, Model } from '@contember/schema'
-import * as path from 'path'
-
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
 import {
 	AllowAllPermissionFactory,
 	SchemaBuilder,
@@ -10,7 +10,6 @@ import {
 } from '@contember/schema-definition'
 import { Authorizator, GraphQlSchemaBuilderFactory } from '../../../../src'
 import * as model from './model'
-import { promises as fs } from 'fs'
 import { assert, describe, it } from 'vitest'
 
 interface Test {

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

@@ -18,6 +18,12 @@ describe('condition optimizer', () => {
 		})
 	})
 
+	it('keep never in OR', () => {
+		assert.deepStrictEqual(optimizer.optimize({
+			or: [{ never: true }],
+		}), false)
+	})
+
 	it('optimizes OR with never', () => {
 		assert.deepStrictEqual(optimizer.optimize({
 			or: [{ eq: 1 }, { never: true }],

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

@@ -15,8 +15,10 @@ const execute = (test: Test) => {
 		.entity('Entity2', e => e.oneHasOne('xyz', r => r.target('Entity1')))
 		.buildSchema()
 	const merger = new PermissionFactory(schema)
+	const initialAcl = JSON.parse(JSON.stringify(test.acl))
 	const result = merger.create(test.acl, test.roles)
 	assert.deepStrictEqual(result, test.result)
+	assert.deepStrictEqual(test.acl, initialAcl)
 }
 
 describe('Permission merger', () => {

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

@@ -76,8 +76,14 @@ describe('Predicates factory', () => {
 	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)
+		const authorRelation = image.fields['authors'] as Model.OneHasManyRelation
+		const predicate = predicateFactory.create(image, Acl.Operation.read, undefined, {
+			type: 'manyHasOne',
+			entity: schema.entities.Author,
+			relation: schema.entities.Author.fields.image as Model.ManyHasOneRelation,
+			targetEntity: image,
+			targetRelation: authorRelation,
+		})
 		assert.deepStrictEqual(predicate, {
 			or: [
 				{

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

@@ -1,7 +1,12 @@
-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'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { testUuid } from '@contember/engine-api-tester'
 
 
 
@@ -45,6 +50,7 @@ const permissions: Acl.Permissions = {
 	},
 }
 
+
 describe('Predicates injector', () => {
 
 	const variables: Acl.VariablesMap = {
@@ -107,5 +113,94 @@ 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', () => {
+	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, {})),
+	)
+	it('eliminates predicates in where', () => {
+		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 } }] })
+	})
+
+	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 } },
+				},
+			],
+		})
+	})
+})