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

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 { Model } from '@contember/schema'
+import {  Model } from '@contember/schema'
 import { GQL, SQL } from '../../../../../src/tags'
 import { testUuid } from '../../../../../src/testUuid'
 
@@ -35,7 +35,7 @@ test('update name', async () => {
 			},
 		},
 		variables: {
-			name_variable: ['John', 'Jack'],
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...sqlTransaction([
@@ -98,7 +98,7 @@ test('update name - denied', async () => {
 			},
 		},
 		variables: {
-			name_variable: ['John', 'Jack'],
+			name_variable: { in: ['John', 'Jack'] },
 		},
 		executes: [
 			...failedTransaction([
@@ -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,
 				},
 			]),
@@ -176,8 +176,8 @@ test('update m:n', async () => {
 			},
 		},
 		variables: {
-			post_name_variable: ['Lorem ipsum', 'Dolor sit'],
-			category_name_variable: ['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/integration/graphQlSchema/graphQlSchemaBuilder.test.ts

@@ -30,20 +30,20 @@ const testSchema = async (test: Test) => {
 	const graphQlSchemaBuilder = schemaFactory.create(schemaWithAcl, authorizator)
 	const graphQlSchema = graphQlSchemaBuilder.build()
 
-	const result = await graphql(
-		graphQlSchema,
-		`
+	const result = await graphql({
+		schema: graphQlSchema,
+		source: `
 			{
 				_info {
 					description
 				}
 			}
 		`,
-	)
+	})
 	const errors = (result.errors || []).map(it => it.message)
 	assert.deepEqual(errors, [])
 
-	const textSchema = printSchema(graphQlSchema)
+	const textSchema = printSchema(graphQlSchema) + '\n'
 
 	const filename = path.join(__dirname, test.graphQlSchemaFile)
 	let expectedSchema: string

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

@@ -5,24 +5,21 @@ import { testUuid } from '@contember/engine-api-tester'
 
 describe('create acl variables', () => {
 
+	const definition: Acl.EntityVariable = { type: Acl.VariableType.entity, entityName: 'Author' }
 	it('prefix from memberships', () => {
 		assert.deepStrictEqual(createAclVariables({
 			roles: {
 				author: {
 					stages: '*',
 					variables: {
-						authorID: { type: Acl.VariableType.entity, entityName: 'Author' },
+						authorID: definition,
 					},
 					entities: {
 					},
 				},
 			},
-		}, {
-			identityId: testUuid(1),
-			personId: null,
-			memberships: [{ role: 'author', variables: [{ name: 'authorID', values: [testUuid(2)] }] }],
-		}), {
-			author__authorID: [testUuid(2)],
+		}, [{ role: 'author', variables: [{ name: 'authorID', condition: { in: [testUuid(2)] } }] }]), {
+			author__authorID: { in: [testUuid(2)] },
 		})
 	})
 
@@ -33,38 +30,14 @@ describe('create acl variables', () => {
 				author: {
 					stages: '*',
 					variables: {
-						authorID: { type: Acl.VariableType.entity, entityName: 'Author' },
+						authorID: definition,
 					},
 					entities: {},
 				},
 			},
-		}, {
-			identityId: testUuid(1),
-			personId: null,
-			memberships: [{ role: 'author', variables: [] }],
-		}), {
-			author__authorID: [],
-		})
-	})
-
-
-	it('predefined', () => {
-		assert.deepStrictEqual(createAclVariables({
-			roles: {
-				author: {
-					stages: '*',
-					variables: {
-						authorIdentity: { type: Acl.VariableType.predefined, value: 'identityID' },
-					},
-					entities: {},
-				},
-			},
-		}, {
-			identityId: testUuid(1),
-			personId: null,
-			memberships: [{ role: 'author', variables: [] }],
-		}), {
-			author__authorIdentity: [testUuid(1)],
+		}, [{ role: 'author', variables: [] }],
+		), {
+			author__authorID: { never: true },
 		})
 	})
 })

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

@@ -0,0 +1,135 @@
+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('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 }],
+		}), { 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', () => {

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', () => {