@contember/engine-content-api 1.4.0-beta.2 → 1.4.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/engine-content-api",
-  "version": "1.4.0-beta.2",
+  "version": "1.4.0-rc.2",
   "license": "Apache-2.0",
   "main": "dist/src/index.js",
   "typings": "dist/src/index.d.ts",
@@ -13,19 +13,19 @@
     "test": "vitest --dir ./tests/cases --no-threads"
   },
   "dependencies": {
-    "@contember/database": "1.4.0-beta.2",
-    "@contember/dic": "1.4.0-beta.2",
-    "@contember/graphql-utils": "1.4.0-beta.2",
-    "@contember/logger": "1.4.0-beta.2",
-    "@contember/schema": "1.4.0-beta.2",
-    "@contember/schema-definition": "1.4.0-beta.2",
-    "@contember/schema-utils": "1.4.0-beta.2",
+    "@contember/database": "1.4.0-rc.2",
+    "@contember/dic": "1.4.0-rc.2",
+    "@contember/graphql-utils": "1.4.0-rc.2",
+    "@contember/logger": "1.4.0-rc.2",
+    "@contember/schema": "1.4.0-rc.2",
+    "@contember/schema-definition": "1.4.0-rc.2",
+    "@contember/schema-utils": "1.4.0-rc.2",
     "fast-deep-equal": "^3.1.3"
   },
   "devDependencies": {
-    "@contember/database-tester": "1.4.0-beta.2",
-    "@contember/engine-api-tester": "1.4.0-beta.2",
-    "@contember/schema-definition": "1.4.0-beta.2",
+    "@contember/database-tester": "1.4.0-rc.2",
+    "@contember/engine-api-tester": "1.4.0-rc.2",
+    "@contember/schema-definition": "1.4.0-rc.2",
     "@graphql-codegen/cli": "^5.0.0",
     "@graphql-codegen/typescript": "^4.0.1",
     "@graphql-codegen/typescript-operations": "^4.0.1",

package/src/mapper/select/SelectBuilder.ts

@@ -1,4 +1,4 @@
-import { Acl, Input, Model } from '@contember/schema'
+import { Acl, Input, Model, Value } from '@contember/schema'
 import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
 import { ColumnValueGetter, SelectHydrator, SelectRow } from './SelectHydrator'
 import { Path, PathFactory } from './Path'
@@ -138,15 +138,21 @@ export class SelectBuilder {
 				relationPath: this.relationPath,
 				addData: async ({ field, dataProvider, defaultValue, predicate }) => {
 					if (predicate === false) {
-						this.hydrator.addPromise(fieldPath, path.for(field), Promise.resolve({}), defaultValue ?? null)
+						this.hydrator.addPromise(fieldPath, () => null, Promise.resolve({}), defaultValue ?? null)
 						return
 					}
 					const predicateGetter = predicate !== undefined && predicate !== true ? addPredicate(predicate) : null
 					const columnName = getColumnName(this.schema, entity, field)
-					let ids = await this.getColumnValues(path.for(field), columnName, predicateGetter)
+					const parentValuePath = path.for(field)
+					let ids = await this.getColumnValues(parentValuePath, columnName, predicateGetter)
 
 					const data = ids.length > 0 ? dataProvider(ids) : Promise.resolve({})
-					this.hydrator.addPromise(fieldPath, path.for(field), data, defaultValue ?? null)
+					this.hydrator.addPromise(
+						fieldPath,
+						row => predicateGetter === null || predicateGetter(row) ? (row[parentValuePath.alias] as Value.PrimaryValue) : null,
+						data,
+						defaultValue ?? null,
+					)
 				},
 				addColumn: ({ path = fieldPath, predicate, query, valueGetter }) => {
 					if (predicate === false) {

package/src/mapper/select/SelectHydrator.ts

@@ -5,14 +5,14 @@ import { logger } from '@contember/logger'
 
 type DataPromises = {
 	path: Path
-	parentKeyPath: Path
+	getParentValue: ColumnValueGetter<Value.PrimaryValue | null>
 	data: Promise<SelectNestedData>
 	defaultValue: SelectNestedDefaultValue
 }
 
 type ResolvedData = {
 	path: Path
-	parentKeyPath: Path
+	getParentValue: ColumnValueGetter<Value.PrimaryValue | null>
 	data: SelectNestedData
 	defaultValue: SelectNestedDefaultValue
 }
@@ -34,11 +34,11 @@ export class SelectHydrator {
 
 	public addPromise(
 		path: Path,
-		parentKeyPath: Path,
+		getParentValue: ColumnValueGetter<Value.PrimaryValue | null>,
 		data: Promise<SelectNestedData>,
 		defaultValue: SelectNestedDefaultValue,
 	) {
-		this.promises.push({ path, parentKeyPath, data, defaultValue })
+		this.promises.push({ path, getParentValue, data, defaultValue })
 	}
 
 	public async hydrateGroups(rows: SelectRow[], groupBy: string): Promise<SelectGroupedObjects> {
@@ -87,11 +87,11 @@ export class SelectHydrator {
 			currentObject[last] = this.formatValue(columnPath.getValue(row))
 		}
 
-		for (let { path, parentKeyPath, data, defaultValue } of resolvedData) {
+		for (let { path, getParentValue, data, defaultValue } of resolvedData) {
 			const pathTmp = [...path.path]
 			const last = pathTmp.pop() as string
 			const currentObject = pathTmp.reduce<any>((obj, part) => (obj && obj[part]) || undefined, result)
-			const parentValue = row[parentKeyPath.alias] as Value.PrimaryValue
+			const parentValue = getParentValue(row)
 			if (currentObject) {
 				currentObject[last] = (parentValue ? data[parentValue] : undefined) || defaultValue
 			}
@@ -103,7 +103,7 @@ export class SelectHydrator {
 	private async resolveDataPromises(): Promise<ResolvedData[]> {
 		const results = await Promise.allSettled(this.promises.map(async (it): Promise<ResolvedData> => ({
 			defaultValue: it.defaultValue,
-			parentKeyPath: it.parentKeyPath,
+			getParentValue: it.getParentValue,
 			path: it.path,
 			data: await it.data,
 		})))

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

@@ -0,0 +1,226 @@
+import { c, createSchema } from '@contember/schema-definition'
+import { test } from 'vitest'
+import { execute } from '../../../../../src/test'
+import { GQL, SQL } from '../../../../../src/tags'
+import { PermissionFactory } from '../../../../../../src'
+import { testUuid } from '@contember/engine-api-tester'
+
+
+namespace RelationAclManyHasOne {
+	export const readerRole = c.createRole('reader')
+
+	@c.Allow(readerRole, {
+		read: ['title'],
+	})
+	@c.Allow(readerRole, {
+		when: { discloseAuthor: { eq: true } },
+		read: ['author'],
+	})
+	export class Article {
+		title = c.stringColumn().notNull()
+		author = c.manyHasOne(Author).notNull()
+		discloseAuthor = c.boolColumn().notNull()
+	}
+
+	@c.Allow(readerRole, {
+		read: true,
+	})
+	export class Author {
+		name = c.stringColumn().notNull()
+	}
+}
+
+
+test('can read same entity only over relation of some rows - many has one', async () => {
+	const schema = createSchema(RelationAclManyHasOne)
+
+	const permissions = new PermissionFactory().create(schema, ['reader'])
+
+	await execute({
+		schema: schema.model,
+		permissions: permissions,
+		variables: {},
+		query: GQL`
+        query {
+          listArticle {
+          	title
+          	author {
+				name
+          	}
+          }
+        }`,
+		executes: [
+			{
+				sql: SQL`select "root_"."title" as "root_title", "root_"."disclose_author" = ? as "root___predicate_discloseAuthor_eq_true", "root_"."author_id" as "root_author", "root_"."id" as "root_id" 
+from "public"."article" as "root_"`,
+				response: {
+					rows: [
+						{
+							root_id: testUuid(1),
+							root_title: 'Article A',
+							root___predicate_discloseAuthor_eq_true: true,
+							root_author: testUuid(10),
+						},
+						{
+							root_id: testUuid(2),
+							root_title: 'Article B',
+							root___predicate_discloseAuthor_eq_true: false,
+							root_author: testUuid(10),
+						},
+					],
+				},
+			},
+			{
+				sql: SQL`select "root_"."id" as "root_id", "root_"."name" as "root_name", "root_"."id" as "root_id" from "public"."author" as "root_" where "root_"."id" in (?)`,
+				parameters: [testUuid(10)],
+				response: {
+					rows: [
+						{
+							root_id: testUuid(10),
+							root_name: 'John doe',
+						},
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listArticle: [
+					{
+						title: 'Article A',
+						author: {
+							name: 'John doe',
+						},
+					},
+					{
+						title: 'Article B',
+						author: null,
+					},
+				],
+			},
+		},
+	})
+})
+
+
+
+namespace RelationAclManyHasMany {
+	export const readerRole = c.createRole('reader')
+
+	@c.Allow(readerRole, {
+		read: ['title'],
+	})
+	@c.Allow(readerRole, {
+		when: { discloseAuthor: { eq: true } },
+		read: ['authors'],
+	})
+	export class Article {
+		title = c.stringColumn().notNull()
+		authors = c.manyHasMany(Author)
+		discloseAuthor = c.boolColumn().notNull()
+	}
+
+	@c.Allow(readerRole, {
+		read: true,
+	})
+	export class Author {
+		name = c.stringColumn().notNull()
+	}
+}
+
+
+test('can read same entity only over relation of some rows - many has many', async () => {
+	const schema = createSchema(RelationAclManyHasMany)
+
+	const permissions = new PermissionFactory().create(schema, ['reader'])
+
+	await execute({
+		schema: schema.model,
+		permissions: permissions,
+		variables: {},
+		query: GQL`
+        query {
+          listArticle {
+          	title
+          	authors {
+				name
+          	}
+          }
+        }`,
+		executes: [
+			{
+				sql: SQL`select "root_"."title" as "root_title", "root_"."disclose_author" = ? as "root___predicate_discloseauthor_eq_true", "root_"."id" as "root_id", "root_"."id" as "root_id" 
+from "public"."article" as "root_"`,
+				response: {
+					rows: [
+						{
+							root_id: testUuid(1),
+							root_title: 'Article A',
+							root___predicate_discloseAuthor_eq_true: true,
+						},
+						{
+							root_id: testUuid(2),
+							root_title: 'Article B',
+							root___predicate_discloseAuthor_eq_true: false,
+						},
+					],
+				},
+			},
+			{
+				sql: SQL`select "junction_"."author_id", "junction_"."article_id" from "public"."article_authors" as "junction_" where "junction_"."article_id" in (?)`,
+				parameters: [testUuid(1)],
+				response: {
+					rows: [
+						{
+							article_id: testUuid(1),
+							author_id: testUuid(10),
+						},
+						{
+							article_id: testUuid(1),
+							author_id: testUuid(11),
+						},
+					],
+				},
+			},
+			{
+				sql: SQL`select "root_"."name" as "root_name", "root_"."id" as "root_id" from "public"."author" as "root_" where "root_"."id" in (?, ?)`,
+				parameters: [testUuid(10), testUuid(11)],
+				response: {
+					rows: [
+						{
+							root_id: testUuid(10),
+							root_name: 'John doe',
+						},
+						{
+							root_id: testUuid(11),
+							root_name: 'Jack doe',
+						},
+					],
+				},
+			},
+		],
+		return: {
+			data: {
+				listArticle: [
+					{
+						title: 'Article A',
+						authors: [
+							{
+								name: 'John doe',
+							},
+							{
+								name: 'Jack doe',
+							},
+						],
+					},
+					{
+						title: 'Article B',
+						authors: [],
+					},
+				],
+			},
+		},
+	})
+})
+
+