@contember/engine-content-api 1.2.0-alpha.3 → 1.2.0-alpha.6

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

@@ -7,7 +7,7 @@ import { testUuid } from '../../../../../src/testUuid'
 
 const schema = new SchemaBuilder()
 	.enum('locale', ['cs', 'en'])
-	.entity('Post', entityBuilder => entityBuilder.oneHasMany('locales', c => c.target('PostLocale')))
+	.entity('Post', entityBuilder => entityBuilder.oneHasMany('locales', c => c.target('PostLocale').ownedBy('post')))
 	.entity('PostLocale', entity =>
 		entity
 			.column('title', column => column.type(Model.ColumnType.String))
@@ -34,6 +34,7 @@ const permissions: Acl.Permissions = {
 		operations: {
 			read: {
 				id: true,
+				post: true,
 				title: 'localePredicate',
 			},
 		},
@@ -45,12 +46,7 @@ test('querying id and title', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			localeVariable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['cs'] }],
-			},
+			localeVariable: { in: ['cs'] },
 		},
 		query: GQL`
         query {
@@ -126,12 +122,7 @@ test('querying with extra where', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			localeVariable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['cs'] }],
-			},
+			localeVariable: { in: ['cs'] },
 		},
 		query: GQL`
         query {
@@ -177,12 +168,7 @@ test('querying only id', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			localeVariable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['cs'] }],
-			},
+			localeVariable: { in: ['cs'] },
 		},
 		query: GQL`
         query {
@@ -254,12 +240,7 @@ test('querying on nested field', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			localeVariable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['cs'] }],
-			},
+			localeVariable: { in: ['cs'] },
 		},
 		query: GQL`
         query {
@@ -294,7 +275,7 @@ test('querying on nested field', async () => {
                          "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 (?, ?) and false`,
+                       where "root_"."post_id" in (?, ?)`,
 				parameters: ['cs', testUuid(1), testUuid(2)],
 				response: {
 					rows: [

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

@@ -58,12 +58,7 @@ test('querying post + author name', async () => {
 		schema: schema,
 		permissions: permissions,
 		variables: {
-			countryVariable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['Czechia'] }],
-			},
+			countryVariable: { in: ['Czechia'] },
 		},
 		query: GQL`
         query {

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

@@ -0,0 +1,130 @@
+import { SchemaDefinition as def } 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'
+
+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',
+			},
+		},
+	},
+}
+
+test('predicate with OR', async () => {
+	await execute({
+		schema: def.createModel(TestModel),
+		permissions: permissions,
+		variables: {},
+		query: GQL`
+        query {
+          listAuthor {
+            id
+            image {
+            	url
+            }
+          }
+        }`,
+		executes: [
+			{
+				sql: SQL`SELECT "root_"."id" AS "root_id", "root_"."image_id" AS "root_image"
+						 FROM "public"."author" AS "root_"
+						 WHERE "root_"."is_public" = ?`,
+				parameters: [true],
+				response: {
+					rows: [
+						{
+							root_id: testUuid(1),
+							root_image: testUuid(2),
+						},
+					],
+				},
+			},
+			{
+				sql: `select "root_"."id" as "root_id", "root_"."url" as "root_url", "root_"."id" as "root_id"  from "public"."image" as "root_"  where "root_"."id" in (?)`,
+				parameters: [testUuid(2)],
+				response: {
+					rows: [
+						{
+							root_id: testUuid(2),
+							root_url: 'abcd',
+						},
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listAuthor: [
+					{
+						id: testUuid(1),
+						image: {
+							url: 'abcd',
+						},
+					},
+				],
+			},
+		},
+	})
+})
+
+

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

@@ -1,7 +1,7 @@
 import { test } from 'vitest'
 import { execute, failedTransaction, sqlTransaction } from '../../../../../src/test'
 import { SchemaBuilder } from '@contember/schema-definition'
-import { Acl, Model } from '@contember/schema'
+import {  Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../../src/tags'
 import { testUuid } from '../../../../../src/testUuid'
 
@@ -35,12 +35,7 @@ test('update name', async () => {
 			},
 		},
 		variables: {
-			name_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['John', 'Jack'] }],
-			},
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...sqlTransaction([
@@ -103,12 +98,7 @@ test('update name - denied', async () => {
 			},
 		},
 		variables: {
-			name_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['John', 'Jack'] }],
-			},
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...failedTransaction([
@@ -123,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,
 				},
 			]),
@@ -186,18 +176,8 @@ test('update m:n', async () => {
 			},
 		},
 		variables: {
-			post_name_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['Lorem ipsum', 'Dolor sit'] }],
-			},
-			category_name_variable: {
-				definition: {
-					type: Acl.VariableType.condition,
-				},
-				value: [{ in: ['foo', 'bar'] }],
-			},
+			post_name_variable: { in: ['Lorem ipsum', 'Dolor sit'] },
+			category_name_variable: { in: ['foo', 'bar'] },
 		},
 		query: GQL`mutation  {
           updatePost(by: {id: "${testUuid(1)}"}, data: {categories: [

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

@@ -18,12 +18,8 @@ describe('create acl variables', () => {
 					},
 				},
 			},
-		}, {
-			identityId: testUuid(1),
-			personId: null,
-			memberships: [{ role: 'author', variables: [{ name: 'authorID', values: [testUuid(2)] }] }],
-		}), {
-			author__authorID: { definition, value: [testUuid(2)] },
+		}, [{ role: 'author', variables: [{ name: 'authorID', condition: { in: [testUuid(2)] } }] }]), {
+			author__authorID: { in: [testUuid(2)] },
 		})
 	})
 
@@ -39,34 +35,9 @@ describe('create acl variables', () => {
 					entities: {},
 				},
 			},
-		}, {
-			identityId: testUuid(1),
-			personId: null,
-			memberships: [{ role: 'author', variables: [] }],
-		}), {
-			author__authorID: { definition, value: [] },
-		})
-	})
-
-
-	it('predefined', () => {
-		const definition: Acl.PredefinedVariable = { type: Acl.VariableType.predefined, value: 'identityID' }
-		assert.deepStrictEqual(createAclVariables({
-			roles: {
-				author: {
-					stages: '*',
-					variables: {
-						authorIdentity: definition,
-					},
-					entities: {},
-				},
-			},
-		}, {
-			identityId: testUuid(1),
-			personId: null,
-			memberships: [{ role: 'author', variables: [] }],
-		}), {
-			author__authorIdentity: { definition, value: [testUuid(1)] },
+		}, [{ role: 'author', variables: [] }],
+		), {
+			author__authorID: { never: true },
 		})
 	})
 })

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

@@ -11,6 +11,7 @@ const entity: Model.Entity = {
 	fields: {},
 	unique: {},
 	eventLog: { enabled: true },
+	indexes: {},
 }
 
 describe('order by helper', () => {